Add FFI::Platform.windows?
Add FFI::Platform.windows? spec
Add FFI::Platform specs
Fix the it labels for FFI::Platform specs (darwin)
Fix signing issue with Fixnums in the JIT

Previously we were using LLVM's lshr instruction, which is defined as:

The 'lshr' instruction (logical shift right) returns the first operand
shifted to the right a specified number of bits with zero fill.

This means it doesn't consider the sign bit. This means that parts in
the JIT that were using this, could cause wrong numbers to be created if
a negative fixnum was shifted so it could be used as a normal number.

Therefore we need to switch to using 'ashr', which does consider the
sign bit:

The 'ashr' instruction (arithmetic shift right) returns the first
operand shifted to the right a specified number of bits with sign
extension.

This change however, exposed another issue. In the tuple handling we
checked whether a fixnum was not too big for the tuple, but not whether
it was positive. This was not a problem before because of the signedness
issue, it would end up as a very big number that was outside the tuple
anyway. Because of switching to 'ashr', we need a better check.

For these better checks we create some helpers, because the check
whether a number of two numbers are positive are needed in a few more
places, such as fixnum_div and fixnum_mod. Using these helpers also
cleans up the code there.
Use regular additions for Fixnum addition and subtraction

Previously we used 63 bit computation with overflows. This however as
slightly different semantics than our Fixnum, because our Fixnum::MIN is
not the same. This would mean that in the JIT a value of Fixnum::MIN - 1
would come out as a fixnum.

Since for multiplication we need these checks anyway, since in LLVM 3.0
i63 with overflow multiplication is broken, we reuse this code for the
addition and subtraction case here. We also immediately promote to
bignum now if it doesn't fit so we don't recompute the value in the
send. This provides a small performance improvement for the case where
Fixnum +/- Fixnum results in a Bignum:

Before:
Fixnum - Fixnum => Bignum
                      6590050.7 (±12.2%) i/s -   32387040 in   5.009288s (cycle=192780)

After:
Fixnum - Fixnum => Bignum
                      6963561.3 (±4.7%) i/s -   34828744 in   5.015573s (cycle=192424)
Don't emit exception checks if inline code doesn't raise

If we know that the inlined code doesn't raise an exception, we don't
need the check. We already did that for the case where the inline used
an uncommon exit for the failure case, but not when the fallback was a
regular send. In that case we always checked for an exception, instead
of just doing this after the send.
Switch String::hash_str to use Siphash to defeat Hash DOS attempts
Fix size error on 32bit
Updated String#splice! internal specs.
String#splice! improvements.
String#[]= fixes.
String#index encoding specs.
Added Rubinius::Mirror.
Added Mirror::String#character_index. Fixed 1.9 String#index.
Don't depend on #rest_size in StringScanner#size. Fixes #2072.

This library needs to be fixed to better encapsulate internal state since
code like Sass::Util::MultibyteStringScanner is written against MRI where C
implementation make it impossible to use good OO composition and also makes
it possible to write very badly behaving Ruby code.
Add spec for overwriting a specialized Struct method through a module

In Rubinius we specialize certain methods for Structs. These however,
need to be overwritable by including a module. This adds a spec for this
case.
Setup Struct specialization through a module

This allows for overwriting the specialized functions by including a
module into the struct class. This is done for example in parts of
Datamapper 2.
Improve LLVM's ability to reason about data layout

We need to explicitly set the data layout for the LLVM module we use to
compile JIT'ted methods. This allows for example the GVN pass to better
optimize certain cases. One case in this example is:

def method
  1 + 1
  nil
end

Previously LLVM was not able to see through this and completely
eliminate the 1 + 1, with these changes it's able to do so. We also use
the PassManagerBuilder to setup a default set of first passes, similar
to what -O2 means in clang.