llrb 0.0.1

data/ext/llrb_insn_opt_str_freeze.c

@@ -0,0 +1,12 @@
+#include "cruby.h"
+
+VALUE
+llrb_insn_opt_str_freeze(VALUE str)
+{
+  if (BASIC_OP_UNREDEFINED_P(BOP_FREEZE, STRING_REDEFINED_OP_FLAG)) {
+    return str;
+  }
+  else {
+    return rb_funcall(rb_str_resurrect(str), idFreeze, 0);
+  }
+}

data/ext/llrb_insn_putspecialobject.c

@@ -0,0 +1,23 @@
+#include "cruby.h"
+
+VALUE vm_get_cbase(const VALUE *ep);
+VALUE vm_get_const_base(const VALUE *ep);
+VALUE
+llrb_insn_putspecialobject(rb_num_t value_type) {
+  enum vm_special_object_type type = (enum vm_special_object_type)value_type;
+
+  switch (type) {
+    case VM_SPECIAL_OBJECT_VMCORE:
+      return rb_mRubyVMFrozenCore;
+    case VM_SPECIAL_OBJECT_CBASE: {
+      rb_thread_t *th = GET_THREAD();
+      return vm_get_cbase(th->cfp->ep);
+    }
+    case VM_SPECIAL_OBJECT_CONST_BASE: {
+      rb_thread_t *th = GET_THREAD();
+      return vm_get_const_base(th->cfp->ep);
+    }
+    default:
+      rb_bug("putspecialobject insn: unknown value_type");
+  }
+}

data/ext/llrb_insn_send.c

@@ -0,0 +1,49 @@
+#include "cruby.h"
+
+#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);
+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);
+
+static inline void
+_llrb_push_result(rb_control_frame_t *cfp, VALUE result)
+{
+  // PUSH(result)
+  *(cfp->sp) = result;
+  cfp->sp += 1;
+}
+
+VALUE
+llrb_insn_send(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;
+
+  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);
+
+  struct rb_calling_info calling;
+
+  vm_caller_setup_arg_block(th, cfp, &calling, ci, blockiseq, 0);
+  calling.argc = ci->orig_argc;
+  calling.recv = recv;
+  vm_search_method(ci, cc, 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;
+}

data/ext/llrb_insn_setclassvariable.c

@@ -0,0 +1,19 @@
+#include "cruby.h"
+
+rb_cref_t * rb_vm_get_cref(const VALUE *ep);
+static inline void
+vm_ensure_not_refinement_module(VALUE self)
+{
+  if (RB_TYPE_P(self, T_MODULE) && FL_TEST(self, RMODULE_IS_REFINEMENT)) {
+    rb_warn("not defined at the refinement, but at the outer class/module");
+  }
+}
+
+VALUE vm_get_cvar_base(const rb_cref_t *cref, rb_control_frame_t *cfp);
+void
+llrb_insn_setclassvariable(VALUE cfp_v, ID id, VALUE val)
+{
+  rb_control_frame_t *cfp = (rb_control_frame_t *)cfp_v;
+  vm_ensure_not_refinement_module(cfp->self);
+  rb_cvar_set(vm_get_cvar_base(rb_vm_get_cref(cfp->ep), cfp), id, val);
+}

data/ext/llrb_insn_setconstant.c

@@ -0,0 +1,23 @@
+#include "cruby.h"
+
+static inline void
+vm_check_if_namespace(VALUE klass)
+{
+  if (!RB_TYPE_P(klass, T_CLASS) && !RB_TYPE_P(klass, T_MODULE)) {
+    rb_raise(rb_eTypeError, "%+"PRIsVALUE" is not a class/module", klass);
+  }
+}
+static inline void
+vm_ensure_not_refinement_module(VALUE self)
+{
+  if (RB_TYPE_P(self, T_MODULE) && FL_TEST(self, RMODULE_IS_REFINEMENT)) {
+    rb_warn("not defined at the refinement, but at the outer class/module");
+  }
+}
+// https://github.com/ruby/ruby/blob/v2_4_1/insns.def#L201-L223
+void
+llrb_insn_setconstant(VALUE self, VALUE cbase, ID id, VALUE val) {
+  vm_check_if_namespace(cbase);
+  vm_ensure_not_refinement_module(self);
+  rb_const_set(cbase, id, val);
+}

