rubinius

Version 3.88 (2017-12-31)

• Improve error message on boot. (Brian Shirai)
• Fix CodeDB location for --preserve-prefix. (Brian Shirai)
• Move new CodeDB over bootstrap version. (Brian Shirai)

Version 3.87 (2017-12-30)

• Added boot time stats. (Brian Shirai)

• Added argument to ret instruction. (Brian Shirai)
  This sets space to add return value type caching and nil values tagged
  to method ids.

• Improved CodeDB loading metrics. (Brian Shirai)

• Updated daedalus. (Brian Shirai)
  This will generate the instruction and interpreter files with debug info.

• Removed unwind label. (Brian Shirai)
  The unwind label was an attempt to move the unwind state from runtime to
  compile time. Due to nested unwind blocks, this needs more work.

• Updated libsodium to 1.0.14. (Brian Shirai)

• Added start of CompiledCode#code_id. (Brian Shirai)
  This id is a cryptographic hash of the CompiledCode object that can be
  used by the CodeDB to uniquely identify this object. The code_id can be
  used to lazily load CompiledCode objects when they are going to be run.

• Added CompiledCode#stamp_id. (Brian Shirai)

• Updated rubinius-bridge gem. (Brian Shirai)
  This adds CompiledCode#code_id when compiling under MRI.

• Updated gems. (Brian Shirai)

• Switch to code_id for runtime/core. (Brian Shirai)

• Lazily load core methods from CodeDB. (Brian Shirai)

• Cleaned JIT gen cruft. (Brian Shirai)

• Add rubygems and bytecode compiler to CodeDB. (Brian Shirai)

• Updated AST gem. (Brian Shirai)

• More work on CodeDB being the general compilation cache. (Brian Shirai)

• Load files from CodeDB if they exist. (Brian Shirai)

• Load compiler from CodeDB. (Brian Shirai)

• Add lambda version of logger functions. (Brian Shirai)
  This enables deferring potentially costly operations because of
  call-by-value that would not be needed if the log level is below the
  level of the logging call.

• Add logging to CodeDB. (Brian Shirai)

• Slightly better loading from CodeDB. (Brian Shirai)

• Start migrating from runtime/ to CodeDB. (Brian Shirai)

• Build and use CodeDB for library code. (Brian Shirai)

• Remove library from default $LOAD_PATH. (Brian Shirai)

• Add missing push_file insn files. (Brian Shirai)

• Copy non-Ruby files to CodeDB source. (Brian Shirai)
  This is mostly for RubyGems but it's conceivable other library code may
  have supporting files.

• Improved build C-exts for Ruby library. (Brian Shirai)

• Don't overwrite CodeDB cache with nothing. (Brian Shirai)

• Remove Converter path caching cruft. (Brian Shirai)
  The cache mechanism was quite blunt and was not even in use. It can be
  replaced with something that works better, but no reason to have the
  unused code in the repo.

• Add deprecations for Rubinius::{RUNTIME, CORE}_PATH. (Brian Shirai)

• Don't segv the process if CodeDB is missing, corrupt. (Brian Shirai)

• Added archdir, removed thens. (Brian Shirai)

• Use fittest fixture in Enumerable#each_entry spec (Kenichi Kamiya)

• Fix Enumerable#each_entry with no yield arguments (Kenichi Kamiya)

• Remove an outdated tag (Kenichi Kamiya)

1. This spec was tagged in https://github.com/rubinius/rubinius/pull/3581.
2. Fixed via https://github.com/rubinius/rubinius/commit/8b7d91bfb92c363b61bbf049104587e91e5b893a

• Add specs around Enumerator#dup (Kenichi Kamiya)

• Fix Enumerator#dup on iterating enumerators (Kenichi Kamiya)

• Add a spec to ensure Enumerator#peek_values identity (Kenichi Kamiya)

• Fix Enumerator#peek_values identity for multiple arguments (Kenichi Kamiya)

• Add specs for Enumerator#initialize with special size (Kenichi Kamiya)

• Ensure to set integer for Enumerator#size (Kenichi Kamiya)

