llrb 0.0.1

data/ext/llrb_insn_checkkeyword.c

@@ -0,0 +1,20 @@
+#include "cruby.h"
+
+// TODO: Use vm_check_keyword after Ruby 2.5
+VALUE
+llrb_insn_checkkeyword(VALUE cfp_v, lindex_t kw_bits_index, rb_num_t keyword_index)
+{
+  rb_control_frame_t *cfp = (rb_control_frame_t *)cfp_v;
+
+  const VALUE *ep = cfp->ep;
+  const VALUE kw_bits = *(ep - kw_bits_index);
+
+  if (FIXNUM_P(kw_bits)) {
+    int bits = FIX2INT(kw_bits);
+    return (bits & (0x01 << keyword_index)) ? Qfalse : Qtrue;
+  }
+  else {
+    VM_ASSERT(RB_TYPE_P(kw_bits, T_HASH));
+    return rb_hash_has_key(kw_bits, INT2FIX(keyword_index)) ? Qfalse : Qtrue;
+  }
+}

data/ext/llrb_insn_checkmatch.c

@@ -0,0 +1,28 @@
+#include "cruby.h"
+
+// NOTE: There's optimization chance to check flag beforehand.
+// TODO: Use `vm_check_match` after Ruby 2.5.
+VALUE check_match(VALUE pattern, VALUE target, enum vm_check_match_type type);
+VALUE
+llrb_insn_checkmatch(VALUE target, VALUE pattern, rb_num_t flag)
+{
+  enum vm_check_match_type checkmatch_type =
+    (enum vm_check_match_type)(flag & VM_CHECKMATCH_TYPE_MASK);
+  VALUE result = Qfalse;
+
+  if (flag & VM_CHECKMATCH_ARRAY) {
+    long i;
+    for (i = 0; i < RARRAY_LEN(pattern); i++) {
+      if (RTEST(check_match(RARRAY_AREF(pattern, i), target, checkmatch_type))) {
+        result = Qtrue;
+        break;
+      }
+    }
+  }
+  else {
+    if (RTEST(check_match(pattern, target, checkmatch_type))) {
+      result = Qtrue;
+    }
+  }
+  return result;
+}

data/ext/llrb_insn_concatarray.c

@@ -0,0 +1,23 @@
+#include "cruby.h"
+
+// TODO: Use vm_concat_array after Ruby 2.5
+VALUE
+llrb_insn_concatarray(VALUE ary1, VALUE ary2st)
+{
+  const VALUE ary2 = ary2st;
+  VALUE tmp1 = rb_check_convert_type(ary1, T_ARRAY, "Array", "to_a");
+  VALUE tmp2 = rb_check_convert_type(ary2, T_ARRAY, "Array", "to_a");
+
+  if (NIL_P(tmp1)) {
+    tmp1 = rb_ary_new3(1, ary1);
+  }
+
+  if (NIL_P(tmp2)) {
+    tmp2 = rb_ary_new3(1, ary2);
+  }
+
+  if (tmp1 == ary1) {
+    tmp1 = rb_ary_dup(ary1);
+  }
+  return rb_ary_concat(tmp1, tmp2);
+}

data/ext/llrb_insn_concatstrings.c

@@ -0,0 +1,21 @@
+#include <stdarg.h>
+#include "cruby.h"
+
+// https://github.com/ruby/ruby/blob/v2_4_1/insns.def#L359-L372
+extern VALUE rb_str_concat_literals(size_t, const VALUE*);
+VALUE
+llrb_insn_concatstrings(size_t num, ...) {
+  VALUE *args = 0;
+  va_list ar;
+
+  if (num > 0) {
+    args = ALLOCA_N(VALUE, num);
+    va_start(ar, num);
+    for (size_t i = 0; i < num; i++) {
+      args[i] = va_arg(ar, VALUE);
+    }
+    va_end(ar);
+  }
+
+  return rb_str_concat_literals(num, args);
+}

data/ext/llrb_insn_defined.c

