debase-ruby_core_source 0.10.2 → 0.10.11

data/lib/debase/ruby_core_source/{ruby-2.5.0-rc1 → ruby-2.6.0-p0}/encindex.h

@@ -57,6 +57,8 @@ enum ruby_preserved_encindex {
 #define rb_utf8_encindex()      RUBY_ENCINDEX_UTF_8
 #define rb_usascii_encindex()   RUBY_ENCINDEX_US_ASCII
 
+int rb_enc_find_index2(const char *name, long len);
+
 #if defined(__cplusplus)
 #if 0
 { /* satisfy cc-mode */

data/lib/debase/ruby_core_source/{ruby-2.5.0-preview1 → ruby-2.6.0-p0}/eval_intern.h

@@ -5,23 +5,22 @@
 #include "vm_core.h"
 
 static inline void
-vm_passed_block_handler_set(rb_thread_t *th, VALUE block_handler)
+vm_passed_block_handler_set(rb_execution_context_t *ec, VALUE block_handler)
 {
     vm_block_handler_verify(block_handler);
-    th->passed_block_handler = block_handler;
+    ec->passed_block_handler = block_handler;
 }
 
 static inline void
-pass_passed_block_handler(rb_thread_t *th)
+pass_passed_block_handler(rb_execution_context_t *ec)
 {
-    VALUE block_handler = rb_vm_frame_block_handler(th->ec.cfp);
-    vm_block_handler_verify(block_handler);
-    vm_passed_block_handler_set(th, block_handler);
-    VM_ENV_FLAGS_SET(th->ec.cfp->ep, VM_FRAME_FLAG_PASSED);
+    VALUE block_handler = rb_vm_frame_block_handler(ec->cfp);
+    vm_passed_block_handler_set(ec, block_handler);
+    VM_ENV_FLAGS_SET(ec->cfp->ep, VM_FRAME_FLAG_PASSED);
 }
 
-#define PASS_PASSED_BLOCK_HANDLER_TH(th) pass_passed_block_handler(th)
-#define PASS_PASSED_BLOCK_HANDLER() pass_passed_block_handler(GET_THREAD())
+#define PASS_PASSED_BLOCK_HANDLER_EC(ec) pass_passed_block_handler(ec)
+#define PASS_PASSED_BLOCK_HANDLER() pass_passed_block_handler(GET_EC())
 
 #ifdef HAVE_STDLIB_H
 #include <stdlib.h>
@@ -98,7 +97,7 @@ extern int select_large_fdset(int, fd_set *, fd_set *, fd_set *, struct timeval
 #define SAVE_ROOT_JMPBUF_AFTER_STMT \
     } \
     __except (GetExceptionCode() == EXCEPTION_STACK_OVERFLOW ? \
-	      (rb_thread_raised_set(GET_THREAD(), RAISED_STACKOVERFLOW), \
+	      (rb_ec_raised_set(GET_EC(), RAISED_STACKOVERFLOW), \
 	       raise(SIGSEGV), \
 	       EXCEPTION_EXECUTE_HANDLER) : \
 	      EXCEPTION_CONTINUE_SEARCH) { \
@@ -128,26 +127,27 @@ LONG WINAPI rb_w32_stack_overflow_handler(struct _EXCEPTION_POINTERS *);
       rb_fiber_start(); \
   } while (0)
 
-#define TH_PUSH_TAG(th) do { \
-  rb_thread_t * const _th = (th); \
+#define EC_PUSH_TAG(ec) do { \
+  rb_execution_context_t * const _ec = (ec); \
   struct rb_vm_tag _tag; \
   _tag.state = TAG_NONE; \
   _tag.tag = Qundef; \
-  _tag.prev = _th->ec.tag;
+  _tag.prev = _ec->tag;
 
-#define TH_POP_TAG() \
-  _th->ec.tag = _tag.prev; \
+#define EC_POP_TAG() \
+  _ec->tag = _tag.prev; \
 } while (0)
 
-#define TH_TMPPOP_TAG() \
-  _th->ec.tag = _tag.prev
-
-#define TH_REPUSH_TAG() (void)(_th->ec.tag = &_tag)
+#define EC_TMPPOP_TAG() \
+  _ec->tag = _tag.prev
 
-#define PUSH_TAG() TH_PUSH_TAG(GET_THREAD())
-#define POP_TAG()      TH_POP_TAG()
+#define EC_REPUSH_TAG() (void)(_ec->tag = &_tag)
 
-#if defined __GNUC__ && __GNUC__ == 4 && (__GNUC_MINOR__ >= 6 && __GNUC_MINOR__ <= 8)
+#if defined __GNUC__ && __GNUC__ == 4 && (__GNUC_MINOR__ >= 6 && __GNUC_MINOR__ <= 8) || __clang__
+/* This macro prevents GCC 4.6--4.8 from emitting maybe-uninitialized warnings.
+ * This macro also prevents Clang from dumping core in EC_EXEC_TAG().
+ * (I confirmed Clang 4.0.1 and 5.0.0.)
+ */
 # define VAR_FROM_MEMORY(var) __extension__(*(__typeof__(var) volatile *)&(var))
 # define VAR_INITIALIZED(var) ((var) = VAR_FROM_MEMORY(var))
 # define VAR_NOCLOBBERED(var) volatile var
@@ -160,10 +160,10 @@ LONG WINAPI rb_w32_stack_overflow_handler(struct _EXCEPTION_POINTERS *);
 #if defined(USE_UNALIGNED_MEMBER_ACCESS) && USE_UNALIGNED_MEMBER_ACCESS && \
     defined(__clang__)
 # define UNALIGNED_MEMBER_ACCESS(expr) __extension__({ \
-    _Pragma("GCC diagnostic push"); \
-    _Pragma("GCC diagnostic ignored \"-Waddress-of-packed-member\""); \
+    COMPILER_WARNING_PUSH; \
+    COMPILER_WARNING_IGNORED(-Waddress-of-packed-member); \
     typeof(expr) unaligned_member_access_result = (expr); \
-    _Pragma("GCC diagnostic pop"); \
+    COMPILER_WARNING_POP; \
     unaligned_member_access_result; \
 })
 #else