• Drop Enumerable:: namespace for Enumerator (Kenichi Kamiya)
  We can drop this since dropped 18x supports

• Fix Regexp.union behavior on optional left parenthesis (Artyom Khramov)
  Regexp::SourceParcer always treats left parenthesis as a beginning of
  a group. However, the parenthesis can be escaped and this case is
  unhandled.

This change tweaks the Regexp::SourceParcer#create_parts method to
handle this case.

• A dark journey through the twisted woods of Ruby code loading. (Brian Shirai)
  The Rubinius CodeDB is a caching mechanism for executable resources.
  There are various kinds of Resources, with the following defined
  currently:

1. Script - a resource described by a path on the command line.
2. CodeModule - a source code resource loaded by Kernel#load.
3. Feature - a source code resource loaded by Kernel#require.
4. Library - a shared library resource loaded by Kernel#require.

Other sorts of resources that are plausible include AST, LLVM IR, shared
libraries, and machine code functions.

The CodeDB cache presumes a source (eg filesystem) for resources. A
resource is the CodeDB can be represented by two attributes (purgeable
or unpurgeable) and three states (cached, uncached, nonexistent).

A resource is a mapping from a "stem" in a "context" (eg $LOAD_PATH,
$LOADED_FEATURES) to the cache or filesystem. The naming of the resource
is a string of the form "#{prefix}#{stem}#{extension}" where both prefix
and extension may be empty strings. The full string is the feature.

The following state machine describes loading a resource that exists in
the cache:

   +---------+   True       +-------------+   False    /------------\
   | loaded? | ---------->  | reload flag | ---------> | Don't load |
   +---------+              +-------------+            \------------/
        |                          |                          ^
        | False                    | True                     |
        |                          |                          |
        +--------------------------+                          |
        |                                                     |
        v                                                     |
  +------------+   False    /------\                          |
  | purgeable? | ---------> | Load |                          |
  +------------+            \------/                          |
        |                      ^                              |
        | True                 |                              |
        |                      |                              |
        v                      |                              |
  +-------------+              |                              |
  | prefix in   |  False       |                              |
  | $LOAD_PATH? | ------------- )-----------------------------+
  +-------------+              |                              |
        |                      |                              |
        | True                 |                              |
        |                      |                              |
        v                      |                              |
  +----------------+           |                              |
  | feature exists | False     |                              |
  | on filesystem? | ---------- )-----------------------------+
  +----------------+           |                              |
        |                      |                              |
        | True                 |                              |
        |                      |                              |
        v                      |                              |
  +---------------+            |                              |
  | cache mtime > | False      |                              |
  | file mtime?   | ----------- )-----------------------------+
  +---------------+            |
        |                      |
        | True                 |
        |                      |
        +----------------------+

• Fix compiler warning. (Brian Shirai)
• Fixed CodeDB call. (Brian Shirai)
• Add start of caching at runtime to CodeDB. (Brian Shirai)
• Copy core CodeDB to cached CodeDB on boot. (Brian Shirai)
• Ensure cached CodeDB is current. (Brian Shirai)
• Write CompiledCode objects to CodeDB. (Brian Shirai)
• Write updated CodeDB to file system on halt. (Brian Shirai)
• Don't cache on Travis; it won't be used. (Brian Shirai)
• Convert CodeDB to a single file. (Brian Shirai)
  The CodeDB cache meets three constraints:

1. easy to lock for concurrent access;
2. easy to mmap for low latency;
3. easy to update the data wihout writing a lot of data.

The single file is composed of the following regions:

1. header includes the file magic, cache version, signature, and region
   sizes;
2. list of code IDs to run when initializing the system from this cache;
3. the code itself in serialized form (data);
4. the index of code IDs to data offset and length;
5. the contents mapping files to code IDs of the file execution context.

When the cache is opened, the data region is mmap'd for low latency
access to loading code. The index and contents regions are read into
in-memory map structures.

When the cache is used in a read-write mode, on close, the new data is
appended to the existing data by writing only the new data at the end of
the data region. The index and contents maps are then written to the new
index and contents regions after the data region.

