ytljit 0.0.1

data/ext/ytljit.h

@@ -0,0 +1,285 @@
+#define MAX_DL_HANDLES 10
+#define INIT_CODE_SPACE_SIZE 64
+#define VALUE_SPACE_SIZE (8 * 1024)
+
+#define OPEN_CHECK(COND)                                        \
+do {                                                            \
+      if ((COND) == NULL) {	                                \
+	printf("Open failed %d handle", used_dl_handles);	\
+      }                                                         \
+ } while(0)
+
+struct CodeSpace {
+  size_t  size;
+  size_t  used;
+  char body[1];
+};
+
+VALUE ytl_address_of(VALUE, VALUE);
+VALUE ytl_code_space_allocate(VALUE);
+
+void init_csarena();
+void *csalloc(int);
+void csfree(void *);
+
+extern VALUE ytl_mYTLJit;
+extern VALUE ytl_cCodeSpace;
+extern VALUE ytl_cValueSpace;
+extern VALUE ytl_cStepHandler;
+extern VALUE ytl_eStepHandler;
+
+/* Copy from node.h */
+typedef struct RNode {
+    unsigned long flags;
+    char *nd_file;
+    union {
+	struct RNode *node;
+	ID id;
+	VALUE value;
+	VALUE (*cfunc)(ANYARGS);
+	ID *tbl;
+    } u1;
+    union {
+	struct RNode *node;
+	ID id;
+	long argc;
+	VALUE value;
+    } u2;
+    union {
+	struct RNode *node;
+	ID id;
+	long state;
+	struct rb_global_entry *entry;
+	long cnt;
+	VALUE value;
+    } u3;
+} NODE;
+
+
+/* Copy from vm_core.h */
+
+struct rb_iseq_struct {
+    /***************/
+    /* static data */
+    /***************/
+
+    VALUE type;          /* instruction sequence type */
+    VALUE name;	         /* String: iseq name */
+    VALUE filename;      /* file information where this sequence from */
+    VALUE filepath;      /* real file path or nil */
+    VALUE *iseq;         /* iseq (insn number and openrads) */
+    VALUE *iseq_encoded; /* encoded iseq */
+    unsigned long iseq_size;
+    VALUE mark_ary;	/* Array: includes operands which should be GC marked */
+    VALUE coverage;     /* coverage array */
+    unsigned short line_no;
+
+    /* insn info, must be freed */
+    struct iseq_insn_info_entry *insn_info_table;
+    size_t insn_info_size;
+
+    ID *local_table;		/* must free */
+    int local_table_size;
+
+    /* method, class frame: sizeof(vars) + 1, block frame: sizeof(vars) */
+    int local_size;
+
+    struct iseq_inline_cache_entry *ic_entries;
+    int ic_size;
+
+    /**
+     * argument information
+     *
+     *  def m(a1, a2, ..., aM,                    # mandatory
+     *        b1=(...), b2=(...), ..., bN=(...),  # optinal
+     *        *c,                                 # rest
+     *        d1, d2, ..., dO,                    # post
+     *        &e)                                 # block
+     * =>
+     *
+     *  argc           = M
+     *  arg_rest       = M+N+1 // or -1 if no rest arg
+     *  arg_opts       = N
+     *  arg_opts_tbl   = [ (N entries) ]
+     *  arg_post_len   = O // 0 if no post arguments
+     *  arg_post_start = M+N+2
+     *  arg_block      = M+N + 1 + O + 1 // -1 if no block arg
+     *  arg_simple     = 0 if not simple arguments.
+     *                 = 1 if no opt, rest, post, block.
+     *                 = 2 if ambiguos block parameter ({|a|}).
+     *  arg_size       = argument size.
+     */
+
+    int argc;
+    int arg_simple;
+    int arg_rest;
+    int arg_block;
+    int arg_opts;
+    int arg_post_len;
+    int arg_post_start;
+    int arg_size;
+    VALUE *arg_opt_table;
+
+    size_t stack_max; /* for stack overflow check */
+
+    /* catch table */
+    struct iseq_catch_table_entry *catch_table;
+    int catch_table_size;
+
+    /* for child iseq */
+    struct rb_iseq_struct *parent_iseq;
+    struct rb_iseq_struct *local_iseq;
+
+    /****************/
+    /* dynamic data */
+    /****************/
+
+    VALUE self;
+    VALUE orig;			/* non-NULL if its data have origin */
+
+    /* block inlining */
+    /*
+     * NODE *node;
+     * void *special_block_builder;
+     * void *cached_special_block_builder;
+     * VALUE cached_special_block;
+     */
+
+    /* klass/module nest information stack (cref) */
+    NODE *cref_stack;
+    VALUE klass;
+
+    /* misc */
+    ID defined_method_id;	/* for define_method */
+
+    /* used at compile time */
+    struct iseq_compile_data *compile_data;
+};
+
+/* Copy from method.h */
+typedef enum {
+    NOEX_PUBLIC    = 0x00,
+    NOEX_NOSUPER   = 0x01,
+    NOEX_PRIVATE   = 0x02,
+    NOEX_PROTECTED = 0x04,
+    NOEX_MASK      = 0x06,
+    NOEX_BASIC     = 0x08,
+    NOEX_UNDEF     = NOEX_NOSUPER,
+    NOEX_MODFUNC   = 0x12,
+    NOEX_SUPER     = 0x20,
+    NOEX_VCALL     = 0x40,
+    NOEX_RESPONDS  = 0x80
+} rb_method_flag_t;
+
+#define NOEX_SAFE(n) ((int)((n) >> 8) & 0x0F)
+#define NOEX_WITH(n, s) ((s << 8) | (n) | (ruby_running ? 0 : NOEX_BASIC))
+#define NOEX_WITH_SAFE(n) NOEX_WITH(n, rb_safe_level())
+
+/* method data type */
+
+typedef enum {
+    VM_METHOD_TYPE_ISEQ,
+    VM_METHOD_TYPE_CFUNC,
+    VM_METHOD_TYPE_ATTRSET,
+    VM_METHOD_TYPE_IVAR,
+    VM_METHOD_TYPE_BMETHOD,
+    VM_METHOD_TYPE_ZSUPER,
+    VM_METHOD_TYPE_UNDEF,
+    VM_METHOD_TYPE_NOTIMPLEMENTED,
+    VM_METHOD_TYPE_OPTIMIZED, /* Kernel#send, Proc#call, etc */
+    VM_METHOD_TYPE_MISSING   /* wrapper for method_missing(id) */
+} rb_method_type_t;
+
+typedef struct rb_method_cfunc_struct {
+    VALUE (*func)(ANYARGS);
+    int argc;
+} rb_method_cfunc_t;
+
+typedef struct rb_method_attr_struct {
+    ID id;
+    VALUE location;
+} rb_method_attr_t;
+
+typedef struct rb_iseq_struct rb_iseq_t;
+
+typedef struct rb_method_definition_struct {
+    rb_method_type_t type; /* method type */
+    ID original_id;
+    union {
+	rb_iseq_t *iseq;            /* should be mark */
+	rb_method_cfunc_t cfunc;
+	rb_method_attr_t attr;
+	VALUE proc;                 /* should be mark */
+	enum method_optimized_type {
+	    OPTIMIZED_METHOD_TYPE_SEND,
+	    OPTIMIZED_METHOD_TYPE_CALL
+	} optimize_type;
+    } body;
+    int alias_count;
+} rb_method_definition_t;
+
+typedef struct rb_method_entry_struct {
+    rb_method_flag_t flag;
+    char mark;
+    rb_method_definition_t *def;
+    ID called_id;
+    VALUE klass;                    /* should be mark */
+} rb_method_entry_t;
+
+struct unlinked_method_entry_list_entry {
+    struct unlinked_method_entry_list_entry *next;
+    rb_method_entry_t *me;
+};
+
+#define UNDEFINED_METHOD_ENTRY_P(me) (!(me) || !(me)->def || (me)->def->type == VM_METHOD_TYPE_UNDEF)
+
+rb_method_entry_t *rb_method_entry(VALUE klass, ID id);
+
+/* Copy from vm_core.h */
+
+#define GetCoreDataFromValue(obj, type, ptr) do { \
+    ptr = (type*)DATA_PTR(obj); \
+} while (0)
+
+typedef struct rb_block_struct {
+    VALUE self;			/* share with method frame if it's only block */
+    VALUE *lfp;			/* share with method frame if it's only block */
+    VALUE *dfp;			/* share with method frame if it's only block */
+    rb_iseq_t *iseq;
+    VALUE proc;
+} rb_block_t;
+
+#define GetProcPtr(obj, ptr) \
+  GetCoreDataFromValue(obj, rb_proc_t, ptr)
+
+typedef struct {
+    rb_block_t block;
+
+    VALUE envval;		/* for GC mark */
+    VALUE blockprocval;
+    int safe_level;
+    int is_from_method;
+    int is_lambda;
+} rb_proc_t;
+
+#define GetEnvPtr(obj, ptr)			\
+  GetCoreDataFromValue(obj, rb_env_t, ptr)
+
+typedef struct {
+    VALUE *env;
+    int env_size;
+    int local_size;
+    VALUE prev_envval;		/* for GC mark */
+    rb_block_t block;
+} rb_env_t;
+
+#define GetBindingPtr(obj, ptr) \
+  GetCoreDataFromValue(obj, rb_binding_t, ptr)
+
+typedef struct {
+    VALUE env;
+    VALUE filename;
+    unsigned short line_no;
+} rb_binding_t;
+
+rb_iseq_t *rb_method_get_iseq(VALUE method);