@@ -174,36 +174,31 @@ LONG WINAPI rb_w32_stack_overflow_handler(struct _EXCEPTION_POINTERS *);
 #undef RB_OBJ_WRITE
 #define RB_OBJ_WRITE(a, slot, b) UNALIGNED_MEMBER_ACCESS(rb_obj_write((VALUE)(a), (VALUE *)(slot), (VALUE)(b), __FILE__, __LINE__))
 
-/* clear th->ec.tag->state, and return the value */
+/* clear ec->tag->state, and return the value */
 static inline int
-rb_threadptr_tag_state(rb_thread_t *th)
+rb_ec_tag_state(const rb_execution_context_t *ec)
 {
-    enum ruby_tag_type state = th->ec.tag->state;
-    th->ec.tag->state = TAG_NONE;
+    enum ruby_tag_type state = ec->tag->state;
+    ec->tag->state = TAG_NONE;
     return state;
 }
 
-NORETURN(static inline void rb_threadptr_tag_jump(rb_thread_t *, enum ruby_tag_type st));
+NORETURN(static inline void rb_ec_tag_jump(const rb_execution_context_t *ec, enum ruby_tag_type st));
 static inline void
-rb_threadptr_tag_jump(rb_thread_t *th, enum ruby_tag_type st)
+rb_ec_tag_jump(const rb_execution_context_t *ec, enum ruby_tag_type st)
 {
-    th->ec.tag->state = st;
-    ruby_longjmp(th->ec.tag->buf, 1);
+    ec->tag->state = st;
+    ruby_longjmp(ec->tag->buf, 1);
 }
 
 /*
   setjmp() in assignment expression rhs is undefined behavior
   [ISO/IEC 9899:1999] 7.13.1.1
 */