@@ -0,0 +1,9 @@
+#include "cruby.h"
+
+VALUE vm_defined(rb_thread_t *th, rb_control_frame_t *reg_cfp, rb_num_t op_type, VALUE obj, VALUE needstr, VALUE v);
+VALUE
+llrb_insn_defined(rb_num_t op_type, VALUE obj, VALUE needstr, VALUE v)
+{
+  rb_thread_t *th = GET_THREAD();
+  return vm_defined(th, th->cfp, op_type, obj, needstr, v);
+}

data/ext/llrb_insn_getclassvariable.c

@@ -0,0 +1,10 @@
+#include "cruby.h"
+
+VALUE vm_get_cvar_base(const rb_cref_t *cref, rb_control_frame_t *cfp);
+rb_cref_t * rb_vm_get_cref(const VALUE *ep);
+VALUE
+llrb_insn_getclassvariable(VALUE cfp_v, ID id)
+{
+  rb_control_frame_t *cfp = (rb_control_frame_t *)cfp_v;
+  return rb_cvar_get(vm_get_cvar_base(rb_vm_get_cref(cfp->ep), cfp), id);
+}

data/ext/llrb_insn_getinstancevariable.c

@@ -0,0 +1,44 @@
+#include "cruby.h"
+
+static inline VALUE
+vm_getivar(VALUE obj, ID id, IC ic)
+{
+  if (LIKELY(RB_TYPE_P(obj, T_OBJECT))) {
+    VALUE val = Qundef;
+    if (LIKELY(ic->ic_serial == RCLASS_SERIAL(RBASIC(obj)->klass))) {
+      st_index_t index = ic->ic_value.index;
+      if (LIKELY(index < ROBJECT_NUMIV(obj))) {
+        val = ROBJECT_IVPTR(obj)[index];
+      }
+     undef_check:
+      if (UNLIKELY(val == Qundef)) {
+        if (RTEST(ruby_verbose))
+          rb_warning("instance variable %"PRIsVALUE" not initialized", QUOTE_ID(id));
+        val = Qnil;
+      }
+      return val;
+    }
+    else {
+      st_data_t index;
+      struct st_table *iv_index_tbl = ROBJECT_IV_INDEX_TBL(obj);
+
+      if (iv_index_tbl) {
+        if (st_lookup(iv_index_tbl, id, &index)) {
+          if (index < ROBJECT_NUMIV(obj)) {
+            val = ROBJECT_IVPTR(obj)[index];
+          }
+          ic->ic_value.index = index;
+          ic->ic_serial = RCLASS_SERIAL(RBASIC(obj)->klass);
+        }
+      }
+      goto undef_check;
+    }
+  }
+  return rb_ivar_get(obj, id);
+}
+
+VALUE
+llrb_insn_getinstancevariable(VALUE obj, ID id, VALUE ic_v)
+{
+  return vm_getivar(obj, id, (IC)ic_v);
+}

data/ext/llrb_insn_getlocal.c

@@ -0,0 +1,14 @@
+#include "cruby.h"
+
+VALUE
+llrb_insn_getlocal(VALUE cfp_v, lindex_t idx, rb_num_t level)
+{
+  rb_control_frame_t *cfp = (rb_control_frame_t *)cfp_v;
+  int i, lev = (int)level;
+  const VALUE *ep = cfp->ep;
+
+  for (i = 0; i < lev; i++) {
+    ep = GET_PREV_EP(ep);
+  }
+  return *(ep - idx);
+}

data/ext/llrb_insn_getlocal_level0.c

@@ -0,0 +1,8 @@
+#include "cruby.h"
+
+VALUE
+llrb_insn_getlocal_level0(VALUE cfp_v, lindex_t idx)
+{
+  rb_control_frame_t *cfp = (rb_control_frame_t *)cfp_v;
+  return *(cfp->ep - idx);
+}

data/ext/llrb_insn_getlocal_level1.c

