rubinius

Version 3.68 (2016-11-10)

• Use llvm-config --libs instead of --libfiles. (Brian Shirai)

Version 3.67 (2016-11-08)

• Catch C++ exceptions sooner. (Brian Shirai)
  We attempt to catch C++ exceptions as close to where they occur as possible.
  This means at the last executed managed code (eg method) so that as much
  context as possible can be given.
• Added extra C++ exception catch to new interpreter. (Brian Shirai)

Version 3.66 (2016-11-07)

• Fixed Bundler, brew wars. (Brian Shirai)
• Fixed setting ThreadGroup for signal handler Thread. (Brian Shirai)
  In Rubinius, trapped signals are handled in a dedicated Thread.

In Ruby, the Thread where a signal is processed isn't defined, but the
assumption is that the signal handler runs in Thread.main (as observed in Ruby
behavior).

Also undefined in Ruby is what ThreadGroup a Thread created in a signal
handler should be added to. Going with the assumption that the signal handler
proc is run in Thread.main, we assume the new Thread should be added to
Thread.main.group.

We now set the signal handler Thread's group to the same group as Thread.main,
so that threads created in a signal handler proc have a group and are added to
a group.

• Better backtrace rendering for copy-paste. (Brian Shirai)
  Rubinius renders backtraces with the receiver+method right justified and the
  source location trailing. Previously, the source location was split when
  exceeding the available terminal width to avoid cluttering the left side where
  the receiver+method was rendered to aid visibility of the most important
  backtrace information.

Unfortunately, splitting up the source location makes copy-pasting the path to
edit a source file very tedious.

Now, the source location is rendered as an unbroken sequence of characters but
starting on a new line if the total backtrace line exceeds the terminal width.
This preserves the readability of the receiver+method, while also preserving
the ability to copy-paste the source location.

• Improved backtrace rendering contrast. (Brian Shirai)
  Rubinius introduced colorized backtraces to improve readability.

Unfortunately, color is problematic due to the perception of colors and the
interaction of color with terminal colors, which something which Rubinius has
no control over.

The goal of readability in backtraces is an important one. There are two
primary pieces of information in each backtrace line: 1. receiver+method; and
2. source code location, file+line number.

The current rendering approach is to bold the receiver+method and separate the
source line on a new line when the total backtrace line exceeds the terminal
width. This provides contrast that improves scanning the backtrace on primary
information, the receiver+method, and easily selecting secondary information,
the source location, when necessary.

• Align method names in backtrace. (Brian Shirai)
  It is a very common convention (in Rubinius, at least) to fully render a
  method as 'A::B::C{#, .}name', where A::B:: is an optional namespace and C is
  the class of the receiver and # indicates an instance method, while .
  indicates a module method.

As such, this convention carries over without much question to rendering
backtraces. However, the context of consuming a backtrace requires different
conventions, but ones that are not foreign.

So, for rendering backtraces, the conventions are retained but the ordering is
changed slightly to improve processing the information. There are now four
basic components to a backtrace line (for an object-oriented method): 1. the
method name; 2. the instance/module indicator; 3. the fully-scoped receiver
name; and 4. the source code location.

The first thing that needs to be located and digested is the method name, so
the method names are right aligned allowing both easily reading the method
name and quick indexing for the second important piece of information, the
receiver name. The source location trails and may be on a new line if the
total backtrace line rendering exceeds the terminal width.

This rendering better orders information in the backtrace based on the
hierarchy of important information (method name > instance/module indicator >
receiver name > source location). It also balances the tensions between making
an individual line of a backtrace readable and making the whole thing
scannable and readable. When rendering the full method name as A::B::C#name,
the variability of the A::B::C component pushed many names too far to the
right, leaving a very jagged left edge that is more difficult to scan, as well
as burying the method name (the primary element) embedded in the middle of a
bunch of character noise.

• Fixed rendering method name. (Brian Shirai)

Version 3.65 (2016-11-01)

• Added C-API rb_memhash. (Brian Shirai)
• Updated rubysl-openssl version. (Brian Shirai)
• Updates to issues/PR templates. (Brian Shirai)
• Try putting README.md under .github. (Brian Shirai)
• Revert "Try putting README.md under .github." (Brian Shirai)
  This reverts commit 320f5045f09473125dad16091f54c15769ed2430.
• Updated README. (Brian Shirai)
• Don't use enum as last arg for varargs. /ht @heftig. (Brian Shirai)

Version 3.64 (2016-10-31)

• Updated daedalus-core gem. (Brian Shirai)

Version 3.63 (2016-10-28)

• Try re-enabling Travis OSX. (Brian Shirai)
• Re-disable Travis OSX. STDIN is not a TTY. (Brian Shirai)
  https://travis-ci.org/rubinius/rubinius/jobs/167911681#L5416