• Build using CodeDB cache. (Brian Shirai)

• Removed Bundler from build. (Brian Shirai)

• Removed remnants of Bundler, RedCard. (Brian Shirai)

• Temporary gem install daedalus. (Brian Shirai)

• Prepare for new build system. (Brian Shirai)

• Moved codegen scripts to build/scripts. (Brian Shirai)

• Move config.rb to build/config. (Brian Shirai)
  This file will be replaced by a non-Ruby dictionary of configured and
  default values for building Rubinius.

• Always build in a staging directory. (Brian Shirai)

• Fix assumptions about file locations during build. (Brian Shirai)

• Fix missed path. (Brian Shirai)

• Moved vendor/ to build/libraries. (Brian Shirai)

• Temporarily pull daedalus in for rewrite. (Brian Shirai)

• Move all build artifacts to build/artifacts. (Brian Shirai)

• Start moving generated files out of machine/gen. (Brian Shirai)

• Fix looping build. (Brian Shirai)

• Finish moving generated code to source dir. (Brian Shirai)

• Move config.guess to build/bin. (Brian Shirai)

• Update README. (Brian Shirai)

• Removed GlobalCache. (Brian Shirai)
  This is part of a three-step process:

1. Remove this global cache
2. Rework inline cache to not require that superclasses keep track of
   subclasses.
3. Evaluate whether an additional layer of caching before inline caching
   is generally useful.

• Create new CodeDB cache when building. (Brian Shirai)

• Properly scope Thread constant. Fixes #3773. (Brian Shirai)

• Guard access to Fiber's Thread. Fixes #3772. (Brian Shirai)
  The Fiber's Thread can disappear any time the Fiber has been suspended.

• Set Rubinius::Signature in the VM. (Brian Shirai)