-#define TH_EXEC_TAG() \
-    (ruby_setjmp(_tag.buf) ? rb_threadptr_tag_state(VAR_FROM_MEMORY(_th)) : (TH_REPUSH_TAG(), 0))
-
-#define EXEC_TAG() \
-  TH_EXEC_TAG()
-
-#define TH_JUMP_TAG(th, st) rb_threadptr_tag_jump(th, st)
+#define EC_EXEC_TAG() \
+    (ruby_setjmp(_tag.buf) ? rb_ec_tag_state(VAR_FROM_MEMORY(_ec)) : (EC_REPUSH_TAG(), 0))
 
-#define JUMP_TAG(st) TH_JUMP_TAG(GET_THREAD(), (st))
+#define EC_JUMP_TAG(ec, st) rb_ec_tag_jump(ec, st)
 
 #define INTERNAL_EXCEPTION_P(exc) FIXNUM_P(exc)
 
@@ -280,13 +275,13 @@ enum {
     RAISED_STACKOVERFLOW = 2,
     RAISED_NOMEMORY = 4
 };
-int rb_threadptr_set_raised(rb_thread_t *th);
-int rb_threadptr_reset_raised(rb_thread_t *th);
-#define rb_thread_raised_set(th, f)   ((th)->ec.raised_flag |= (f))
-#define rb_thread_raised_reset(th, f) ((th)->ec.raised_flag &= ~(f))
-#define rb_thread_raised_p(th, f)     (((th)->ec.raised_flag & (f)) != 0)
-#define rb_thread_raised_clear(th)    ((th)->ec.raised_flag = 0)
-int rb_threadptr_stack_check(rb_thread_t *th);
+#define rb_ec_raised_set(ec, f)   ((ec)->raised_flag |= (f))
+#define rb_ec_raised_reset(ec, f) ((ec)->raised_flag &= ~(f))
+#define rb_ec_raised_p(ec, f)    (((ec)->raised_flag & (f)) != 0)
+#define rb_ec_raised_clear(ec)    ((ec)->raised_flag = 0)
+int rb_ec_set_raised(rb_execution_context_t *ec);
+int rb_ec_reset_raised(rb_execution_context_t *ec);
+int rb_ec_stack_check(rb_execution_context_t *ec);
 
 VALUE rb_f_eval(int argc, const VALUE *argv, VALUE self);
 VALUE rb_make_exception(int argc, const VALUE *argv);
@@ -302,8 +297,6 @@ NORETURN(void rb_vm_localjump_error(const char *,VALUE, int));
 #if 0
 NORETURN(void rb_vm_jump_tag_but_local_jump(int));
 #endif
-NORETURN(void rb_raise_method_missing(rb_thread_t *th, int argc, const VALUE *argv,
-				      VALUE obj, int call_status));
 
 VALUE rb_vm_make_jump_tag_but_local_jump(int state, VALUE val);
 rb_cref_t *rb_vm_cref(void);
@@ -314,9 +307,8 @@ void rb_thread_terminate_all(void);
 VALUE rb_vm_cbase(void);
 
 /* vm_backtrace.c */
-VALUE rb_threadptr_backtrace_object(rb_thread_t *th);
-VALUE rb_threadptr_backtrace_str_ary(rb_thread_t *th, long lev, long n);
-VALUE rb_threadptr_backtrace_location_ary(rb_thread_t *th, long lev, long n);
+VALUE rb_ec_backtrace_object(const rb_execution_context_t *ec);
+VALUE rb_ec_backtrace_str_ary(const rb_execution_context_t *ec, long lev, long n);
 
 #ifndef CharNext		/* defined as CharNext[AW] on Windows. */
 # ifdef HAVE_MBLEN

data/lib/debase/ruby_core_source/{ruby-2.5.0-preview1 → ruby-2.6.0-p0}/gc.h