@@ -0,0 +1,8 @@
+#include "cruby.h"
+
+VALUE
+llrb_insn_getlocal_level1(VALUE cfp_v, lindex_t idx)
+{
+  rb_control_frame_t *cfp = (rb_control_frame_t *)cfp_v;
+  return *(GET_PREV_EP(cfp->ep) - idx);
+}

data/ext/llrb_insn_getspecial.c

@@ -0,0 +1,14 @@
+#include "cruby.h"
+
+VALUE vm_getspecial(rb_thread_t *th, const VALUE *lep, rb_num_t key, rb_num_t type);
+VALUE
+llrb_insn_getspecial(rb_num_t key, rb_num_t type)
+{
+  rb_thread_t *th = GET_THREAD();
+
+  const VALUE *ep = th->cfp->ep;
+  while (!VM_ENV_LOCAL_P(ep)) {
+    ep = VM_ENV_PREV_EP(ep);
+  }
+  return vm_getspecial(th, ep, key, type);
+}

data/ext/llrb_insn_invokeblock.c

@@ -0,0 +1,39 @@
+#include "cruby.h"
+
+VALUE vm_exec(rb_thread_t *th);
+
+static inline void
+_llrb_push_result(rb_control_frame_t *cfp, VALUE result)
+{
+  // PUSH(result)
+  *(cfp->sp) = result;
+  cfp->sp += 1;
+}
+
+VALUE vm_invoke_block(rb_thread_t *th, rb_control_frame_t *reg_cfp, struct rb_calling_info *calling, const struct rb_call_info *ci);
+VALUE
+llrb_insn_invokeblock(VALUE th_v, VALUE cfp_v, VALUE ci_v, unsigned int stack_size, ...)
+{
+  rb_thread_t *th = (rb_thread_t *)th_v;
+  rb_control_frame_t *cfp = (rb_control_frame_t *)cfp_v;
+  CALL_INFO ci = (CALL_INFO)ci_v;
+
+  va_list ar;
+  va_start(ar, stack_size);
+  for (unsigned int i = 0; i < stack_size; i++) {
+    _llrb_push_result(cfp, va_arg(ar, VALUE));
+  }
+  va_end(ar);
+
+  struct rb_calling_info calling;
+  calling.argc = ci->orig_argc;
+  calling.block_handler = VM_BLOCK_HANDLER_NONE;
+  calling.recv = cfp->self;
+
+  VALUE val = vm_invoke_block(th, cfp, &calling, ci);
+  if (val == Qundef) {
+    VM_ENV_FLAGS_SET(th->cfp->ep, VM_FRAME_FLAG_FINISH);
+    return vm_exec(th);
+  }
+  return val;
+}

data/ext/llrb_insn_invokesuper.c

@@ -0,0 +1,47 @@
+#include "cruby.h"
+
+#define CALL_METHOD(calling, ci, cc) (*(cc)->call)(th, cfp, (calling), (ci), (cc))
+VALUE vm_exec(rb_thread_t *th);
+
+static inline void
+_llrb_push_result(rb_control_frame_t *cfp, VALUE result)
+{
+  // PUSH(result)
+  *(cfp->sp) = result;
+  cfp->sp += 1;
+}
+
+void vm_caller_setup_arg_block(const rb_thread_t *th, rb_control_frame_t *reg_cfp,
+    struct rb_calling_info *calling, const struct rb_call_info *ci, rb_iseq_t *blockiseq, const int is_super);
+void vm_search_super_method(rb_thread_t *th, rb_control_frame_t *reg_cfp,
+    struct rb_calling_info *calling, struct rb_call_info *ci, struct rb_call_cache *cc);
+VALUE
+llrb_insn_invokesuper(VALUE th_v, VALUE cfp_v, VALUE ci_v, VALUE cc_v, VALUE blockiseq_v, unsigned int stack_size, ...)
+{
+  rb_thread_t *th = (rb_thread_t *)th_v;
+  rb_control_frame_t *cfp = (rb_control_frame_t *)cfp_v;
+  CALL_INFO ci = (CALL_INFO)ci_v;
+  CALL_CACHE cc = (CALL_CACHE)cc_v;
+  ISEQ blockiseq = (ISEQ)blockiseq_v;
+
+  va_list ar;
+  va_start(ar, stack_size);
+  for (unsigned int i = 0; i < stack_size; i++) {
+    _llrb_push_result(cfp, va_arg(ar, VALUE));
+  }
+  va_end(ar);
+
+  struct rb_calling_info calling;
+  calling.argc = ci->orig_argc;
+
+  vm_caller_setup_arg_block(th, cfp, &calling, ci, blockiseq, 1);
+  calling.recv = th->cfp->self;
+  vm_search_super_method(th, th->cfp, &calling, ci, cc);
+
+  VALUE result = CALL_METHOD(&calling, ci, cc);
+  if (result == Qundef) {
+    VM_ENV_FLAGS_SET(th->cfp->ep, VM_FRAME_FLAG_FINISH);
+    return vm_exec(th);
+  }
+  return result;
+}

