cast_off 0.2.0

data/ext/cast_off/generated_c_include/iter_api.h

@@ -0,0 +1,595 @@
+static rb_iseq_t *construct_iter_api_iseq(VALUE (*fptr)(ANYARGS), ID mid)
+{
+  VALUE putnil = rb_ary_new();
+  VALUE pop = rb_ary_new();
+  VALUE send = rb_ary_new();
+  VALUE getlocal0 = rb_ary_new();
+  VALUE getlocal1 = rb_ary_new();
+  VALUE getlocal2 = rb_ary_new();
+  VALUE leave = rb_ary_new();
+  VALUE val = rb_ary_new();
+  VALUE misc = rb_hash_new();
+  VALUE locals = rb_ary_new();
+  VALUE exception = rb_ary_new();
+  VALUE body = rb_ary_new();
+  VALUE iseqval;
+  rb_iseq_t *iseq;
+
+  /* create putnil instruction */
+  rb_ary_push(putnil, ID2SYM(rb_intern("putnil")));
+
+  /* create pop instruction */
+  rb_ary_push(pop, ID2SYM(rb_intern("pop")));
+
+  /* create send instruction */
+  rb_ary_push(send, ID2SYM(rb_intern("send")));
+  rb_ary_push(send, ID2SYM(mid)); /* mid */
+  rb_ary_push(send, INT2FIX(2)); /* argc */
+  rb_ary_push(send, Qnil); /* blockiseq */
+  rb_ary_push(send, LONG2FIX(0)); /* flag */
+  rb_ary_push(send, LONG2FIX(0)); /* */
+
+  /* create getlocal instruction */
+  rb_ary_push(getlocal0, ID2SYM(rb_intern("getlocal")));
+  rb_ary_push(getlocal0, INT2FIX(4));
+  rb_ary_push(getlocal1, ID2SYM(rb_intern("getlocal")));
+  rb_ary_push(getlocal1, INT2FIX(3));
+  rb_ary_push(getlocal2, ID2SYM(rb_intern("getlocal")));
+  rb_ary_push(getlocal2, INT2FIX(2));
+
+  /* create leave instruction */
+  rb_ary_push(leave, ID2SYM(rb_intern("leave")));
+
+  /*
+   * [:magic, :major_version, :minor_version, :format_type, :misc,
+   *  :name, :filename, :filepath, :line_no, :type, :locals, :args,
+   *  :catch_table, :bytecode]
+   */
+  
+#define ISEQ_MAJOR_VERSION 1
+#define ISEQ_MINOR_VERSION 2
+  rb_ary_push(val, rb_str_new2("YARVInstructionSequence/SimpleDataFormat")); /* magic */
+  rb_ary_push(val, INT2FIX(ISEQ_MAJOR_VERSION)); /* major version */
+  rb_ary_push(val, INT2FIX(ISEQ_MINOR_VERSION)); /* minor version */
+  rb_ary_push(val, INT2FIX(1)); /* format type */
+
+  /* misc */
+  rb_hash_aset(misc, ID2SYM(rb_intern("arg_size")), INT2FIX(0));
+  rb_hash_aset(misc, ID2SYM(rb_intern("local_size")), INT2FIX(4));
+  rb_hash_aset(misc, ID2SYM(rb_intern("stack_max")), INT2FIX(3));
+  rb_ary_push(val, misc);
+
+  rb_ary_push(val, rb_str_new2("<compiled>")); /* name */
+  rb_ary_push(val, rb_str_new2("<compiled>")); /* filename */
+  rb_ary_push(val, rb_str_new2("<compiled>")); /* filepath */
+  rb_ary_push(val, INT2FIX(-1)); /* line_no */
+  rb_ary_push(val, ID2SYM(rb_intern("method"))); /* type */
+
+  /* locals */
+  rb_ary_push(locals, ID2SYM(rb_intern("recv")));
+  rb_ary_push(locals, ID2SYM(rb_intern("key")));
+  rb_ary_push(locals, ID2SYM(rb_intern("blockptr")));
+  rb_ary_push(val, locals);
+
+  /* args */
+  rb_ary_push(val, INT2FIX(0));
+
+  /* catch_table */
+  rb_ary_push(val, exception);
+
+  /* bytecode */
+  rb_ary_push(body, putnil);
+  rb_ary_push(body, pop);
+  rb_ary_push(body, getlocal0);
+  rb_ary_push(body, getlocal1);
+  rb_ary_push(body, getlocal2);
+  rb_ary_push(body, send);
+  rb_ary_push(body, leave);
+  rb_ary_push(val, body);
+
+  /* create iseq from ary */
+  iseqval = rb_iseq_load(val, Qnil, Qnil);
+  if (rb_class_of(iseqval) != rb_cISeq) {
+    rb_bug("construct_inline_api_iseq: should not be reached(0)");
+  }
+  iseq = DATA_PTR(iseqval);
+
+  rb_define_singleton_method(rb_mCastOff, rb_id2name(mid), fptr, 2);
+  return iseq;
+}
+NOINLINE(static rb_iseq_t *construct_iter_api_iseq(VALUE (*fptr)(ANYARGS), ID mid));
+
+static rb_iseq_t*
+search_iter_api_iseq(VALUE (*fptr)(ANYARGS), ID mid)
+{
+  VALUE deoptimization_iseq_table, val;
+  rb_iseq_t *iseq;
+
+  deoptimization_iseq_table = rb_const_get(rb_mCastOffCompiler, rb_intern("DEOPTIMIZATION_ISEQ_TABLE"));
+  val = rb_hash_aref(deoptimization_iseq_table, ID2SYM(mid));
+  if (rb_class_of(val) == rb_cISeq) {
+    iseq = DATA_PTR(val);
+  } else {
+    iseq = construct_iter_api_iseq(fptr, mid);
+    if (rb_class_of(iseq->self) != rb_cISeq) {
+      rb_bug("search_iter_api_iseq: should not be reached(0), mid = %s", rb_id2name(mid));
+    }
+    rb_hash_aset(deoptimization_iseq_table, ID2SYM(mid), iseq->self);
+  }
+
+  return iseq;
+}
+NOINLINE(static rb_iseq_t* search_iter_api_iseq(VALUE (*fptr)(ANYARGS), ID mid));
+
+#define iter_namegen(klass, mid, suffix) cast_off_ ## klass ## _ ## mid ## _ ## suffix
+#define _iter_strgen(str) #str
+#define iter_strgen(str) _iter_strgen(str)
+
+#define define_deoptimization_iseq_fetch_function(klass, mid) \
+static rb_iseq_t* \
+iter_namegen(klass, mid, deoptimization_iseq)(void) \
+{ \
+  ID mid = rb_intern(iter_strgen(iter_namegen(klass, mid, deoptimize))); \
+  return search_iter_api_iseq(iter_namegen(klass, mid, deoptimize), mid); \
+} \
+NOINLINE(static rb_iseq_t* iter_namegen(klass, mid, deoptimization_iseq)(void));
+
+#define define_frame_construction_function(klass, mid) \
+static void \
+iter_namegen(klass, mid, construct_frame)(void *key, VALUE blockptr) \
+{ \
+  VALUE thval = rb_thread_current(); \
+  rb_thread_t *th = DATA_PTR(thval); \
+  rb_control_frame_t *cfp = th->cfp; \
+  rb_iseq_t *iseq = iter_namegen(klass, mid, deoptimization_iseq)(); \
+  VALUE *sp = cfp->sp; \
+\
+  CHECK_STACK_OVERFLOW(cfp, 1); \
+  *sp++ = rb_mCastOff; \
+  *sp++ = GC_GUARDED_PTR(key); \
+  *sp++ = GC_GUARDED_PTR(blockptr); \
+  vm_push_frame(th, iseq, VM_FRAME_MAGIC_METHOD, rb_mCastOff, 0, iseq->iseq_encoded + 1, sp, 0, 1); \
+} \
+NOINLINE(static void iter_namegen(klass, mid, construct_frame)(void *key, VALUE blockptr));
+
+#define deoptimization_function_begin(klass, mid) \
+static VALUE \
+iter_namegen(klass, mid, deoptimize)(VALUE recv, VALUE k, VALUE b) \
+{ \
+  VALUE thval = rb_thread_current(); \
+  rb_thread_t *th = DATA_PTR(thval); \
+  rb_control_frame_t *cfp = th->cfp; \
+  iter_namegen(klass, mid, t) *key = GC_GUARDED_PTR_REF(k); \
+  cfp->lfp[0] = b; /* blockptr */ \
+  {
+
+#define deoptimization_function_end(klass, mid) \
+  } \
+} \
+NOINLINE(static VALUE iter_namegen(klass, mid, deoptimize)(VALUE recv, VALUE k, VALUE b));
+
+#define ArgError(a, b) rb_raise(rb_eArgError, "wrong number of arguments (%d for %d)", (a), (b))
+static inline int
+cast_off_prepare_iter_api_lambda_args(int use_c, VALUE *use_v, int given_c, VALUE *given_v, int simple, int must, int opt_len, int post_len, int post_start, int rest_index)
+{
+  int i, num = -1;
+  int rest_c = given_c;
+
+  if (simple) {
+    if (UNLIKELY(use_c != given_c)) {
+      ArgError(given_c, use_c);
+    }
+    for (i = 0; i < use_c; i++) {
+      use_v[i] = given_v[i];
+    }
+    return num;
+  }
+
+  /* mandatory */
+  if (given_c < (must + post_len)) { /* check with post arg */
+    ArgError(given_c, must + post_len);
+  }
+
+  for (i = 0; i < must; i++) {
+    use_v[i] = given_v[i];
+  }
+  rest_c -= must;
+
+  /* post arguments */
+  if (post_len) {
+    for (i = post_start; i < post_start + post_len; i++) {
+      use_v[i] = given_v[i];
+    }
+    rest_c -= post_len;
+  }
+
+  /* opt arguments */
+  if (opt_len) {
+    if (rest_index == -1 && rest_c > opt_len) {
+      ArgError(given_c, must + opt_len + post_len);
+    }
+
+    if (rest_c >= opt_len) {
+      for (i = must; i < must + opt_len; i++) {
+        use_v[i] = given_v[i];
+      }
+      num = must + opt_len;
+      rest_c -= opt_len;
+    } else {
+      for (i = must; i< must + rest_c; i++) {
+        use_v[i] = given_v[i];
+      }
+      for (i = must + rest_c; i < must + opt_len; i++) {
+        use_v[i] = Qundef;
+      }
+      num = must + rest_c;
+      rest_c = 0;
+    }
+  }
+
+  /* rest arguments */
+  if (rest_index != -1) {
+    if (rest_c) {
+      use_v[rest_index] = rb_ary_new4(rest_c, &given_v[must + opt_len]);
+    } else {
+      use_v[rest_index] = rb_ary_new();
+    }
+    rest_c = 0;
+  }
+
+  if (rest_c) rb_bug("cast_off_prepare_iter_api_lambda_args: should not be reached(0)");
+
+  return num;
+}
+
+static inline int
+cast_off_prepare_iter_api_block_args(int use_c, VALUE *use_v, int given_c, VALUE *given_v, int splat, int must, int opt_len, int post_len, int post_start, int rest_index)
+{
+  int i, cpy;
+  volatile VALUE mark;
+  int num = -1;
+
+  if (splat) {
+    VALUE ary;
+
+    if(given_c == 1 && !NIL_P(ary = rb_check_array_type(given_v[0]))) { /* rhs is only an array */
+      cpy = given_c = RARRAY_LENINT(ary);
+      if (cpy > must) cpy = must;
+      MEMCPY(use_v, RARRAY_PTR(ary), VALUE, cpy);
+      mark = ary;
+      given_v = RARRAY_PTR(ary);
+    } else {
+      cpy = given_c;
+      if (cpy > must) cpy = must;
+      for (i = 0; i < cpy; i++) {
+        use_v[i] = given_v[i];
+      }
+    }
+  } else {
+    cpy = given_c;
+    if (cpy > must) cpy = must;
+    for (i = 0; i < cpy; i++) {
+      use_v[i] = given_v[i];
+    }
+  }
+  for (i = cpy; i < must; i++) {
+    use_v[i] = Qnil;
+  }
+
+  if (post_len || opt_len) {
+    int rsize = given_c > must ? given_c - must : 0;    /* # of arguments which did not consumed yet */
+    int psize = rsize > post_len ? post_len : rsize;  /* # of post arguments */
+    int osize = 0;  /* # of opt arguments */
+    VALUE ary;
+
+    /* reserves arguments for post parameters */
+    rsize -= psize;
+
+    if (opt_len) {
+      if (rsize >= opt_len) {
+        osize = opt_len;
+        num = must + opt_len;
+        for (i = must; i < num; i++) {
+          use_v[i] = given_v[i];
+        }
+      } else {
+        osize = rsize;
+        num = must + rsize;
+        for (i = must; i < num; i++) {
+          use_v[i] = given_v[i];
+        }
+        for (i = num; i < must + opt_len; i++) {
+          use_v[i] = Qundef;
+        }
+      }
+    }
+    rsize -= osize;
+
+    if (rest_index == -1) {
+        /* copy post argument */
+        MEMMOVE(&use_v[post_start], &given_v[must + osize], VALUE, psize);
+    } else {
+        ary = rb_ary_new4(rsize, &given_v[rest_index]);
+
+        /* copy post argument */
+        MEMMOVE(&use_v[post_start], &given_v[must + rsize + osize], VALUE, psize);
+        use_v[rest_index] = ary;
+    }
+
+    for (i = psize; i < post_len; i++) {
+        use_v[post_start + i] = Qnil;
+    }
+  } else {
+    /* not opts and post_index */
+    if (rest_index != -1) {
+      if (given_c < rest_index) {
+        for (i = given_c; i < rest_index; i++) {
+          use_v[i] = Qnil;
+        }
+        use_v[rest_index] = rb_ary_new();
+      } else {
+        use_v[rest_index] = rb_ary_new4(given_c - rest_index, &given_v[rest_index]);
+      }
+    }
+  }
+
+#if 0
+  if (block_index != -1) {
+    VALUE procval;
+
+    if (rb_block_given_p()) {
+      procval = rb_block_proc();
+    } else {
+      procval = Qnil;
+    }
+    use_v[block_index] = procval;
+  }
+#endif
+
+  return num;
+}
+
+/* Fixnum#times */
+typedef struct cast_off_Fixnum_times_struct {
+  long fin;
+  long index;
+} cast_off_Fixnum_times_t;
+
+static inline VALUE
+cast_off_Fixnum_times_prep(cast_off_Fixnum_times_t *key, VALUE recv, int prep_argc, ...)
+{
+  int i;
+  VALUE ret;
+
+  if (prep_argc != 0) {
+    rb_raise(rb_eArgError, "invalid argument");
+  }
+
+  key->fin = FIX2LONG(recv);
+  key->index = 0;
+
+  return recv;
+}
+
+static inline VALUE
+cast_off_Fixnum_times_loop(cast_off_Fixnum_times_t *key, VALUE val, int argc, VALUE *argv, int splat, int must, int post_len, int post_start, int rest_index)
+{
+  int i;
+  long fin = key->fin;
+  long index = key->index;
+
+  if (index < fin) {
+    for (i = 0; i < argc; i++) {
+      if (i == 0) {
+        argv[0] = LONG2FIX(index);
+      } else {
+        argv[i] = Qnil;
+      }
+    }
+    key->index = index + 1;
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}
+
+static inline VALUE
+cast_off_Fixnum_times_finl(cast_off_Fixnum_times_t *key)
+{
+  return LONG2FIX(key->fin);
+}
+ 
+deoptimization_function_begin(Fixnum, times) {
+  while(key->index < key->fin) {
+    rb_yield(LONG2FIX(key->index));
+    key->index++;
+  }
+  return LONG2FIX(key->fin);
+};
+deoptimization_function_end(Fixnum, times);
+define_deoptimization_iseq_fetch_function(Fixnum, times);
+define_frame_construction_function(Fixnum, times);
+
+/* Array#map */
+typedef struct cast_off_Array_map_struct {
+  VALUE recv;
+  long index;
+  VALUE ret;
+} cast_off_Array_map_t;
+
+static inline VALUE
+cast_off_Array_map_prep(cast_off_Array_map_t *key, VALUE recv, int prep_argc, ...)
+{
+  VALUE ret;
+
+  if (prep_argc != 0) {
+    rb_raise(rb_eArgError, "invalid argument");
+  }
+
+  ret = rb_ary_new2(RARRAY_LEN(recv));
+
+  key->recv = recv;
+  key->index = 0;
+  key->ret = ret;
+
+  return ret;
+}
+
+static inline VALUE
+cast_off_Array_map_loop(cast_off_Array_map_t *key, VALUE val, int argc, VALUE *argv, int splat, int must, int post_len, int post_start, int rest_index)
+{
+  int i;
+  VALUE recv = key->recv;
+  long index = key->index;
+
+  if (index > 0) {
+    rb_ary_push(key->ret, val);
+  }
+
+  if (index < RARRAY_LEN(recv)) {
+    VALUE v[1];
+
+    v[0] = RARRAY_PTR(recv)[index];
+    cast_off_prepare_iter_api_block_args(argc, argv, 1, v, splat, must, 0, post_len, post_start, rest_index);
+    key->index = index + 1;
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}
+
+static inline VALUE
+cast_off_Array_map_finl(cast_off_Array_map_t *key)
+{
+  return key->ret;
+}
+
+deoptimization_function_begin(Array, map) {
+  while (key->index < RARRAY_LEN(key->recv)) {
+    rb_ary_push(key->ret, rb_yield(RARRAY_PTR(key->recv)[key->index]));
+    key->index++;
+  }
+  return key->ret;
+};
+deoptimization_function_end(Array, map);
+define_deoptimization_iseq_fetch_function(Array, map);
+define_frame_construction_function(Array, map);
+
+/* Array#map! */
+typedef struct cast_off_Array_map_bang_struct {
+  VALUE recv;
+  long index;
+} cast_off_Array_map_bang_t;
+
+static inline VALUE
+cast_off_Array_map_bang_prep(cast_off_Array_map_bang_t *key, VALUE recv, int prep_argc, ...)
+{
+  if (prep_argc != 0) {
+    rb_raise(rb_eArgError, "invalid argument");
+  }
+
+  rb_ary_modify(recv);
+
+  key->recv = recv;
+  key->index = 0;
+
+  return recv;
+}
+
+static inline VALUE
+cast_off_Array_map_bang_loop(cast_off_Array_map_bang_t *key, VALUE val, int argc, VALUE *argv, int splat, int must, int post_len, int post_start, int rest_index)
+{
+  int i;
+  VALUE recv = key->recv;
+  long index = key->index;
+
+  if (index > 0) {
+    rb_ary_store(recv, index - 1, val);
+  }
+
+  if (index < RARRAY_LEN(recv)) {
+    VALUE v[1];
+
+    v[0] = RARRAY_PTR(recv)[index];
+    cast_off_prepare_iter_api_block_args(argc, argv, 1, v, splat, must, 0, post_len, post_start, rest_index);
+    key->index = index + 1;
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}
+
+static inline VALUE
+cast_off_Array_map_bang_finl(cast_off_Array_map_bang_t *key)
+{
+  return key->recv;
+}
+
+deoptimization_function_begin(Array, map_bang) {
+  while (key->index < RARRAY_LEN(key->recv)) {
+    rb_ary_store(key->recv, key->index, rb_yield(RARRAY_PTR(key->recv)[key->index]));
+    key->index++;
+  }
+  return key->recv;
+};
+deoptimization_function_end(Array, map_bang);
+define_deoptimization_iseq_fetch_function(Array, map_bang);
+define_frame_construction_function(Array, map_bang);
+
+/* Array#each */
+typedef struct cast_off_Array_each_struct {
+  VALUE recv;
+  long index;
+} cast_off_Array_each_t;
+
+static inline VALUE
+cast_off_Array_each_prep(cast_off_Array_each_t *key, VALUE recv, int prep_argc, ...)
+{
+  int i;
+
+  if (prep_argc != 0) {
+    rb_raise(rb_eArgError, "invalid argument");
+  }
+
+  key->recv = recv;
+  key->index = 0;
+
+  return recv;
+}
+ 
+static inline VALUE
+cast_off_Array_each_loop(cast_off_Array_each_t *key, VALUE val, int argc, VALUE *argv, int splat, int must, int post_len, int post_start, int rest_index)
+{
+  int i;
+  VALUE recv = key->recv;
+  long index = key->index;
+
+  if (index < RARRAY_LEN(recv)) {
+    VALUE v[1];
+
+    v[0] = RARRAY_PTR(recv)[index];
+    cast_off_prepare_iter_api_block_args(argc, argv, 1, v, splat, must, 0, post_len, post_start, rest_index);
+    key->index = index + 1;
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}
+
+static inline VALUE
+cast_off_Array_each_finl(cast_off_Array_each_t *key)
+{
+  return key->recv;
+}
+
+deoptimization_function_begin(Array, each) {
+  while (key->index < RARRAY_LEN(key->recv)) {
+    rb_yield(RARRAY_PTR(key->recv)[key->index]);
+    key->index++;
+  }
+  return key->recv;
+};
+deoptimization_function_end(Array, each);
+define_deoptimization_iseq_fetch_function(Array, each);
+define_frame_construction_function(Array, each);
+