@@ -2,9 +2,9 @@
 #ifndef RUBY_GC_H
 #define RUBY_GC_H 1
 
-#if defined(__x86_64__) && !defined(_ILP32) && defined(__GNUC__) && !defined(__native_client__)
+#if defined(__x86_64__) && !defined(_ILP32) && defined(__GNUC__)
 #define SET_MACHINE_STACK_END(p) __asm__ __volatile__ ("movq\t%%rsp, %0" : "=r" (*(p)))
-#elif defined(__i386) && defined(__GNUC__) && !defined(__native_client__)
+#elif defined(__i386) && defined(__GNUC__)
 #define SET_MACHINE_STACK_END(p) __asm__ __volatile__ ("movl\t%%esp, %0" : "=r" (*(p)))
 #else
 NOINLINE(void rb_gc_set_stack_end(VALUE **stack_end_p));
@@ -91,7 +91,6 @@ const char *rb_raw_obj_info(char *buff, const int buff_size, VALUE obj);
 void rb_obj_info_dump(VALUE obj);
 
 struct rb_thread_struct;
-int rb_threadptr_during_gc(struct rb_thread_struct *th);
 
 RUBY_SYMBOL_EXPORT_BEGIN
 

data/lib/debase/ruby_core_source/ruby-2.6.0-p0/hrtime.h