data/ext/llrb_insn_setinstancevariable.c

@@ -0,0 +1,48 @@
+#include "cruby.h"
+
+static inline VALUE
+vm_setivar(VALUE obj, ID id, VALUE val, IC ic, struct rb_call_cache *cc, int is_attr)
+{
+  rb_check_frozen(obj);
+
+  if (LIKELY(RB_TYPE_P(obj, T_OBJECT))) {
+    VALUE klass = RBASIC(obj)->klass;
+    st_data_t index;
+
+    if (LIKELY(
+      (!is_attr && ic->ic_serial == RCLASS_SERIAL(klass)) ||
+      (is_attr && cc->aux.index > 0))) {
+      VALUE *ptr = ROBJECT_IVPTR(obj);
+      index = !is_attr ? ic->ic_value.index : cc->aux.index-1;
+
+      if (index < ROBJECT_NUMIV(obj)) {
+        RB_OBJ_WRITE(obj, &ptr[index], val);
+        return val; /* inline cache hit */
+      }
+    }
+    else {
+      struct st_table *iv_index_tbl = ROBJECT_IV_INDEX_TBL(obj);
+
+      if (iv_index_tbl && st_lookup(iv_index_tbl, (st_data_t)id, &index)) {
+        if (!is_attr) {
+          ic->ic_value.index = index;
+          ic->ic_serial = RCLASS_SERIAL(klass);
+        }
+        else if (index >= INT_MAX) {
+          rb_raise(rb_eArgError, "too many instance variables");
+        }
+        else {
+          cc->aux.index = (int)(index + 1);
+        }
+      }
+      /* fall through */
+    }
+  }
+  return rb_ivar_set(obj, id, val);
+}
+
+void
+llrb_insn_setinstancevariable(VALUE obj, ID id, VALUE val, VALUE ic_v)
+{
+  vm_setivar(obj, id, val, (IC)ic_v, 0, 0);
+}

data/ext/llrb_insn_setlocal.c

@@ -0,0 +1,16 @@
+#include "cruby.h"
+
+void rb_vm_env_write(const VALUE *ep, int index, VALUE v);
+
+void
+llrb_insn_setlocal(VALUE cfp_v, lindex_t idx, rb_num_t level, VALUE val)
+{
+  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);
+  }
+  rb_vm_env_write(ep, -(int)idx, val);
+}

data/ext/llrb_insn_setlocal_level0.c

@@ -0,0 +1,9 @@
+#include "cruby.h"
+
+void rb_vm_env_write(const VALUE *ep, int index, VALUE v);
+void
+llrb_insn_setlocal_level0(VALUE cfp_v, lindex_t idx, VALUE val)
+{
+  rb_control_frame_t *cfp = (rb_control_frame_t *)cfp_v;
+  rb_vm_env_write(cfp->ep, -(int)idx, val);
+}

data/ext/llrb_insn_setlocal_level1.c

@@ -0,0 +1,10 @@
+#include "cruby.h"
+
+void rb_vm_env_write(const VALUE *ep, int index, VALUE v);
+
+void
+llrb_insn_setlocal_level1(VALUE cfp_v, lindex_t idx, VALUE val)
+{
+  rb_control_frame_t *cfp = (rb_control_frame_t *)cfp_v;
+  rb_vm_env_write(GET_PREV_EP(cfp->ep), -(int)idx, val);
+}

data/ext/llrb_insn_setspecial.c

@@ -0,0 +1,15 @@
+#include "cruby.h"
+
+void lep_svar_set(rb_thread_t *th, const VALUE *lep, rb_num_t key, VALUE val);
+void
+llrb_insn_setspecial(rb_num_t key, VALUE obj)
+{
+  rb_thread_t *th = GET_THREAD();
+
+  const VALUE *ep = th->cfp->ep;
+  while (!VM_ENV_LOCAL_P(ep)) {
+    ep = VM_ENV_PREV_EP(ep);
+  }
+
+  lep_svar_set(th, ep, key, obj);
+}

data/ext/llrb_insn_splatarray.c

@@ -0,0 +1,13 @@
+#include "cruby.h"
+
+// https://github.com/ruby/ruby/blob/v2_4_1/insns.def#L515-L534
+VALUE
+llrb_insn_splatarray(VALUE ary, VALUE flag) {
+  VALUE tmp = rb_check_convert_type(ary, T_ARRAY, "Array", "to_a");
+  if (NIL_P(tmp)) {
+    tmp = rb_ary_new3(1, ary);
+  } else if (RTEST(flag)) {
+    tmp = rb_ary_dup(tmp);
+  }
+  return tmp;
+}