• Fixed Thread{.#}abort_on_exception specs. (Brian Shirai)

• Don't overwrite CodeDB cache in use. (Brian Shirai)

• Don't trigger exception unwind for no exception. (Brian Shirai)

• Set ENV for build Melbourne. (Brian Shirai)
  The Rubinius core library currently includes Ruby code that sets the
  platform and machine-specific configuration values that are then used to
  build C-extensions like Melbourne. To build these from the bootstrap
  CodeDB cache but still use the machine-specific values, we inject them
  into the environment when building Melbourne.

• Remove use of SecureRandom. (Brian Shirai)
  This also assigns a random code_id to a CompiledCode object. In the
  future, the code_id will be assigned based on the serialized form of the
  CompiledCode object to better represent the uniqueness of a particular
  instance but also be stable (with a seed) to enable using the code_id as
  a key for associating other data.

• Tweak definition of Diagnostics class. (Brian Shirai)

• Add start of new inline cache validation. (Brian Shirai)

• Invalidate inline caches. (Brian Shirai)

• Removed more remnants of old cache invalidation. (Brian Shirai)

• Improved use of inline cache. (Brian Shirai)

• Add core/prediction.rb. (Brian Shirai)

• Add info to seek failure message. (Brian Shirai)

• Roll back class_data change. (Brian Shirai)

• Try reverting it all. (Brian Shirai)
  The Travis failures are not reproducible locally on a Trusty64 virtualbox VM.

• Re-apply some inline cache changes. (Brian Shirai)

• Re-apply more inline cache changes. (Brian Shirai)

• Disable evictions. (Brian Shirai)

• Revert "Disable evictions." (Brian Shirai)
  This reverts commit e25512ed8707d2555a722392d5a6c6a5ae1167d9.

• Disable replacing inline cache. (Brian Shirai)

• Revert "Re-apply more inline cache changes." (Brian Shirai)
  This reverts commit e281c579b9482d454df834cce5e75f2b83b25a55.

• Start consolidating under diagnostics. (Brian Shirai)

• Add MethodPrediction. (Brian Shirai)

• Remove abort from legacy util/thread. (Brian Shirai)

• Rework CallSite caching. (Brian Shirai)
  This restructures CallSite and the inline caching concepts slightly from
  the previous implementation.

A CallSite is a location in the source code where another method is
invoked. A CallSite may or may not have a cache.

A CallSite tracks every time it is invoked. The default invocation of a
CallSite that has never been invoked does not cause the first method to
be cached. This is to avoid caching methods that will only be inovked
once.

A CallSite cache has a max size. New cache entries are always added at
the front of the list of cache entries. During a garbage collection
cycle, invalid cache entries are evicted and the list of entries is
re-ordered so that more "efficient" caches occur in the list before less
efficient ones. The efficiency is calculated as (h / (h + m) * h), where
h is hits, m is misses, and the scaling by h is intended to more
realistically represent cases like 100/100 and 2/2. The former is more
"efficient" (ie more likely to be hit) than the latter.

A CallSite that has frequently evicted cache entries is likely
megamorphic and will not benefit from caching as the cost of mutating
the cache and iterating to find a possibly matching entry outweighs just
dispatching to the method. In this case, the CallSite will disable
caching and just dispatch every time the CallSite is invoked.

• Ensure ThreadNexus threads_mutex is unlocked after fork(). (Brian Shirai)

• Elaborate Fiber#transfer exception message. (Brian Shirai)

• Comment deopt code temporarily. (Brian Shirai)

• Mask ESPIPE on terminal device. (Brian Shirai)

• Fix Fiber#transfer error message. (Brian Shirai)

• Revert "Mask ESPIPE on terminal device." (Brian Shirai)
  This reverts commit c02010846b5844edd1a1313d28299d369158e767.

• Try rescue on rewind for File#reopen. (Brian Shirai)

• Pre-install some gems (again). (Brian Shirai)

• Set root Fiber's Thread attribute correctly. Fixes #3776. (Brian Shirai)

• Temporarily tag Thread#join specs that segv. (Brian Shirai)

• Migrate a few more things to C++11 concurrency features. (Brian Shirai)

• Add codedb/source to LOAD_PATH for IRB. (Brian Shirai)
  Alternatively, we could remove every last trace of IRB code, but that
  will admittedly take slightly longer to complete.

Why remove it? Because IRB does stuff like implement its own code
loading mechanism instead of using load or require, which makes it
impossible to extend functionality behind load and require, like the
CodeDB does. In other words, things like IRB are why can't have nice
things. We need to be rid of things like IRB.

• Added 'optflags' to RbConfig. (Brian Shirai)
• Update packaging for codedb. (Brian Shirai)
• Fixed configure. (Brian Shirai)
• Fixed path when --preserve-prefix is used. (Brian Shirai)
• Fixed Heroku release name. (Brian Shirai)

Version 3.86 (2017-09-27)

• Added stubs for remaining instruction specs. (Brian Shirai)
• Retire insns/interp machine tests. (Brian Shirai)
  Since starting on the new interpreter and instruction set, WebAssembly has
  been officially adopted by all major browser vendors and has become a
  legitimate implementation target.

To facilitate transitioning to multiple VM targets, the instruction set needs
to be specified in a format that is target-independent. The spec/instructions
specs are a reasonable intermediate target, but are also a step towards a
language-neutral textual asm format and assembler that will provide complete
targe independence.

• Removed old interpreter. (Brian Shirai)
• fixed zsuper instruction for keyword arguments and arguments placeholder (Andrew Aladjev)
• improved specs for super arguments (Andrew Aladjev)

Version 3.85 (2017-09-24)

• Fixed running ensure in new interpreter. (Brian Shirai)
• Fixed new interpreter for break. (Brian Shirai)
• Added interpreter spec for return in block. (Brian Shirai)
• Added logging when creating experimental interpreter. (Brian Shirai)
• Fixed raise_exc, raise_return insn interpreters. (Brian Shirai)
• Added configuration switch for experimental interpreter. (Brian Shirai)
• Reworked handling unwinds in new interpreter. (Brian Shirai)
• Updated daedalus. (Brian Shirai)
• Fixed interpreter vm tests. (Brian Shirai)
• Rename run_exception insn. (Brian Shirai)
• Updated rubinius-compiler gem. (Brian Shirai)
• Reworked run_exception instruction as unwind. (Brian Shirai)
• Add unwind check to bytecode verifier. (Brian Shirai)
• Bumped compiler and AST versions. (Brian Shirai)
• Fixes for unwind instruction. (Brian Shirai)
• Added basic UnwindSite caching. (Brian Shirai)
• Use UnwindSite for unwinding the call stack. (Brian Shirai)
• Set up CallFrame for instruction tests. (Brian Shirai)
• Updated compiler version. (Brian Shirai)
• Fixed more new interpreter insns for unwind. (Brian Shirai)
• Updated daedalus. (Brian Shirai)
• Fixed handling return value in new interpreter. (Brian Shirai)
• Fixed setting call flags in new interpreter. (Brian Shirai)
• Fixed storing literals in new interpreter. (Brian Shirai)
• Fixed unwind in new interpreter. (Brian Shirai)
• Fixed break in new interpreter. (Brian Shirai)
• Temporary fix for IP to line in new interpreter. (Brian Shirai)
• Enable experimental interpreter for CI. (Brian Shirai)
• Updated gems_list.txt. (Brian Shirai)

Version 3.84 (2017-08-02)

• Added start of instruction specs. (Brian Shirai)
• Use new interpreter for instruction specs. (Brian Shirai)
• Add example branch instruction spec. (Brian Shirai)
• Added basic run_exception insn spec. (Brian Shirai)
• Added exception rescue spec. (Brian Shirai)
• Added rb_hash_fetch C-API. Closes #3753. (Brian Shirai)

Version 3.83 (2017-07-26)

• Fix a typo in the GitHub issue template (#3750) (Jos Ahrens)
  Corrects a typo 'issued' -> 'issue' in 8.c

• Add Random::DEFAULT as an instance of Random (#3752) (Lin Jen-Shin (godfat))
  This is basically for MRI compatibility. This could be verified by:

  ruby -ve 'p ObjectSpace.each_object(Random).to_a == [Random::DEFAULT]'
  ruby 2.4.1p111 (2017-03-22 revision 58053) [x86_64-linux]
  true

Closes https://github.com/rubinius/rubinius/issues/3296

Version 3.82 (2017-06-27)

• For rubinius/rubinius#3747 (#3748) (NightFeather)
  when stop is nil or omitted,
  should be set to infinity_value,
  and sign would be same with step.

I don't know a better way the cover this in spec though

• Remove unneeded specs. (Brian Shirai)
  Specs should positively test values or state changes. There is an infinite
  number of ways code could not raise an error, so asserting a value created or
  state changed is the preferred way to write specs.

• Attempt to work around broken Travis image. (Brian Shirai)
  The Travis Trusty image update fails to set STDOUT as a TTY.

• Revert "Attempt to work around broken Travis image." (Brian Shirai)
  This reverts commit 96887debc1b51ebe68fa9299577c6684858e1748.

• Guard TTY spec. (Brian Shirai)
  Travis CI sporadically breaks their images such that STDOUT isn't a TTY.

Version 3.81 (2017-06-09)

• Extract Array#{inspect, to_s} object inspect. (Brian Shirai)
• Fixed Hash#{inspect, to_s}. (Brian Shirai)

Version 3.80 (2017-06-09)

• Fixed Array#{inspect, to_s}. Fixes #3746. (Brian Shirai)

Version 3.79 (2017-06-01)

• Kernel: allow caller{,_locations} to accept a Range (#3745) (Tamir Duberstein)
  Closes #3744.

Version 3.78 (2017-05-16)

• Fix nil.rb. Closes #3740. (Brian Shirai)
• Added UncaughtThrowError#tag. Fixes #3742. (Brian Shirai)
• Add new GitHub token. (Brian Shirai)

Version 3.77 (2017-05-06)

• Added basic &. specs. (Brian Shirai)
• Update Rubinius processor for a&.m = b. Fixes #3739. (Brian Shirai)

Version 3.76 (2017-05-06)

• Fixed Fiber.yield not propagating rescued exception. Fixes #3706. (Brian Shirai)
• Tag timezone spec failing on macOS. (Brian Shirai)
• Removed rubinius::bug usage from FinalizerThread. (Brian Shirai)
• Reworked Fiber::cancel. (Brian Shirai)

Version 3.75 (2017-04-22)

• Fixed spawning subprocess from Fiber. Fixes #3725. (Brian Shirai)
• Disallow fork() from non-root Fiber. Related to #3725. (Brian Shirai)
  In Rubinius, Fiber is composed with a native OS thread. A consequence of this
  is that when fork() is called, only the current OS thread is carried over to
  the new process.

This contrasts with implementing Fiber as a user-mode "stack" that is
multiplexed onto a single OS thread. In this case, all the data from multiple
Fibers are carried over to the new process with the OS thread executing the
fork() system call.

The user-mode "stack" implementation has a significant drawback in not being
reliably portable across systems (eg porting to WebAssembly would not permit
physically modifying a "thread" stack). Additionally, this approach obscures
the program's operation from the OS scheduler and complicates debugging the
process.

The advantages of composing Fiber with a first-class OS thread are the
opposite. They are completely portable, they offer the OS clear visibility
into the operation of the program, they inspectable by debuggers, and the
resource overhead is as readily controllable as with user-mode "stack" Fibers.

The drawbacks of the user-mode "stack" approach are significant, so Rubinius
has chosen to implement Fiber using first-class OS threads. This makes use of
Fiber incompatible with using fork(). However, Fiber is nothing more than a
limited Thread, and since Rubinius gives full control over the resources
allocated for Thread, Fiber offers no significant advantage over Thread aside
from the abstraction of the single lock associated with all the Fibers on a
Thread that guarantees serial execution of all Fiber code. This could be
mimicked by pure Ruby code and instances of Thread.

Since the use case of Fiber and fork() are mostly distinct, the limitation of
not being able to call fork() from a non-root Fiber is considered an
acceptable trade-off for the advantages of proper OS thread support of Fiber.

• Cleaned up Thread init_lock. (Brian Shirai)
  At one time, starting a Thread used a lock and this naming was a relic of
  that. Now creating a Thread is properly sequenced and does not need a lock.

Also, this lock is used at execution leaf nodes around state and when no
fork() can be active, so re-init'ing the lock on process transitions is not
necessary.

• Simplify MachineThreads. (Brian Shirai)
  MachineThreads was introduced when state control around fork/exec was ad hoc
  and scattered. The boundaries were also not well-defined and there were
  numerous race conditions.

The boundaries are now much better defined and some of the 'events' have not
been needed. There is more restructuring needed and if the removed events turn
out to be required, they can be re-added.

Version 3.74 (2017-04-16)

• Update rake version. Closes #3704. (Brian Shirai)
• Updated gems. (Brian Shirai)
• Update Melbourne. (Brian Shirai)

Version 3.73 (2017-03-31)

• Added deprecation for Executable#primitive. (Brian Shirai)
• Added Executable#tags. (Brian Shirai)
• Added Executable#tags. (Brian Shirai)
• Added {Bignum, Fixnum}.bit_length. Fixes #3728. (Brian Shirai)
• Fixed Math.log2 for huge Bignums. (Brian Shirai)

Version 3.72 (2017-02-21)

• make sure errno from child process is preserved (Chuck Remes)
• preserve errno for backtick child subprocesses (Chuck Remes)
• add tests for instructions:ret (Chuck Remes)
• mock module that handles +const_missing+ call (Chuck Remes)
• add tests for instructions::find_const (Chuck Remes)
• add tests for instructions::push_const (Chuck Remes)
• use 'nation/city' format for timezone names so offsets are looked up properly (Chuck Remes)
• remove separate code branch for OpenBSD and FreeBSD Both BSDs deprecated and removed the timelocal function several releases ago. They now use mktime just like most every other UNIX OS. (Chuck Remes)

Version 3.71 (2017-02-09)

• add tests for instructions::send_method (Chuck Remes)
• add tests for instructions::send_stack (Chuck Remes)
• add test for instructions::send_stack_with_block (Chuck Remes)
• add test for instructions::rotate (Chuck Remes)
• add work in progress test for instructions::send_vcall (Chuck Remes)
• better tests for instructions::send_stack (Chuck Remes)
  The test_send_stack_execute_returns_null tests the situation where
  no value is returned from the method, e.g. nullptr.

Second test test_send_stack_method_no_method_error tests code path
where the method is not found and raises a NoMethodError. This had
the side effect of leaving arguments on the stack. This is a
problem that requires a bug fix to the instruction.

• clean up stack before trying to execute method (Chuck Remes)
• verify stack is cleaned up before NoMethodError raised (Chuck Remes)
• clean up stack before executing method in case it raises error (Chuck Remes)
• test to verify handling of method returning nullptr (Chuck Remes)
• verify stack is cleaned up when NoMethodError raised (Chuck Remes)
• clean up stack before executing method (Chuck Remes)
• handle method that returns nullptr properly (Chuck Remes)
• test for stack cleanup on instructions::send_stack_with_splat when NoMethodError raised (Chuck Remes)
• clean up stack before executing method (Chuck Remes)
• finish other tests for instructions::send_stack_with_splat (Chuck Remes)
• free allocated buffes on an early return to prevent memory leak (Chuck Remes)
• allow for scan-build to substitute CC and CXX compilers (Chuck Remes)
• fix typo (Chuck Remes)
• add tests for instructions::send_super_stack_with_block (Chuck Remes)
• clean up stack prior to calling method that may raise exception (Chuck Remes)
• add tests for instructions::send_super_stack_with_splat (Chuck Remes)
• verify stack cleared before method call that could raise exception (Chuck Remes)
• add tests for instructions::send_vcall (Chuck Remes)
• add test for instructions::set_const (Chuck Remes)
• add test for instructions::set_const_at (Chuck Remes)
• add tests for instructions::set_ivar (Chuck Remes)
• add tests for instructions:::set_local, set_stack_local, and store_my_field (Chuck Remes)
• compatible with musl libc (SquallATF)
  Mapping unsigned to uint to compatible with musl libc
• freebsd supports birthtime so test for it (Chuck Remes)
• update US/Eastern to use modern zone terminoloy America/New_York (Chuck Remes)
• fix two small FFI bugs (Chuck Remes)
  Bug 1 was trying to find the string index of the integer 0. For this
  to work the system calls :to_str on the Fixnum which fails. The fix
  is to specify the nul string explicitly.

Bug 2 was more of an issue of convenience. The FFI.config facility
builds FFI::Struct class layouts from data in runtime/platform.conf.
Some structs have char arrays. The original code allocated the proper
space but it did not associate an array with a :char_array field.
Therefore trying to access the field to assign to it directly did
not work.
e.g.
struct = RubySL::Socket::Foreign::SockaddrUn.new
struct[:sun_path] = "/some/path" # failed!
This fix allows the direct assignment of string fields built using
the FFI.config convenience method.

• start work on yield_stack instruction (Chuck Remes)
• update gems list to include rubysl-socket 2.2.1 (Chuck Remes)
• rescue subprocess EPIPE so we do not see unnecessary backtrace during spec run (Chuck Remes)

Version 3.70 (2017-01-24)

Version 3.69 (2016-11-17)

• fix case where IO#gets blocks forever on read to char boundary (Chuck Remes)
  This was a tough one. WEBrick would hang when reading an HTTP
  header. The cause was that IO::EachReader#read_to_separator_with_limit
  blocked forever trying to "peek ahead" to ensure we are reading
  to the end of a proper character boundary. In this case the socket
  had no more data to recv but it also does not set EOF, therefore
  the read blocked indefinitely. The simple fix was to move to a
  non-blocking read and skip the read entirely if the string
  already had a valid encoding. However, this broke several specs
  for reading multi-byte chars. To resolve that problem required
  making sure that when read_nonblock returned an empty buffer that
  this buffer was set to ASCII_8BIT instead of whatever the default
  external coding was set to (usually UTF-8). The fixes are all
  relatively simple but it took many hours to chase this down and
  figure out the minimal approach to fix it.
• DRY up allocation of 8-bit string buffers (Chuck Remes)