@@ -0,0 +1,168 @@
+#ifndef RB_HRTIME_H
+#define RB_HRTIME_H
+#include "ruby/ruby.h"
+#include <time.h>
+#if defined(HAVE_SYS_TIME_H)
+#  include <sys/time.h>
+#endif
+
+/*
+ * Hi-res monotonic clock.  It is currently nsec resolution, which has over
+ * 500 years of range (with an unsigned 64-bit integer).  Developers
+ * targeting small systems may try 32-bit and low-resolution (milliseconds).
+ *
+ * TBD: Is nsec even necessary? usec resolution seems enough for userspace
+ * and it'll be suitable for use with devices lasting over 500,000 years
+ * (maybe some devices designed for long-term space travel)
+ *
+ * Current API:
+ *
+ *	* rb_hrtime_now      - current clock value (monotonic if available)
+ *	* rb_hrtime_mul      - multiply with overflow check
+ *	* rb_hrtime_add      - add with overflow check
+ *	* rb_timeval2hrtime  - convert from timeval
+ *	* rb_timespec2hrtime - convert from timespec
+ *	* rb_msec2hrtime     - convert from millisecond
+ *	* rb_sec2hrtime      - convert from time_t (seconds)
+ *	* rb_hrtime2timeval  - convert to timeval
+ *	* rb_hrtime2timespec - convert to timespec
+ *
+ * Note: no conversion to milliseconds is provided here because different
+ * functions have different limits (e.g. epoll_wait vs w32_wait_events).
+ * So we provide RB_HRTIME_PER_MSEC and similar macros for implementing
+ * this for each use case.
+ */
+#define RB_HRTIME_PER_USEC ((rb_hrtime_t)1000)
+#define RB_HRTIME_PER_MSEC (RB_HRTIME_PER_USEC * (rb_hrtime_t)1000)
+#define RB_HRTIME_PER_SEC  (RB_HRTIME_PER_MSEC * (rb_hrtime_t)1000)
+#define RB_HRTIME_MAX      UINT64_MAX
+
+/*
+ * Lets try to support time travelers.  Lets assume anybody with a time machine
+ * also has access to a modern gcc or clang with 128-bit int support
+ */
+#ifdef MY_RUBY_BUILD_MAY_TIME_TRAVEL
+typedef int128_t rb_hrtime_t;
+#else
+typedef uint64_t rb_hrtime_t;
+#endif
+
+/* thread.c */
+/* returns the value of the monotonic clock (if available) */
+rb_hrtime_t rb_hrtime_now(void);
+
+/*
+ * multiply @a and @b with overflow check and return the
+ * (clamped to RB_HRTIME_MAX) result.
+ */
+static inline rb_hrtime_t
+rb_hrtime_mul(rb_hrtime_t a, rb_hrtime_t b)
+{
+    rb_hrtime_t c;
+
+#ifdef HAVE_BUILTIN___BUILTIN_MUL_OVERFLOW
+    if (__builtin_mul_overflow(a, b, &c))
+        return RB_HRTIME_MAX;
+#else
+    if (b != 0 && a > RB_HRTIME_MAX / b) /* overflow */
+        return RB_HRTIME_MAX;
+    c = a * b;
+#endif
+    return c;
+}
+
+/*
+ * add @a and @b with overflow check and return the
+ * (clamped to RB_HRTIME_MAX) result.
+ */
+static inline rb_hrtime_t
+rb_hrtime_add(rb_hrtime_t a, rb_hrtime_t b)
+{
+    rb_hrtime_t c;
+
+#ifdef HAVE_BUILTIN___BUILTIN_ADD_OVERFLOW
+    if (__builtin_add_overflow(a, b, &c))
+        return RB_HRTIME_MAX;
+#else
+    c = a + b;
+    if (c < a) /* overflow */
+        return RB_HRTIME_MAX;
+#endif
+    return c;
+}
+
+/*
+ * convert a timeval struct to rb_hrtime_t, clamping at RB_HRTIME_MAX
+ */
+static inline rb_hrtime_t
+rb_timeval2hrtime(const struct timeval *tv)
+{
+    rb_hrtime_t s = rb_hrtime_mul((rb_hrtime_t)tv->tv_sec, RB_HRTIME_PER_SEC);
+    rb_hrtime_t u = rb_hrtime_mul((rb_hrtime_t)tv->tv_usec, RB_HRTIME_PER_USEC);
+
+    return rb_hrtime_add(s, u);
+}
+
+/*
+ * convert a timespec struct to rb_hrtime_t, clamping at RB_HRTIME_MAX
+ */
+static inline rb_hrtime_t
+rb_timespec2hrtime(const struct timespec *ts)
+{
+    rb_hrtime_t s = rb_hrtime_mul((rb_hrtime_t)ts->tv_sec, RB_HRTIME_PER_SEC);
+
+    return rb_hrtime_add(s, (rb_hrtime_t)ts->tv_nsec);
+}
+
+/*
+ * convert a millisecond value to rb_hrtime_t, clamping at RB_HRTIME_MAX
+ */
+static inline rb_hrtime_t
+rb_msec2hrtime(unsigned long msec)
+{
+    return rb_hrtime_mul((rb_hrtime_t)msec, RB_HRTIME_PER_MSEC);
+}
+
+/*
+ * convert a time_t value to rb_hrtime_t, clamping at RB_HRTIME_MAX
+ * Negative values will be clamped at 0.
+ */
+static inline rb_hrtime_t
+rb_sec2hrtime(time_t sec)
+{
+    if (sec <= 0) return 0;
+
+    return rb_hrtime_mul((rb_hrtime_t)sec, RB_HRTIME_PER_SEC);
+}
+
+/*
+ * convert a rb_hrtime_t value to a timespec, suitable for calling
+ * functions like ppoll(2) or kevent(2)
+ */
+static inline struct timespec *
+rb_hrtime2timespec(struct timespec *ts, const rb_hrtime_t *hrt)
+{
+    if (hrt) {
+        ts->tv_sec = (time_t)(*hrt / RB_HRTIME_PER_SEC);
+        ts->tv_nsec = (int32_t)(*hrt % RB_HRTIME_PER_SEC);
+        return ts;
+    }
+    return 0;
+}
+
+/*
+ * convert a rb_hrtime_t value to a timeval, suitable for calling
+ * functions like select(2)
+ */
+static inline struct timeval *
+rb_hrtime2timeval(struct timeval *tv, const rb_hrtime_t *hrt)
+{
+    if (hrt) {
+        tv->tv_sec = (time_t)(*hrt / RB_HRTIME_PER_SEC);
+        tv->tv_usec = (int32_t)((*hrt % RB_HRTIME_PER_SEC)/RB_HRTIME_PER_USEC);
+
+        return tv;
+    }
+    return 0;
+}
+#endif /* RB_HRTIME_H */