data/ext/llrb_insn_opt_aref.c

@@ -0,0 +1,25 @@
+#include "cruby.h"
+
+VALUE
+llrb_insn_opt_aref(VALUE recv, VALUE obj)
+{
+  if (!SPECIAL_CONST_P(recv)) {
+    if (RBASIC_CLASS(recv) == rb_cArray && BASIC_OP_UNREDEFINED_P(BOP_AREF, ARRAY_REDEFINED_OP_FLAG) && FIXNUM_P(obj)) {
+      return rb_ary_entry(recv, FIX2LONG(obj));
+    }
+    else if (RBASIC_CLASS(recv) == rb_cHash && BASIC_OP_UNREDEFINED_P(BOP_AREF, HASH_REDEFINED_OP_FLAG)) {
+      return rb_hash_aref(recv, obj);
+    }
+    else {
+      //goto INSN_LABEL(normal_dispatch);
+      return rb_funcall(recv, rb_intern("[]"), 1, obj);
+    }
+  }
+  else {
+    //INSN_LABEL(normal_dispatch):
+    //PUSH(recv);
+    //PUSH(obj);
+    //CALL_SIMPLE_METHOD(recv);
+    return rb_funcall(recv, rb_intern("[]"), 1, obj);
+  }
+}

data/ext/llrb_insn_opt_aset.c

@@ -0,0 +1,28 @@
+#include "cruby.h"
+
+VALUE
+llrb_insn_opt_aset(VALUE recv, VALUE obj, VALUE set)
+{
+  if (!SPECIAL_CONST_P(recv)) {
+    if (RBASIC_CLASS(recv) == rb_cArray && BASIC_OP_UNREDEFINED_P(BOP_ASET, ARRAY_REDEFINED_OP_FLAG) && FIXNUM_P(obj)) {
+      rb_ary_store(recv, FIX2LONG(obj), set);
+      return set;
+    }
+    else if (RBASIC_CLASS(recv) == rb_cHash && BASIC_OP_UNREDEFINED_P(BOP_ASET, HASH_REDEFINED_OP_FLAG)) {
+      rb_hash_aset(recv, obj, set);
+      return set;
+    }
+    else {
+      //goto INSN_LABEL(normal_dispatch);
+      return rb_funcall(recv, '+', 2, obj, set);
+    }
+  }
+  else {
+    //INSN_LABEL(normal_dispatch):
+    //PUSH(recv);
+    //PUSH(obj);
+    //PUSH(set);
+    //CALL_SIMPLE_METHOD(recv);
+    return rb_funcall(recv, '+', 2, obj, set);
+  }
+}

data/ext/llrb_insn_opt_div.c

