Add a spec for $! inside at_exit{ }
Always allow at_exit handlers access to $!

Prior to this change only SystemExit's were made available in at_exit.

(git diff -w)
Fix BlockArgument bytecode generation
Use CPPFLAGS and LDFLAGS when checking libraries, after all, they are also used afterwards for the real compilation and linking.
Use CXXFLAGS instead of CFLAGS when compiling c++.
Use clang compile flag fix if using clang. Closes #1876.
Merge pull request #1879 from r-stu31/configure_flags

configure: add CPPFLAGS and LDFLAGS where missing
Make sure to parse options before starting the first VM
Add specs for rb_catch
Add specs for rb_throw_obj and rb_catch_obj
Add rb_catch and in 1.9 mode rb_catch_obj and rb_throw_obj
Add specs for rb_iter_break
Implement rb_iter_break()
Renamed VMMethod to MachineCode.

This was a difficult name choice but it is consistent with CompiledCode
and (not yet used) SourceCode. The CompiledCode is an abstraction of
computation that is the focal point around which much revolves. MachineCode
is a representation of computation specialized for our (virtual) machine.

While there is possible ambiguity against the idea of JIT'd machine code,
our MachineCode is a proper data structure, not just the format of bits
resulting from the JIT compilation process. Also, our MachineCode is properly
scoped differently than any such class/concept in LLVM (or more generally,
the JIT).

Regarding naming of instances of MachineCode, the following rationale is used:

* parameters/variables have been named 'mcode' since the use of the variable
  is elaborated by the surrounding code (ie making ambiguity less an issue)
  and long variable names can sometimes make code unweildy.
* attributes/fields/accessors have been name 'machine_code' because they have
  less context to disambiguate.
Cleaned up debris from CompiledMethod rename.
Add spec for BlockArgument bytecode generation
Fix timing issue of Thread#kill and sleep

In some cases, a thread isn't correctly killed by Thread#kill. If that is the
case, Thread#join on that thread leads to the deadlock.

Consider the following example:

    thread = Thread.new do
      sleep
    end
    thread.kill # actually, don't kill
    thread.join # thread lives forever; deadlock

Thread#kill does 2 things to kill a thread:
    1. prepares the thread to be terminated and
    2. wakes up the thread.

Most of time, the wake-up is executed after the sleep in the killed thread.

However, it is possible the wake-up is executed BEFORE the sleep in some rare
cases. If that is the case, the wake-up does nothing because the thread is
still waking up at that time. Then, the thread begins to sleep forever. As a
result, Thread#join never returns.

To avoid such a deadlock, Thread#sleep must check to terminate or not before
actually sleeping. In addition, it must be asssured that the wake-up isn't
executed AFTER the check BEFORE the sleep.

The follwing diagrams illustrate the good and bad timings.

Good timings:

                 Time
                 ------------------------------------------------------>
    main thread  prepare - wakeup (no-op) |
    new thread                            | check - no sleep - terminate

                 Time
                 ------------------------------------------------------>
    main thread                | prepare - wake-up |
    new thread   check - sleep |                   | terminate

                 Time
                 ------------------------------------------------------>
    main thread        | prepare |       | wake-up |
    new thread   check |         | sleep |         | terminate

Bad timing:

                 Time
                 ------------------------------------------------------>
    main thread        | prepare - wake-up (no-op) |
    new thread   check |                           | sleep forever

To fix the deadlock, this commit makes check_async be called before sleeping
inside the park mutex.
Add a spec for dead lock by Thread#kill and sleep
Merge pull request #1884 from ryoqun/thread-join-deadlock

Fix Thread#join deadlock from use of Thread#kill and sleep
Revert "Add a spec for dead lock by Thread#kill and sleep"

This reverts commit de62854548920f9d49f11da7ba026655bfd9d69e.