data/lib/ytljit/asm.rb

@@ -0,0 +1,205 @@
+module YTLJit
+
+  class StepHandler
+    REG_NAME = ["EAX", "ECX", "EDX", "EBX", "EBP", "ESP", "EDI"]
+    def step_handler(*regs)
+      STDERR.print "#{regs[0].to_s(16)} "
+      STDERR.print CodeSpace.disasm_cache[regs[0].to_s(16)], "\n"
+      regs.each_with_index do |val, i|
+        STDERR.print REG_NAME[i]
+        STDERR.print ": 0x"
+        STDERR.print val.to_s(16)
+        STDERR.print " "
+      end
+      STDERR.print "\n"
+     end
+  end
+
+  class Generator
+    def initialize(asm)
+      @asm = asm
+    end
+    attr :asm
+  end
+
+  class OutputStream
+    def asm=(a)
+      @asm = a
+    end
+
+    def base_address
+      0
+    end
+
+    def var_base_address(offset = 0)
+      OpVarMemAddress.new(lambda {offset})
+    end
+  end
+
+  class FileOutputStream<OutputStream
+    def initialize(st)
+      @stream = st
+    end
+
+    def emit(code)
+      @stream.write(code)
+    end
+  end
+
+  class DummyOutputStream<OutputStream
+    def initialize(st)
+    end
+
+    def emit(code)
+    end
+  end
+
+  class Assembler
+    @@value_table_cache = {}
+    @@value_table_entity = ValueSpace.new
+
+    def self.set_value_table(out)
+      @@value_table_cache = {}
+      @@value_table_entity = out
+    end
+
+    def self.get_value_table(out)
+      [@@value_table_entity, @@value_table_cache]
+    end
+
+    def initialize(out, gen = GeneratorExtend)
+      @generator = gen.new(self)
+      @output_stream = out
+      @retry_mode = false
+      @step_mode = false
+      @asmsend_history = []
+
+      # Instruction pach table for forwarding reference
+      # This is array of proc object.
+      @after_patch_tab = []
+      reset
+    end
+
+    def reset
+      @current_address = @output_stream.base_address
+      @offset = 0
+    end
+
+    attr_accessor :current_address
+    attr_accessor :step_mode
+    attr          :offset
+    attr          :output_stream
+    attr          :after_patch_tab
+    attr          :retry_mode
+
+    def var_current_address
+      current_address = @current_address
+
+      func = lambda {
+        current_address
+      }
+      OpVarMemAddress.new(func)
+    end
+
+    attr_accessor :generated_code
+
+    def store_outcode(out)
+      update_state(out)
+      @offset += out.bytesize
+      @output_stream.emit(out)
+      out
+    end
+
+    def update_state(out)
+      @current_address += out.bytesize
+      out
+    end
+
+    def with_retry(&body)
+      org_base_address = @output_stream.base_address
+      yield
+
+      org_retry_mode = @retry_mode
+      @retry_mode = :change_org
+      while org_base_address != @output_stream.base_address do
+        org_base_address = @output_stream.base_address
+        reset
+        @output_stream.reset
+        @asmsend_history.each do |arg|
+          send(arg[0], *arg[1])
+        end
+        @output_stream.update_refer
+      end
+
+      @after_patch_tab.each do |patproc|
+        patproc.call
+      end
+      @retry_mode = org_retry_mode
+    end
+
+    def add_value_entry(val)
+      off= nil
+      unless off = @@value_table_cache[val] then
+        off = @@value_table_entity.current_pos
+        @@value_table_entity.emit([val.value].pack("Q"))
+        @@value_table_cache[val] = off
+      end
+
+      @@value_table_entity.var_base_address(off)
+    end
+
+    def add_var_value_retry_func(mn, args)
+      if args.any? {|e| e.is_a?(OpVarValueMixin) } and 
+         @retry_mode == false then
+        offset = @offset
+        stfunc = lambda {
+          with_current_address(@output_stream.base_address + offset) {
+            orgretry_mode = @retry_mode
+            @retry_mode = :change_op
+            out = @generator.send(mn, *args)
+            if out.is_a?(Array)
+              @output_stream[offset] = out[0]
+            else
+              @output_stream[offset] = out
+            end
+            @retry_mode = orgretry_mode
+          }
+        }
+        args.each do |e|
+          if e.is_a?(OpVarValueMixin) then
+            e.add_refer(stfunc)
+          end
+        end
+      end
+    end
+
+    def method_missing(mn, *args)
+      out = @generator.call_stephandler
+      store_outcode(out)
+
+      if @retry_mode == false then
+        case mn
+        when :call_with_arg
+          args.push(@generator.call_with_arg_get_argsize(*args))
+        end
+        @asmsend_history.push [mn, args]
+      end
+        
+      add_var_value_retry_func(mn, args)
+      out = @generator.send(mn, *args)
+      if out.is_a?(Array) then
+        store_outcode(out[0])
+      else
+        store_outcode(out)
+      end
+      out
+    end
+
+    def with_current_address(address)
+      org_curret_address = self.current_address
+      self.current_address = address
+      yield
+      self.current_address = org_curret_address
+    end
+  end
+end