@@ -0,0 +1,32 @@
+#include "cruby.h"
+
+VALUE
+llrb_insn_opt_div(VALUE recv, VALUE obj)
+{
+  if (FIXNUM_2_P(recv, obj) &&
+    BASIC_OP_UNREDEFINED_P(BOP_DIV, INTEGER_REDEFINED_OP_FLAG)) {
+    //if (FIX2LONG(obj) == 0) goto INSN_LABEL(normal_dispatch);
+    if (FIX2LONG(obj) == 0) return rb_funcall(recv, '/', 1, obj);
+    return rb_fix_div_fix(recv, obj);
+  }
+  else if (FLONUM_2_P(recv, obj) &&
+      BASIC_OP_UNREDEFINED_P(BOP_DIV, FLOAT_REDEFINED_OP_FLAG)) {
+    return DBL2NUM(RFLOAT_VALUE(recv) / RFLOAT_VALUE(obj));
+  }
+  //else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) {
+  //  if (RBASIC_CLASS(recv) == rb_cFloat && RBASIC_CLASS(obj) == rb_cFloat  &&
+  //    BASIC_OP_UNREDEFINED_P(BOP_DIV, FLOAT_REDEFINED_OP_FLAG)) {
+  //    val = DBL2NUM(RFLOAT_VALUE(recv) / RFLOAT_VALUE(obj));
+  //  }
+  //  else {
+  //    goto INSN_LABEL(normal_dispatch);
+  //  }
+  //}
+  else {
+    //INSN_LABEL(normal_dispatch):
+    //PUSH(recv);
+    //PUSH(obj);
+    //CALL_SIMPLE_METHOD(recv);
+    return rb_funcall(recv, '/', 1, obj);
+  }
+}

data/ext/llrb_insn_opt_eq.c

@@ -0,0 +1,57 @@
+#include "cruby.h"
+
+static inline VALUE
+opt_eq_func(VALUE recv, VALUE obj)
+{
+  if (FIXNUM_2_P(recv, obj) &&
+    BASIC_OP_UNREDEFINED_P(BOP_EQ, INTEGER_REDEFINED_OP_FLAG)) {
+    return (recv == obj) ? Qtrue : Qfalse;
+  }
+  else if (FLONUM_2_P(recv, obj) &&
+      BASIC_OP_UNREDEFINED_P(BOP_EQ, FLOAT_REDEFINED_OP_FLAG)) {
+    return (recv == obj) ? Qtrue : Qfalse;
+  }
+  //else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) {
+  //  if (RBASIC_CLASS(recv) == rb_cFloat &&
+  //    RBASIC_CLASS(obj) == rb_cFloat &&
+  //    BASIC_OP_UNREDEFINED_P(BOP_EQ, FLOAT_REDEFINED_OP_FLAG)) {
+  //    double a = RFLOAT_VALUE(recv);
+  //    double b = RFLOAT_VALUE(obj);
+
+  //    if (isnan(a) || isnan(b)) {
+  //      return Qfalse;
+  //    }
+  //    return  (a == b) ? Qtrue : Qfalse;
+  //  }
+  //  else if (RBASIC_CLASS(recv) == rb_cString &&
+  //      RBASIC_CLASS(obj) == rb_cString &&
+  //      BASIC_OP_UNREDEFINED_P(BOP_EQ, STRING_REDEFINED_OP_FLAG)) {
+  //    return rb_str_equal(recv, obj);
+  //  }
+  //}
+
+  //{
+  //  vm_search_method(ci, cc, recv);
+
+  //  if (check_cfunc(cc->me, rb_obj_equal)) {
+  //    return recv == obj ? Qtrue : Qfalse;
+  //  }
+  //}
+
+  return Qundef;
+}
+
+VALUE
+llrb_insn_opt_eq(VALUE recv, VALUE obj)
+{
+  VALUE val = opt_eq_func(recv, obj);
+
+  if (val == Qundef) {
+    /* other */
+    //PUSH(recv);
+    //PUSH(obj);
+    //CALL_SIMPLE_METHOD(recv);
+    return rb_funcall(recv, rb_intern("=="), 1, obj);
+  }
+  return val;
+}