• Removed obsolete compiler define RBX_PROFILER. (Brian Shirai)
• Attempt to avoid breaking LLVM compiler flags. (Brian Shirai)
• Updated gems. (Brian Shirai)
• More instruction tests. (Brian Shirai)
• More interpreter tests. (Brian Shirai)
• Tests for check_frozen instruction. (Brian Shirai)
• Moved builtin/ to class/. (Brian Shirai)
  The name 'builtin' is not very descriptive. Now that we are going to have
  managed objects that are both object-oriented and simple data, and both are
  'built in', we need more descriptive names for the directories, so the new
  names are 'class' and 'data', which parallels the names used in the code.
• Fixed path to website releases data. (Brian Shirai)
• For Rubinius build on aarch64-linux-gnu (Raspberry Pi 3). (#3705) (medols)
• Specs for rb_obj_method_arity. (Brian Shirai)
• Added rb_obj_method_arity. Fixes #3708. (Brian Shirai)

Version 3.62 (2016-10-14)

• Fixed building OSX packages. (Brian Shirai)

Version 3.61 (2016-10-13)

• Updated website repo name. (Brian Shirai)
• Install zlib in Docker container for building Nokogiri. (Brian Shirai)
• Update README.md (#3702) (LTheGreats)
  Got rid of empty link.
• Updated README to match #3702. (Brian Shirai)
• Updated debugger gem version. (Brian Shirai)
• Attempt to use Homebrew OpenSSL on Travis OSX. (Brian Shirai)
• Try force linking openssl on Travis OSX. (Brian Shirai)
• Revert "Try force linking openssl on Travis OSX." (Brian Shirai)
  This reverts commit 6a864cf60220da6c79105ca0926c6b1e44adac78.
• Updated rubysl-socket to 2.2. (Brian Shirai)
• Move deploy to Travis Linux and disable OSX. (Brian Shirai)
• Install LLVM 3.8 on Travis Linux. (Brian Shirai)
• Use bsdtar. (Brian Shirai)
  The bsdtar program supports '-s pattern' but GNU tar does not.
• Install bsdtar on Travis Linux. (Brian Shirai)

Version 3.60 (2016-09-21)

• Bump libsodium to 1.0.11 (#3696) (Jesse Cooke)
• Specs for reopening class/module private constant. (Brian Shirai)
• Apple 10.12 deprecates syscall(2). (Brian Shirai)
• Removed support for private constants. Closes #3697. (Brian Shirai)
  Private constants are a bad idea, and supporting them isn't necessarily a good
  idea.

Private constants do not add any capability to Ruby. They merely restrict
programs that would otherwise run. For this reason, not supporting private
constants in Rubinius doesn't prohibit any code that would otherwise run in
Ruby, except for the fruitless class of code that soley relies on accessing a
private constant to raise an exception.

The exception that is raised is a NameError, which causes confusion between a
constant not being defined at all, and therefore able to be defined or
autoloaded, etc., and the constant being defined but private, and therefore
prohibiting defining the constant. To distinguish between these cases would
require parsing the exception text itself.

Despite being labeled private and superficially not accessible, it is easy to
actually access the constant. So no well-meaning code is actually inhibited by
labeling a constant private.

If code were presented that relied on private constants being private, in the
positive sense (ie added capability, not merely prohibited capability), we
can revisit support for private constants.

• Guard File.setgid? spec for superuser. (Brian Shirai)
• Properly include stdint.h for uint64_t. (Brian Shirai)

Version 3.59 (2016-09-12)

• Don't double quote OSX configure parameters. (Brian Shirai)

Version 3.58 (2016-09-02)

• Disable rubygems checking missing extensions. (Brian Shirai)

Version 3.57 (2016-08-30)

• Clang 3.8 disallows return NULL for intptr_t function type. (Brian Shirai)
• Use -latomic if it exists. Related to #3693. (Brian Shirai)
• Use space before & after -latomic. Fixes #3693. (Brian Shirai)

Version 3.56 (2016-08-19)

• Add typedef for id_t (#3691) (Chris Olstrom)
  Resolves a compilation failure under musl libc.
• Force use of llvm 3.8 for Homebrew package. (Brian Shirai)
• Force llvm 3.8 for building Travis OSX binary. (Brian Shirai)

Version 3.55 (2016-08-17)

• Synchronize all access to struct dirent, via @heftig. (Brian Shirai)

Version 3.54 (2016-08-16)

• Replace deprecated readdir_r. (Brian Shirai)
  Calls to readdir(3) are not guaranteed to be thread safe so we introduce a
  spinlock around calls. This synchronization will usually not be necessary, but
  we have to ensure correctness.

Version 3.53 (2016-08-15)

• Start adding interpreter tests. (Brian Shirai)
• Added reference count bits to new memory header. (Brian Shirai)
• Updated daedalus gem. (Brian Shirai)
• Updated rubygems to 2.6.6. (Brian Shirai)

Version 3.52 (2016-08-13)

• Removed more legacy JIT cruft. (Brian Shirai)
• Duplicate instruction defs for new interpreter. (Brian Shirai)
• Initial work on new interpreter. (Brian Shirai)
• Try to build with clang[++]-3.8 on OSX. (Brian Shirai)
• Try full paths for clang 3.8 on OSX. (Brian Shirai)
• Try brew link llvm38 on OSX. (Brian Shirai)
• Try versioned llvm-config. (Brian Shirai)
• Try versioned clang/clang++ again. (Brian Shirai)
• Split instructions into files. (Brian Shirai)
  With the expansion of the instruction set and different types of instructions
  with expanded attributes, using a special syntax becomes much more complex.

Instead of managing special code to parse this special syntax, we convert to
standard JSON for attributes and documentation, and explicit C++ source files
and C #include statements for code.

• Updated Daedalus gem. (Brian Shirai)
• Convert instructions to inlined functions. (Brian Shirai)
  The instructions themselves are snippets of code that mutate state.

The interpreter executes the functions and moves the instruction pointer
(IP) to the next instruction, essentially operating as a loop (implemented by
tail calls) over the instruction (opcode) vector.

The naive JIT linearizes the sequence of function calls to the instructions
and introduces control flow directly (instead of it being an artifact of
iterating over the opcode vector).

• Sort opcodes for deterministic ordering. (Brian Shirai)
• Updated compiler version. (Brian Shirai)
• Updated compiler version. (Brian Shirai)
• Added new interpreter and more control flow work. (Brian Shirai)
• Added InstructionData. (Brian Shirai)
• Fixed ordering for generated InstructionData. (Brian Shirai)
• Updated compiler version. (Brian Shirai)
• Removed udis86 library. (Brian Shirai)
• Reordered instructions for active compiler. (Brian Shirai)
  The bytecode generated is now using the same ordering for the instructions as
  the new interpreter, making it possible to internalize methods and check the
  functioning of the new interpreter.
• Added Interpreter::prepare. (Brian Shirai)
• Cleaned up some JIT cruft. (Brian Shirai)
• Fixed stack access in new interpreter. (Brian Shirai)
• Start adding instruction tests. (Brian Shirai)
• Added Mirror#instance_fields, #instance_variables. (Brian Shirai)

Version 3.51 (2016-07-27)

• Moved oop.[ch]pp to memory/header.[ch]pp. (Brian Shirai)
  First, OOP is obscure to newcomers wouldn't have any basis to know what an
  object-oriented pointer (really a "tagged pointer") is. Second, with the
  addition of non-OO managed memory objects, the name is no longer accurate.
  MemoryHeader is both descriptive and accurate.
• More MemoryHeader, InflatedHeader work. (Brian Shirai)
• Revert "Singleton classes can't have subclasses." (Brian Shirai)
  While singleton classes cannot have subclasses, modules can have singleton
  classes and the inline cache invalidation critically depends on those
  singleton classes being reachable from the module.

This reverts commit 20938ee86dcb7396c4cf2d16bb89ffd9fcee9a9d.

• Downgrade Bundler due to https://github.com/bundler/bundler/issues/4750. (Brian Shirai)
• Updated rubinius-debugger version. (Brian Shirai)

Version 3.50 (2016-07-25)

• Ensure MemoryHeader is a POD. (Brian Shirai)
  Also get rid of the union because its sole purpose (assign one field, read
  another) is undefined behavior in C++.

We define MemoryFlags as a single machine word type instead of using a struct
of bitfields for the reasons given in the code comment.

• Module#define_method accepts attr_accessor methods. Fixes #3685. (Brian Shirai)

Version 3.49 (2016-07-22)

• Added Thread#name, #name=. (Brian Shirai)
• Added start of new managed memory header. (Brian Shirai)
• Add a failing spec for a case then protected method called from public_send in own method (#3681) (Kenichi Kamiya)
• Add specs to call public_send via own public method

ref: https://bugs.ruby-lang.org/issues/7499

• Add a failing tag for above
• Adjust style with classic lambda syntax

ref: https://github.com/rubinius/rubinius/pull/3681#issuecomment-234644486

• Fix sized enumerators of Numeric#step with Infinity (#3683) (Kenichi Kamiya)
• Add specs for sized enumerator of Numeric#step with infinity limit
• Fix sized enumerator of Numeric#step with Infinity
• Add error constant ENOTSUP (#3684) (Miguel Landaeta)
• Define predicates for MemoryHeader. (Brian Shirai)
• Fixed 32-bit code assumption. Fixes #3682. (Brian Shirai)
  When allocating an Array of size 229, Rubinius would allocate a Tuple big
  enough to hold 229 == 536870912 elements. On a 64bit arch, each of these
  elements require sizeof(intptr_t) == 8 bytes. A Tuple memory header is 4 *
  sizeof(intptr_t) == 32 bytes. So, we have 2*_29_8+32 == 4294967328. It's a big
  number, but not so big that the 64bit arch can't easily handle it.

Unfortunately, down in the managed memory code, there was an explicit uint32_t
data type. What happens when 4294967328 == 0x100000020 bytes get put into
32bits? 0x100000020 & 0xffffffff == 32. Those 2**29 elements were being
crammed into 32 bytes. Computers may be magic, but even they can only take so
much.