llrb 0.0.1

data/ext/llrb_insn_opt_ge.c

@@ -0,0 +1,28 @@
+#include "cruby.h"
+
+VALUE
+llrb_insn_opt_ge(VALUE recv, VALUE obj)
+{
+  if (FIXNUM_2_P(recv, obj) &&
+    BASIC_OP_UNREDEFINED_P(BOP_GE, INTEGER_REDEFINED_OP_FLAG)) {
+    SIGNED_VALUE a = recv, b = obj;
+
+    if (a >= b) {
+      return Qtrue;
+    }
+    else {
+      return Qfalse;
+    }
+  }
+  else if (FLONUM_2_P(recv, obj) &&
+      BASIC_OP_UNREDEFINED_P(BOP_GE, FLOAT_REDEFINED_OP_FLAG)) {
+    /* flonum is not NaN */
+    return RFLOAT_VALUE(recv) >= RFLOAT_VALUE(obj) ? Qtrue : Qfalse;
+  }
+  else {
+    //PUSH(recv);
+    //PUSH(obj);
+    //CALL_SIMPLE_METHOD(recv);
+    return rb_funcall(recv, rb_intern(">="), 1, obj);
+  }
+}

data/ext/llrb_insn_opt_gt.c

@@ -0,0 +1,38 @@
+#include "cruby.h"
+
+VALUE
+llrb_insn_opt_gt(VALUE recv, VALUE obj)
+{
+  if (FIXNUM_2_P(recv, obj) &&
+    BASIC_OP_UNREDEFINED_P(BOP_GT, INTEGER_REDEFINED_OP_FLAG)) {
+    SIGNED_VALUE a = recv, b = obj;
+
+    if (a > b) {
+      return Qtrue;
+    }
+    else {
+      return Qfalse;
+    }
+  }
+  else if (FLONUM_2_P(recv, obj) &&
+      BASIC_OP_UNREDEFINED_P(BOP_GT, FLOAT_REDEFINED_OP_FLAG)) {
+    /* flonum is not NaN */
+    return RFLOAT_VALUE(recv) > RFLOAT_VALUE(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_GT, FLOAT_REDEFINED_OP_FLAG)) {
+  //    val = double_cmp_gt(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_le.c

@@ -0,0 +1,29 @@
+#include "cruby.h"
+
+VALUE
+llrb_insn_opt_le(VALUE recv, VALUE obj)
+{
+  if (FIXNUM_2_P(recv, obj) &&
+    BASIC_OP_UNREDEFINED_P(BOP_LE, INTEGER_REDEFINED_OP_FLAG)) {
+    SIGNED_VALUE a = recv, b = obj;
+
+    if (a <= b) {
+      return Qtrue;
+    }
+    else {
+      return Qfalse;
+    }
+  }
+  else if (FLONUM_2_P(recv, obj) &&
+      BASIC_OP_UNREDEFINED_P(BOP_LE, FLOAT_REDEFINED_OP_FLAG)) {
+    /* flonum is not NaN */
+    return RFLOAT_VALUE(recv) <= RFLOAT_VALUE(obj) ? Qtrue : Qfalse;
+  }
+  else {
+    /* other */
+    //PUSH(recv);
+    //PUSH(obj);
+    //CALL_SIMPLE_METHOD(recv);
+    return rb_funcall(recv, rb_intern("<="), 1, obj);
+  }
+}

data/ext/llrb_insn_opt_lt.c

@@ -0,0 +1,38 @@
+#include "cruby.h"
+
+VALUE
+llrb_insn_opt_lt(VALUE recv, VALUE obj)
+{
+  if (FIXNUM_2_P(recv, obj) &&
+      BASIC_OP_UNREDEFINED_P(BOP_LT, INTEGER_REDEFINED_OP_FLAG)) {
+    SIGNED_VALUE a = recv, b = obj;
+
+    if (a < b) {
+      return Qtrue;
+    }
+    else {
+      return Qfalse;
+    }
+  }
+  else if (FLONUM_2_P(recv, obj) &&
+      BASIC_OP_UNREDEFINED_P(BOP_LT, FLOAT_REDEFINED_OP_FLAG)) {
+    /* flonum is not NaN */
+    return RFLOAT_VALUE(recv) < RFLOAT_VALUE(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_LT, FLOAT_REDEFINED_OP_FLAG)) {
+  //    val = double_cmp_lt(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_ltlt.c

@@ -0,0 +1,27 @@
+#include "cruby.h"
+
+VALUE
+llrb_insn_opt_ltlt(VALUE recv, VALUE obj)
+{
+  if (!SPECIAL_CONST_P(recv)) {
+    if (RBASIC_CLASS(recv) == rb_cString &&
+      BASIC_OP_UNREDEFINED_P(BOP_LTLT, STRING_REDEFINED_OP_FLAG)) {
+      return rb_str_concat(recv, obj);
+    }
+    else if (RBASIC_CLASS(recv) == rb_cArray &&
+        BASIC_OP_UNREDEFINED_P(BOP_LTLT, ARRAY_REDEFINED_OP_FLAG)) {
+      return rb_ary_push(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_minus.c

@@ -0,0 +1,36 @@
+#include "cruby.h"
+
+VALUE
+llrb_insn_opt_minus(VALUE recv, VALUE obj)
+{
+  if (FIXNUM_2_P(recv, obj) &&
+      BASIC_OP_UNREDEFINED_P(BOP_MINUS, INTEGER_REDEFINED_OP_FLAG)) {
+    long a, b, c;
+
+    a = FIX2LONG(recv);
+    b = FIX2LONG(obj);
+    c = a - b;
+    return LONG2NUM(c);
+  }
+  else if (FLONUM_2_P(recv, obj) &&
+      BASIC_OP_UNREDEFINED_P(BOP_MINUS, 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_MINUS, FLOAT_REDEFINED_OP_FLAG)) {
+  //    val = DBL2NUM(RFLOAT_VALUE(recv) - RFLOAT_VALUE(obj));
+  //  }
+  //  else {
+  //    goto INSN_LABEL(normal_dispatch);
+  //  }
+  //}
+  else {
+    /* other */
+    //INSN_LABEL(normal_dispatch):
+    //PUSH(recv);
+    //PUSH(obj);
+    //CALL_SIMPLE_METHOD(recv);
+    return rb_funcall(recv, '-', 1, obj);
+  }
+}

data/ext/llrb_insn_opt_mod.c

@@ -0,0 +1,32 @@
+#include "cruby.h"
+
+VALUE
+llrb_insn_opt_mod(VALUE recv, VALUE obj)
+{
+  if (FIXNUM_2_P(recv, obj) &&
+    BASIC_OP_UNREDEFINED_P(BOP_MOD, 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_mod_fix(recv, obj);
+  }
+  else if (FLONUM_2_P(recv, obj) &&
+      BASIC_OP_UNREDEFINED_P(BOP_MOD, FLOAT_REDEFINED_OP_FLAG)) {
+    return DBL2NUM(ruby_float_mod(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_MOD, FLOAT_REDEFINED_OP_FLAG)) {
+  //    val = DBL2NUM(ruby_float_mod(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_mult.c

@@ -0,0 +1,30 @@
+#include "cruby.h"
+
+VALUE
+llrb_insn_opt_mult(VALUE recv, VALUE obj)
+{
+  if (FIXNUM_2_P(recv, obj) &&
+      BASIC_OP_UNREDEFINED_P(BOP_MULT, INTEGER_REDEFINED_OP_FLAG)) {
+    return rb_fix_mul_fix(recv, obj);
+  }
+  else if (FLONUM_2_P(recv, obj) &&
+      BASIC_OP_UNREDEFINED_P(BOP_MULT, 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_MULT, 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_neq.c

@@ -0,0 +1,103 @@
+#include "cruby.h"
+
+void vm_search_method(const struct rb_call_info *ci, struct rb_call_cache *cc, VALUE recv);
+
+inline VALUE
+rb_obj_equal(VALUE obj1, VALUE obj2)
+{
+    if (obj1 == obj2) return Qtrue;
+    return Qfalse;
+}
+
+#define id_eq               idEq
+inline VALUE
+rb_obj_not_equal(VALUE obj1, VALUE obj2)
+{
+    VALUE result = rb_funcall(obj1, id_eq, 1, obj2);
+    return RTEST(result) ? Qfalse : Qtrue;
+}
+
+static inline int
+check_cfunc(const rb_callable_method_entry_t *me, VALUE (*func)())
+{
+  if (me && me->def->type == VM_METHOD_TYPE_CFUNC &&
+      me->def->body.cfunc.func == func) {
+    return 1;
+  }
+  else {
+    return 0;
+  }
+}
+
+static inline VALUE
+opt_eq_func(VALUE recv, VALUE obj, CALL_INFO ci, CALL_CACHE cc)
+{
+  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;
+}
+
+static inline VALUE
+_llrb_insn_opt_neq(VALUE recv, VALUE obj, CALL_INFO ci, CALL_CACHE cc, CALL_INFO ci_eq, CALL_CACHE cc_eq)
+{
+  //extern VALUE rb_obj_not_equal(VALUE obj1, VALUE obj2);
+  vm_search_method(ci, cc, recv);
+
+  VALUE val = Qundef;
+
+  if (check_cfunc(cc->me, rb_obj_not_equal)) {
+    val = opt_eq_func(recv, obj, ci_eq, cc_eq);
+
+    if (val != Qundef) {
+      val = RTEST(val) ? Qfalse : Qtrue;
+    }
+  }
+
+  if (val == Qundef) {
+    /* other */
+    //PUSH(recv);
+    //PUSH(obj);
+    //CALL_SIMPLE_METHOD(recv);
+    return rb_funcall(recv, rb_intern("!="), 1, obj);
+  }
+  return val;
+}
+
+VALUE
+llrb_insn_opt_neq(VALUE recv, VALUE obj, VALUE ci, VALUE cc, VALUE ci_eq, VALUE cc_eq)
+{
+  return _llrb_insn_opt_neq(recv, obj, (CALL_INFO)ci, (CALL_CACHE)cc, (CALL_INFO)ci_eq, (CALL_CACHE)cc_eq);
+}

data/ext/llrb_insn_opt_plus.c

@@ -0,0 +1,48 @@
+#include "cruby.h"
+
+VALUE
+llrb_insn_opt_plus(VALUE recv, VALUE obj)
+{
+  if (FIXNUM_2_P(recv, obj) &&
+      BASIC_OP_UNREDEFINED_P(BOP_PLUS,INTEGER_REDEFINED_OP_FLAG)) {
+    /* fixnum + fixnum */
+#ifndef LONG_LONG_VALUE
+    VALUE msb = (VALUE)1 << ((sizeof(VALUE) * CHAR_BIT) - 1);
+    VALUE val = recv - 1 + obj;
+    if ((~(recv ^ obj) & (recv ^ val)) & msb) {
+      return rb_int2big((SIGNED_VALUE)((val>>1) | (recv & msb)));
+    }
+    return val;
+#else
+    return LONG2NUM(FIX2LONG(recv) + FIX2LONG(obj));
+#endif
+  }
+  else if (FLONUM_2_P(recv, obj) &&
+      BASIC_OP_UNREDEFINED_P(BOP_PLUS, 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_PLUS, FLOAT_REDEFINED_OP_FLAG)) {
+  //    val = DBL2NUM(RFLOAT_VALUE(recv) + RFLOAT_VALUE(obj));
+  //  }
+  //  else if (RBASIC_CLASS(recv) == rb_cString && RBASIC_CLASS(obj) == rb_cString &&
+  //      BASIC_OP_UNREDEFINED_P(BOP_PLUS, STRING_REDEFINED_OP_FLAG)) {
+  //    val = rb_str_plus(recv, obj);
+  //  }
+  //  else if (RBASIC_CLASS(recv) == rb_cArray &&
+  //    BASIC_OP_UNREDEFINED_P(BOP_PLUS, ARRAY_REDEFINED_OP_FLAG)) {
+  //    val = rb_ary_plus(recv, 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_send_without_block.c

@@ -0,0 +1,45 @@
+#include "cruby.h"
+
+static inline void
+_llrb_push_result(rb_control_frame_t *cfp, VALUE result)
+{
+  // PUSH(result)
+  *(cfp->sp) = result;
+  cfp->sp += 1;
+}
+
+#define CALL_METHOD(calling, ci, cc) (*(cc)->call)(th, cfp, (calling), (ci), (cc))
+void vm_search_method(const struct rb_call_info *ci, struct rb_call_cache *cc, VALUE recv);
+VALUE vm_exec(rb_thread_t *th);
+VALUE // TODO: refactor with invokesuper
+llrb_insn_opt_send_without_block(VALUE th_value, VALUE cfp_value, VALUE ci_value, VALUE cc_value, unsigned int stack_size, ...)
+{
+  rb_thread_t *th = (rb_thread_t *)th_value;
+  rb_control_frame_t *cfp = (rb_control_frame_t *)cfp_value;
+  CALL_INFO ci = (CALL_INFO)ci_value;
+  CALL_CACHE cc = (CALL_CACHE)cc_value;
+
+  VALUE recv = Qnil;
+  va_list ar;
+  va_start(ar, stack_size);
+  for (unsigned int i = 0; i < stack_size; i++) {
+    VALUE val = va_arg(ar, VALUE);
+    if (i == 0) recv = val;
+    _llrb_push_result(cfp, val);
+  }
+  va_end(ar);
+
+  vm_search_method(ci, cc, recv);
+
+  struct rb_calling_info calling;
+  calling.block_handler = VM_BLOCK_HANDLER_NONE;
+  calling.argc = ci->orig_argc;
+  calling.recv = recv;
+
+  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;
+}