Add LDFLAGS from envionment to ldflags used for building vm.
Add Float#<=> spec when argument is not a Float
Fix Float#<=> spec. Fixes #1718
Improve concurrent performance by cache locality

There is a bottle neck in SharedState::check_gc_p. It is called from all Ruby
threads and always writes to memory. That invalidates CPU cache and thus,
everything is slowed down.

Actually writing isn't always necessary in this case. It is only when the GC
flag is set. And that situation is unlikely.

This commit removes the bottle neck by avoiding writing. Then, each CPU core
runs at their full speed, not hampered by slow memory fetching due to cache
invalidation.

check_gc_p is heavily called under concurrently-executed tight loops (happen
sometime in the real word, are excised often by people interested in Rubinius's
promised concurrency)

After this commit, each concurrent thread executes a specially synthesized test
code as roughly fast as a single thread. This doesn't indicate that Rubinius
executes Ruby code purely proportional to the number of CPU cores. However it
does that Rubinius runs its core vm and has a potential to run Ruby code at the
speed.

Hello true concurrency :)

I measured performance as follows.

BEFORE THIS COMMIT:
1 thread:
 #<Thread:0x1c id=3 run>: 1.677862 seconds for looping 100000000 times
 #<Thread:0x1c id=3 run>: 1.681874 seconds for looping 100000000 times
 #<Thread:0x1c id=3 run>: 1.682204 seconds for looping 100000000 times
 #<Thread:0x1c id=3 run>: 1.672264 seconds for looping 100000000 times

2 threads:
 #<Thread:0x1c id=4 run>: 4.340247 seconds for looping 100000000 times
 #<Thread:0x24 id=3 run>: 4.443239 seconds for looping 100000000 times
 #<Thread:0x1c id=4 run>: 4.338425 seconds for looping 100000000 times
 #<Thread:0x24 id=3 run>: 4.465941 seconds for looping 100000000 times

AFTER THIS COMMIT:
1 thread:
 #<Thread:0x10 id=3 run>: 1.645313 seconds for looping 100000000 times
 #<Thread:0x10 id=3 run>: 1.640116 seconds for looping 100000000 times
 #<Thread:0x10 id=3 run>: 1.641852 seconds for looping 100000000 times
 #<Thread:0x10 id=3 run>: 1.647724 seconds for looping 100000000 times

2 threads:
 #<Thread:0x10 id=4 run>: 1.764503 seconds for looping 100000000 times
 #<Thread:0x18 id=3 run>: 1.697629 seconds for looping 100000000 times
 #<Thread:0x10 id=4 run>: 1.715689 seconds for looping 100000000 times
 #<Thread:0x10 id=4 run>: 1.702426 seconds for looping 100000000 times

TEST CODE:
loop_count = 100_000_000
threads = 2
threads.times.collect do
  Thread.new do
    loop do
      time = Time.now
      i = loop_count
      i -= 1 until i.zero?
      puts "#{Thread.current}: #{Time.now - time} seconds for looping " +
           "#{loop_count} times"
    end
  end
end.each(&:join)
Merge pull request #1719 from carlosgaldino/float-comparison

Float comparison
Fix an issue that Marshal cannot unmarshal from an IO stream.
Add a spec for marshal.load to unmarshal through StringIO stream into
spec/ruby/core/marshal/shared/load.rb, according to Ryo Onodera's
suggestion.
Merge pull request #1715 from caiquanqing/master

Fix an issue that Marshal cannot unmarshal from an IO stream in 1.9 mode
Adds: Module#public_constant can only be passed constant names defined in the target (self) module.
This commit makes the corresponding spec in
spec/ruby/core/module/public_constant_spec.rb pass.
The error message is the very as issued by MRI Ruby (1.9.3 head).
Merge pull request #1720 from troessner/public_constant_can_only_be_passed_constant_names_defined_in_the_target_self_module

Adds: Module#public_constant can only be passed constant names defined i...
Update 1.9 tags
Update failing tags.

This should fix the build
Add unstable tags.
Add back tag for clean build on Travis
Improve NameError message for Module#public_constant.
Merge pull request #1722 from troessner/improve_name_error_message_for_module_public_constant

Improve NameError message for Module#public_constant.
Use pointer size in Zlib::ZStream#expand_output

More work on issue #1561

expand_output creates a FFI::MemoryPointer of CHUNK size, and used CHUNK
to cleanup the allocated memory.

Now we use FFI::MemoryPointer#total instead of CHUNK to get the real
allocated mmeory size in that pointer.
Add Zlib::ZStream#avail_out=

More work on issue #1561
Return correct source_location for multi-line procs
Remove a tag for a passing spec