data/lib/debase/ruby_core_source/{ruby-2.5.0-rc1 → ruby-2.6.0-p0}/id.h

@@ -95,6 +95,8 @@ enum ruby_method_ids {
     idEqq = RUBY_TOKEN(EQQ),
     idNeq = RUBY_TOKEN(NEQ),
     idNot = '!',
+    idAnd = '&',
+    idOr = '|',
     idBackquote = '`',
     idEqTilde = RUBY_TOKEN(MATCH),
     idNeqTilde = RUBY_TOKEN(NMATCH),
@@ -118,8 +120,6 @@ enum ruby_method_ids {
     id_core_define_method,
     id_core_define_singleton_method,
     id_core_set_postexe,
-    id_core_hash_from_ary,
-    id_core_hash_merge_ary,
     id_core_hash_merge_ptr,
     id_core_hash_merge_kwd,
     id_debug_created_info,
@@ -163,6 +163,7 @@ enum ruby_method_ids {
     tTo_a,
     tTo_s,
     tTo_i,
+    tTo_f,
     tTo_r,
     tBt,
     tBt_locations,
@@ -226,6 +227,7 @@ enum ruby_method_ids {
     DEFINE_LOCALID_FROM_TOKEN(To_a),
     DEFINE_LOCALID_FROM_TOKEN(To_s),
     DEFINE_LOCALID_FROM_TOKEN(To_i),
+    DEFINE_LOCALID_FROM_TOKEN(To_f),
     DEFINE_LOCALID_FROM_TOKEN(To_r),
     DEFINE_LOCALID_FROM_TOKEN(Bt),
     DEFINE_LOCALID_FROM_TOKEN(Bt_locations),

data/lib/debase/ruby_core_source/ruby-2.6.0-p0/insns.inc

@@ -0,0 +1,249 @@
+/* -*- mode:c; style:ruby; coding: utf-8; indent-tabs-mode: nil -*- */
+
+/* This is  an auto-generated file  and is a  part of the  programming language
+ * Ruby.  The  person who  created  a  program  to  generate this  file  (``I''
+ * hereafter) would like  to refrain from defining licensing  of this generated
+ * source code.
+ *
+ * This file consist of many small  parts of codes copyrighted by each authors,
+ * not  only  the  ``I''  person.   Those  original  authors  agree  with  some
+ * open-source license.  I  believe that the license we agree  is the condition
+ * mentioned in  the file COPYING.  It  states "4.  You may  modify and include
+ * the part of the software into any  other software ...".  But the problem is,
+ * the license never makes it clear if  such modified parts still remain in the
+ * same  license, or  not.   The fact  that  we agree  with  the source  code's
+ * licensing terms do not automatically define that of generated ones.  This is
+ * the reason  why this file  is under unclear situation.   All that I  know is
+ * that above provision guarantees this file to exist.
+ *
+ * Please let me  hesitate to declare something about this  nuanced contract. I
+ * am not in the position to take  over other authors' license to merge into my
+ * one.  Changing them to (say) GPLv3  is not doable by myself. Perhaps someday
+ * it might turn out to be okay to say this file is under a license. I wish the
+ * situation would become more clear in the future. */
+
+/*******************************************************************/
+/*******************************************************************/
+/*******************************************************************/
+/**
+  This file contains YARV instruction list.
+
+  ----
+  This file is auto generated by insns2vm.rb
+  DO NOT TOUCH!
+
+  If you want to fix something, you must edit "tool/ruby_vm/views/insns.inc.erb"
+  or tool/insns2vm.rb
+ */
+
+/* BIN : Basic Instruction Name */
+#define BIN(n) YARVINSN_##n
+
+enum ruby_vminsn_type {
+    BIN(nop),
+    BIN(getlocal),
+    BIN(setlocal),
+    BIN(getblockparam),
+    BIN(setblockparam),
+    BIN(getblockparamproxy),
+    BIN(getspecial),
+    BIN(setspecial),
+    BIN(getinstancevariable),
+    BIN(setinstancevariable),
+    BIN(getclassvariable),
+    BIN(setclassvariable),
+    BIN(getconstant),
+    BIN(setconstant),
+    BIN(getglobal),
+    BIN(setglobal),
+    BIN(putnil),
+    BIN(putself),
+    BIN(putobject),
+    BIN(putspecialobject),
+    BIN(putiseq),
+    BIN(putstring),
+    BIN(concatstrings),
+    BIN(tostring),
+    BIN(freezestring),
+    BIN(toregexp),
+    BIN(intern),
+    BIN(newarray),
+    BIN(duparray),
+    BIN(duphash),
+    BIN(expandarray),
+    BIN(concatarray),
+    BIN(splatarray),
+    BIN(newhash),
+    BIN(newrange),
+    BIN(pop),
+    BIN(dup),
+    BIN(dupn),
+    BIN(swap),
+    BIN(reverse),
+    BIN(reput),
+    BIN(topn),
+    BIN(setn),
+    BIN(adjuststack),
+    BIN(defined),
+    BIN(checkmatch),
+    BIN(checkkeyword),
+    BIN(checktype),
+    BIN(defineclass),
+    BIN(send),
+    BIN(opt_send_without_block),
+    BIN(opt_str_freeze),
+    BIN(opt_str_uminus),
+    BIN(opt_newarray_max),
+    BIN(opt_newarray_min),
+    BIN(invokesuper),
+    BIN(invokeblock),
+    BIN(leave),
+    BIN(throw),
+    BIN(jump),
+    BIN(branchif),
+    BIN(branchunless),
+    BIN(branchnil),
+    BIN(opt_getinlinecache),
+    BIN(opt_setinlinecache),
+    BIN(once),
+    BIN(opt_case_dispatch),
+    BIN(opt_plus),
+    BIN(opt_minus),
+    BIN(opt_mult),
+    BIN(opt_div),
+    BIN(opt_mod),
+    BIN(opt_eq),
+    BIN(opt_neq),
+    BIN(opt_lt),
+    BIN(opt_le),
+    BIN(opt_gt),
+    BIN(opt_ge),
+    BIN(opt_ltlt),
+    BIN(opt_and),
+    BIN(opt_or),
+    BIN(opt_aref),
+    BIN(opt_aset),
+    BIN(opt_aset_with),
+    BIN(opt_aref_with),
+    BIN(opt_length),
+    BIN(opt_size),
+    BIN(opt_empty_p),
+    BIN(opt_succ),
+    BIN(opt_not),
+    BIN(opt_regexpmatch1),
+    BIN(opt_regexpmatch2),
+    BIN(opt_call_c_function),
+    BIN(bitblt),
+    BIN(answer),
+    BIN(getlocal_WC_0),
+    BIN(getlocal_WC_1),
+    BIN(setlocal_WC_0),
+    BIN(setlocal_WC_1),
+    BIN(putobject_INT2FIX_0_),
+    BIN(putobject_INT2FIX_1_),
+    BIN(trace_nop),
+    BIN(trace_getlocal),
+    BIN(trace_setlocal),
+    BIN(trace_getblockparam),
+    BIN(trace_setblockparam),
+    BIN(trace_getblockparamproxy),
+    BIN(trace_getspecial),
+    BIN(trace_setspecial),
+    BIN(trace_getinstancevariable),
+    BIN(trace_setinstancevariable),
+    BIN(trace_getclassvariable),
+    BIN(trace_setclassvariable),
+    BIN(trace_getconstant),
+    BIN(trace_setconstant),
+    BIN(trace_getglobal),
+    BIN(trace_setglobal),
+    BIN(trace_putnil),
+    BIN(trace_putself),
+    BIN(trace_putobject),
+    BIN(trace_putspecialobject),
+    BIN(trace_putiseq),
+    BIN(trace_putstring),
+    BIN(trace_concatstrings),
+    BIN(trace_tostring),
+    BIN(trace_freezestring),
+    BIN(trace_toregexp),
+    BIN(trace_intern),
+    BIN(trace_newarray),
+    BIN(trace_duparray),
+    BIN(trace_duphash),
+    BIN(trace_expandarray),
+    BIN(trace_concatarray),
+    BIN(trace_splatarray),
+    BIN(trace_newhash),
+    BIN(trace_newrange),
+    BIN(trace_pop),
+    BIN(trace_dup),
+    BIN(trace_dupn),
+    BIN(trace_swap),
+    BIN(trace_reverse),
+    BIN(trace_reput),
+    BIN(trace_topn),
+    BIN(trace_setn),
+    BIN(trace_adjuststack),
+    BIN(trace_defined),
+    BIN(trace_checkmatch),
+    BIN(trace_checkkeyword),
+    BIN(trace_checktype),
+    BIN(trace_defineclass),
+    BIN(trace_send),
+    BIN(trace_opt_send_without_block),
+    BIN(trace_opt_str_freeze),
+    BIN(trace_opt_str_uminus),
+    BIN(trace_opt_newarray_max),
+    BIN(trace_opt_newarray_min),
+    BIN(trace_invokesuper),
+    BIN(trace_invokeblock),
+    BIN(trace_leave),
+    BIN(trace_throw),
+    BIN(trace_jump),
+    BIN(trace_branchif),
+    BIN(trace_branchunless),
+    BIN(trace_branchnil),
+    BIN(trace_opt_getinlinecache),
+    BIN(trace_opt_setinlinecache),
+    BIN(trace_once),
+    BIN(trace_opt_case_dispatch),
+    BIN(trace_opt_plus),
+    BIN(trace_opt_minus),
+    BIN(trace_opt_mult),
+    BIN(trace_opt_div),
+    BIN(trace_opt_mod),
+    BIN(trace_opt_eq),
+    BIN(trace_opt_neq),
+    BIN(trace_opt_lt),
+    BIN(trace_opt_le),
+    BIN(trace_opt_gt),
+    BIN(trace_opt_ge),
+    BIN(trace_opt_ltlt),
+    BIN(trace_opt_and),
+    BIN(trace_opt_or),
+    BIN(trace_opt_aref),
+    BIN(trace_opt_aset),
+    BIN(trace_opt_aset_with),
+    BIN(trace_opt_aref_with),
+    BIN(trace_opt_length),
+    BIN(trace_opt_size),
+    BIN(trace_opt_empty_p),
+    BIN(trace_opt_succ),
+    BIN(trace_opt_not),
+    BIN(trace_opt_regexpmatch1),
+    BIN(trace_opt_regexpmatch2),
+    BIN(trace_opt_call_c_function),
+    BIN(trace_bitblt),
+    BIN(trace_answer),
+    BIN(trace_getlocal_WC_0),
+    BIN(trace_getlocal_WC_1),
+    BIN(trace_setlocal_WC_0),
+    BIN(trace_setlocal_WC_1),
+    BIN(trace_putobject_INT2FIX_0_),
+    BIN(trace_putobject_INT2FIX_1_),
+    VM_INSTRUCTION_SIZE
+};
+
+#define ASSERT_VM_INSTRUCTION_SIZE(array) \
+    STATIC_ASSERT(numberof_##array, numberof(array) == VM_INSTRUCTION_SIZE)