data/ext/llrb_insn_throw.c

@@ -0,0 +1,11 @@
+#include "cruby.h"
+
+VALUE vm_throw(rb_thread_t *th, rb_control_frame_t *reg_cfp, rb_num_t throw_state, VALUE throwobj);
+void
+llrb_insn_throw(VALUE th_value, VALUE cfp_value, rb_num_t throw_state, VALUE throwobj)
+{
+  rb_thread_t *th = (rb_thread_t *)th_value;
+  rb_control_frame_t *cfp = (rb_control_frame_t *)cfp_value;
+  RUBY_VM_CHECK_INTS(th);
+  th->errinfo = vm_throw(th, cfp, throw_state, throwobj);
+}

data/ext/llrb_insn_trace.c

@@ -0,0 +1,37 @@
+#include "cruby.h"
+#include "cruby/probes_helper.h"
+
+// TODO: Use vm_dtrace after Ruby 2.5
+static inline void
+_llrb_insn_trace(rb_thread_t *th, rb_control_frame_t *cfp, rb_event_flag_t flag, VALUE val)
+{
+  if (RUBY_DTRACE_METHOD_ENTRY_ENABLED() ||
+      RUBY_DTRACE_METHOD_RETURN_ENABLED() ||
+      RUBY_DTRACE_CMETHOD_ENTRY_ENABLED() ||
+      RUBY_DTRACE_CMETHOD_RETURN_ENABLED()) {
+
+    switch (flag) {
+      case RUBY_EVENT_CALL:
+        RUBY_DTRACE_METHOD_ENTRY_HOOK(th, 0, 0);
+        break;
+      case RUBY_EVENT_C_CALL:
+        RUBY_DTRACE_CMETHOD_ENTRY_HOOK(th, 0, 0);
+        break;
+      case RUBY_EVENT_RETURN:
+        RUBY_DTRACE_METHOD_RETURN_HOOK(th, 0, 0);
+        break;
+      case RUBY_EVENT_C_RETURN:
+        RUBY_DTRACE_CMETHOD_RETURN_HOOK(th, 0, 0);
+        break;
+    }
+  }
+
+  // TODO: Confirm it works!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+  // Especially for :line event. We may need to update program counter.
+  EXEC_EVENT_HOOK(th, flag, cfp->self, 0, 0, 0 /* id and klass are resolved at callee */, val);
+}
+void
+llrb_insn_trace(VALUE th, VALUE cfp, rb_event_flag_t flag, VALUE val)
+{
+  _llrb_insn_trace((rb_thread_t *)th, (rb_control_frame_t *)cfp, flag, val);
+}

data/ext/llrb_push_result.c

@@ -0,0 +1,14 @@
+#include "cruby.h"
+
+static inline void
+_llrb_push_result(rb_control_frame_t *cfp, VALUE result)
+{
+  // PUSH(result)
+  *(cfp->sp) = result;
+  cfp->sp += 1;
+}
+void
+llrb_push_result(VALUE cfp, VALUE result)
+{
+  _llrb_push_result((rb_control_frame_t *)cfp, result);
+}

data/ext/llrb_self_from_cfp.c

@@ -0,0 +1,12 @@
+#include "cruby.h"
+
+static inline VALUE
+_llrb_self_from_cfp(rb_control_frame_t *cfp)
+{
+  return cfp->self;
+}
+VALUE
+llrb_self_from_cfp(VALUE cfp)
+{
+  return _llrb_self_from_cfp((rb_control_frame_t *)cfp);
+}

data/ext/llrb_set_pc.c

@@ -0,0 +1,8 @@
+#include "cruby.h"
+
+void
+llrb_set_pc(VALUE cfp_v, VALUE pc_v)
+{
+  rb_control_frame_t *cfp = (rb_control_frame_t *)cfp_v;
+  cfp->pc = (VALUE *)pc_v;
+}

data/lib/llrb.rb

@@ -0,0 +1,2 @@
+require 'llrb/version'
+require 'llrb/jit'

data/lib/llrb/jit.rb