data/lib/ytljit/asmext.rb

@@ -0,0 +1,199 @@
+#---------
+#  Extended Specication of Assembler Level Layer
+#
+module YTLJit
+  class TypedData
+    include AbsArch
+
+    def initialize(type, ent)
+      @type = type
+      @entity = ent
+    end
+
+    attr :type
+    attr :entity
+
+    def [](arg)
+      TypedData.new(@type[arg], @entity)
+    end
+
+    def gen_access(gen)
+      asm = gen.asm
+      base = @entity
+      case @type
+      when AsmType::Scalar, AsmType::Pointer, AsmType::Array
+        if base != TMPR then
+          code = ""
+          code += asm.update_state(gen.mov(TMPR, base))
+          [code, @type]
+        else
+          ["", @type]
+        end
+
+      when AsmType::StructMember
+        code = ""
+        if base != TMPR then
+          code += asm.update_state(gen.mov(TMPR, base))
+        end
+        oi = OpIndirect.new(TMPR, @type.offset)
+        if @type.type.is_a?(AsmType::Array) then
+          code += asm.update_state(gen.call_stephandler) if code != ""
+          code += asm.update_state(gen.lea(TMPR, oi))
+        else
+          code += asm.update_state(gen.call_stephandler)  if code != ""
+          code += asm.update_state(gen.mov(TMPR, oi))
+        end
+        [code, @type.type]
+
+      when AsmType::PointedData
+        # Now support only index == 0
+        code = ""
+        if base != TMPR then
+          code += asm.update_state(gen.mov(TMPR,  base))
+        end
+        if @type.offset != 0 then
+          oi = OpIndirect.new(TMPR, @type.offset)
+          code += asm.update_state(gen.call_stephandler)  if code != ""
+          code += asm.update_state(gen.lea(TMPR, oi))
+        end
+        ineax = OpIndirect.new(TMPR)
+        code += asm.update_state(gen.call_stephandler) if code != ""
+        code += asm.update_state(gen.mov(TMPR,  ineax))
+        [code, @type.type]
+      end
+    end
+  end
+
+  class FunctionArgument
+    def initialize(no, kind)
+      @no = no
+      @abi_kind = kind
+    end
+  end
+
+  class FunctionArgumentInt<FunctionArgument
+    case $ruby_platform
+    when /x86_64/
+      include FunctionArgumentX64MixinCommon
+      include FunctionArgumentX64MixinInt
+
+    when /i.86/
+      include FunctionArgumentX86Mixin
+    end
+  end
+
+  class FunctionArgumentFloat<FunctionArgument
+    case $ruby_platform
+    when /x86_64/
+      include FunctionArgumentX64MixinCommon
+      include FunctionArgumentX64MixinFloat
+
+    when /i.86/
+      include FunctionArgumentX86Mixin
+    end
+  end
+
+  class FuncArgInfo
+    def initialize
+      @maxargs = 0
+      @used_arg_tab = []
+      @area_allocate_pos = []
+    end
+
+    attr_accessor :used_arg_tab
+    attr          :maxargs
+    attr          :area_allocate_pos
+
+    def update_maxargs(args)
+      if @maxargs < args then
+        @maxargs = args
+      end
+    end
+  end
+
+  module GeneratorExtendMixin
+    include AbsArch
+
+    def initialize(asm, handler = "ytl_step_handler")
+      super
+      @funcarg_info = FuncArgInfo.new
+    end
+    attr :funcarg_info
+
+    def nosupported_addressing_mode(inst, dst, src, src2 = nil)
+      case inst
+      when :mov
+        case src
+        when TypedData
+          orgaddress = @asm.current_address
+          rcode = ""
+          rcode, rtype = src.gen_access(self)
+          if dst != TMPR then
+            rcode += @asm.update_state(call_stephandler) if rcode != ""
+            rcode += @asm.update_state(mov(dst, TMPR))
+          end
+          @asm.current_address = orgaddress
+          return [rcode, TypedData.new(rtype, dst)]
+        end
+
+      when :seta, :setae, :setb, :setbe, :setl, :setle, :setg, :setge,
+           :setna, :setnae, :setnb, :setnbe, :setnc, :setnle,
+           :setno, :seto, :setz, :setnz
+        case dst
+        when OpReg32, OpReg64
+          rcode = ""
+          reg8 = [AL, CL, DL, BL][dst.reg_no]
+          rcode += send(inst, reg8)
+          rcode += self.and(dst, 1)
+          return rcode
+        end
+      end
+
+      case src
+      when FunctionArgument
+        orgaddress = @asm.current_address
+        rcode = ""
+        rcode = src.gen_access_src(self, inst, dst, src, src2)
+        rcode  += @asm.update_state(call_stephandler)
+        @asm.current_address = orgaddress
+        return rcode
+
+      when OpRegXMM
+        case inst
+        when :mov
+          return movsd(dst, src)
+        end
+      end
+
+      case dst
+      when FunctionArgument
+        orgaddress = @asm.current_address
+        rcode = ""
+        rcode = dst.gen_access_dst(self, inst, dst, src, src2)
+        rcode  += @asm.update_state(call_stephandler)
+        @asm.current_address = orgaddress
+        return rcode
+
+      when OpRegXMM
+        case inst
+        when :mov
+          return movsd(dst, src)
+        end
+      end
+
+      super
+    end
+  end
+
+  class GeneratorExtend<GeneratorIABinary
+    include GeneratorExtendMixin
+
+    case $ruby_platform
+    when /x86_64/
+      include GeneratorExtendX64Mixin
+
+    when /i.86/
+      include GeneratorExtendX86Mixin
+    end
+  end
+end