@@ -0,0 +1,76 @@
+require 'llrb/llrb'
+
+module LLRB
+  module JIT
+    # Compile method to native code
+    #
+    # @param [Object] recv - receiver of method to be compiled
+    # @param [String,Symbol] method - precompiled method name
+    # @return [Boolean] - return true if precompiled
+    def self.compile(recv, name)
+      compile_proc(recv.method(name))
+    end
+
+    def self.compile_proc(func)
+      iseqw = RubyVM::InstructionSequence.of(func)
+      return false if iseqw.nil? # method defined with C function can't be compiled
+
+      #puts "#{iseqw.disasm}\n"
+      compile_iseq(iseqw)
+    end
+
+    # Preview compiled method in LLVM IR
+    #
+    # @param [Object] recv - receiver of method to be compiled
+    # @param [String,Symbol] method_name - precompiled method name
+    def self.preview(recv, name)
+      method = recv.method(name)
+      iseqw = RubyVM::InstructionSequence.of(method)
+      return false if iseqw.nil?
+
+      puts "#{iseqw.disasm}\n"
+      preview_iseq(iseqw)
+    end
+
+    def self.compiled?(recv, name)
+      method = recv.method(name)
+      iseqw = RubyVM::InstructionSequence.of(method)
+      return false if iseqw.nil?
+
+      is_compiled(iseqw)
+    end
+
+    def self.start
+      hook_stop
+      start_internal
+    end
+
+    # Hook JIT stop at exit to safely shutdown Ruby VM. JIT touches Ruby VM and
+    # it should not run after Ruby VM destruction. Otherwise it will cause SEGV.
+    def self.hook_stop
+      return if defined?(@hook_stop)
+      @hook_stop = true
+      at_exit { LLRB::JIT.stop }
+    end
+    private_class_method :hook_stop
+
+    # Followings are defined in ext/llrb/llrb.cc
+
+    # @param  [RubyVM::InstructionSequence] iseqw - RubyVM::InstructionSequence instance
+    # @return [Boolean] return true if compiled
+    private_class_method :compile_iseq
+
+    # @param  [RubyVM::InstructionSequence] iseqw - RubyVM::InstructionSequence instance
+    # @return [Boolean] return true if compiled
+    private_class_method :preview_iseq
+
+    # @param  [RubyVM::InstructionSequence] iseqw - RubyVM::InstructionSequence instance
+    # @return [Boolean] return true if compiled
+    private_class_method :is_compiled
+
+    # This does not hook stop, but it may cause SEGV if JIT runs after Ruby VM is shut down.
+    # To ensure JIT will be stopped on exit, you should use .start instead.
+    # @return [Boolean] return true if started JIT
+    private_class_method :start_internal
+  end
+end

data/lib/llrb/start.rb

@@ -0,0 +1,2 @@
+require 'llrb'
+LLRB::JIT.start

data/lib/llrb/version.rb

@@ -0,0 +1,3 @@
+module LLRB
+  VERSION = '0.0.1'
+end

data/llrb.gemspec

@@ -0,0 +1,48 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'llrb/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'llrb'
+  spec.version       = LLRB::VERSION
+  spec.authors       = ['Takashi Kokubun']
+  spec.email         = ['takashikkbn@gmail.com']
+
+  spec.summary       = 'LLRB is LLVM-based JIT compiler for Ruby. Note that this gem can be only installed to fork of CRuby.'
+  spec.description   = 'LLRB is LLVM-based JIT compiler for Ruby. Note that this gem can be only installed to fork of CRuby.'
+  spec.homepage      = 'https://github.com/k0kubun/llrb'
+  spec.license       = 'MIT'
+
+  ccans = Dir.chdir("#{__dir__}/ext/llrb/cruby") { Dir.glob("ccan/**/*.h") }
+  cruby = (ccans + %w[
+    internal.h
+    iseq.h
+    method.h
+    node.h
+    probes_helper.h
+    ruby_assert.h
+    ruby_atomic.h
+    thread_pthread.h
+    vm_core.h
+    vm_debug.h
+    vm_exec.h
+    vm_opts.h
+  ]).map { |f| "ext/llrb/cruby/#{f}" }
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end + cruby
+
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+  spec.extensions    = ['ext/llrb/extconf.rb']
+
+  spec.add_development_dependency 'benchmark-ips'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rake-compiler'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end