ytljit 0.0.3 → 0.0.4

data/ext/code_alloc.c

@@ -229,7 +229,13 @@ csfree(void *chunk)
     rb_raise(rb_eArgError, "Maybe free illgal chunk");
   }
   bitpos = offset / alocsize;
+
+#if 0
   arena->bitmap[bitpos / 64] ^= (1 << (bitpos & (64 - 1)));
+  if (arena->bitmap[bitpos / 64] & (1 << (bitpos & (64 - 1))) == 0) {
+    rb_raise(rb_eArgError, "Maybe freeed chunk passed");
+  }
+#endif
 
   /* Update arena_search_tab */
   for (tmpa = arena_tab[logsize], sarena = arena_search_tab[logsize];

data/ext/memory.c

@@ -0,0 +1,82 @@
+#include <unistd.h>
+#include <stdlib.h>
+#include "ruby.h"
+
+#include "ytljit.h"
+
+VALUE ytl_mRuntime;
+VALUE ytl_cArena;
+
+VALUE
+ytl_arena_allocate(VALUE klass)
+{
+  struct Arena *arena;
+
+  arena = malloc(ARENA_SIZE);
+  arena->size = ARENA_SIZE - sizeof(struct Arena);
+
+  return Data_Wrap_Struct(klass, NULL, free, (void *)arena);
+}
+
+VALUE
+ytl_arena_ref(VALUE self, VALUE offset)
+{
+  struct Arena *raw_arena;
+  int raw_offset;
+
+  raw_arena = (struct Arena *)DATA_PTR(self);
+  raw_offset = FIX2INT(offset);
+
+  return INT2FIX(raw_arena->body[raw_offset]);
+}
+
+VALUE
+ytl_arena_emit(VALUE self, VALUE offset, VALUE src)
+{
+  struct Arena *raw_arena;
+
+  int raw_offset;
+
+  raw_arena = (struct Arena *)DATA_PTR(self);
+  raw_offset = FIX2INT(offset);
+
+  raw_arena->body[raw_offset] = FIX2INT(src);
+
+  return src;
+}
+
+VALUE
+ytl_arena_size(VALUE self)
+{
+  struct Arena *raw_arena;
+
+  int raw_offset;
+
+  raw_arena = (struct Arena *)DATA_PTR(self);
+
+  return INT2FIX(raw_arena->size);
+}
+
+VALUE
+ytl_arena_address(VALUE self)
+{
+  struct Arena *raw_arena;
+
+  raw_arena = (struct Arena *)DATA_PTR(self);
+
+  return INT2FIX(raw_arena->body);
+}
+
+
+VALUE
+ytl_arena_to_s(VALUE self)
+{
+  struct Arena *raw_arena;
+
+  raw_arena = (struct Arena *)DATA_PTR(self);
+
+  return rb_sprintf("#<Arena %p size=%d body=%p>", 
+		    (void *)self, 
+		    raw_arena->size,
+		    (void *)raw_arena->body);
+}

data/ext/ytljit.c

@@ -511,6 +511,15 @@ Init_ytljit_ext()
   rb_define_alloc_func(ytl_cValueSpace, ytl_value_space_allocate);
   rb_define_method(ytl_cValueSpace, "to_s", ytl_value_space_to_s, 0);
   
+  ytl_mRuntime = rb_define_module_under(ytl_mYTLJit, "Runtime");
+  ytl_cArena = rb_define_class_under(ytl_mRuntime, "Arena", rb_cObject);
+  rb_define_alloc_func(ytl_cArena, ytl_arena_allocate);
+  rb_define_method(ytl_cArena, "[]=", ytl_arena_emit, 2);
+  rb_define_method(ytl_cArena, "[]", ytl_arena_ref, 1);
+  rb_define_method(ytl_cArena, "size", ytl_arena_size, 0);
+  rb_define_method(ytl_cArena, "address", ytl_arena_address, 0);
+  rb_define_method(ytl_cArena, "to_s", ytl_arena_to_s, 0);
+
   /* Open Handles */
 #ifdef __CYGWIN__
   OPEN_CHECK(dl_handles[used_dl_handles] = dlopen("cygwin1.dll", RTLD_LAZY));

data/ext/ytljit.h

@@ -2,6 +2,8 @@
 #define INIT_CODE_SPACE_SIZE 64
 #define VALUE_SPACE_SIZE (8 * 1024)
 
+#define ARENA_SIZE 256 * 1024 /* 256 Kbytes */
+
 #define OPEN_CHECK(COND)                                        \
 do {                                                            \
       if ((COND) == NULL) {	                                \
@@ -15,8 +17,21 @@ struct CodeSpace {
   char body[1];
 };
 
+struct Arena {
+  size_t size;
+  VALUE body[1];
+};
+
 VALUE ytl_address_of(VALUE, VALUE);
 VALUE ytl_code_space_allocate(VALUE);
+VALUE ytl_code_value_allocate(VALUE);
+
+VALUE ytl_arena_allocate(VALUE);
+VALUE ytl_arena_emit(VALUE, VALUE, VALUE);
+VALUE ytl_arena_ref(VALUE, VALUE);
+VALUE ytl_arena_size(VALUE);
+VALUE ytl_arena_address(VALUE);
+VALUE ytl_arena_to_s(VALUE);
 
 void init_csarena();
 void *csalloc(int);
@@ -28,6 +43,9 @@ extern VALUE ytl_cValueSpace;
 extern VALUE ytl_cStepHandler;
 extern VALUE ytl_eStepHandler;
 
+extern VALUE ytl_mRuntime;
+extern VALUE ytl_cArena;
+
 /* Copy from node.h */
 typedef struct RNode {
     unsigned long flags;

data/lib/runtime/gc.rb

@@ -0,0 +1,41 @@
+module YTLJit
+  module Runtime
+    class GCBase
+      def gc(heap)
+        raise "#{heap} is overflow"
+      end
+      
+      def malloc(type)
+      end
+    end
+    
+    class GCCopy<GCBase
+      def initialize
+        @arena = []
+        @arena[0] = Arena.new
+        @arena[1] = Arena.new
+        @from_arena = 0
+      end
+      
+      def gc
+      end
+      
+      def malloc(type)
+        siz = type.size
+        siz += YTLObject.size
+        fromare = @arena[@from_arena]
+        if fromare.size < fromare.using + siz then
+          gc
+        end
+        
+        res = TypedDataArena.new(YTLObject, fromare, fromare.using)
+        fromare.using += siz
+
+        # Initialize object header
+        yield res
+        
+        res.cast(type)
+      end
+    end
+  end
+end

data/lib/runtime/object.rb

@@ -0,0 +1,18 @@
+module YTLJit
+  module Runtime
+    include InternalRubyType
+    # Format of header
+    #
+    #     size of object
+    #   xxxxxxxxxxxxxxxxxxxFEUTFRM
+    #
+    ADDRESS = AsmType::MACHINE_WORD
+    YTLObject = AsmType::Struct.new(
+                  VALUE, :header, 
+                  ADDRESS, :traverse_func,
+                  AsmType::Array.new(VALUE, 0), :body
+                )
+  end
+end
+
+    

data/lib/ytljit.rb

@@ -44,3 +44,12 @@ require 'ytljit/vm_type_gen'
 require 'ytljit/vm_type'
 
 require 'ytljit/vm_typeinf'
+require 'ytljit/vm_cruby_obj'
+
+require 'ytljit/arena'
+
+
+# Runtime
+
+require 'runtime/object.rb'
+require 'runtime/gc.rb'

data/lib/ytljit/arena.rb

@@ -0,0 +1,63 @@
+module YTLJit
+  module Runtime
+    class Arena
+      def initialize
+        @using = 0
+      end
+
+      attr_accessor :using
+    end
+
+    class TypedDataArena
+      def initialize(type, arena, origin)
+        @type = type
+        @arena = arena
+        @origin = origin
+      end
+
+      def [](*arg)
+        TypedDataArena.new(@type[*arg], @arena, @origin)
+      end
+
+      def cast(otype)
+        TypedDataArena.new(otype, @arena, @origin)
+      end
+
+      def address
+        case @type
+        when AsmType::Scalar, 
+             AsmType::Pointer, 
+             AsmType::Array, 
+             AsmType::Struct
+          @arena.address + @origin
+          
+        when AsmType::StructMember, AsmType::PointedData
+          @arena.address + @origin + @type.offset
+
+        end
+      end
+
+      def ref
+        case @type
+        when AsmType::Scalar, AsmType::Pointer, AsmType::Array
+          @arena[@origin]
+          
+        when AsmType::StructMember, AsmType::PointedData
+          @arena[@origin + @type.offset / AsmType::MACHINE_WORD.size]
+
+        end
+      end
+
+      def ref=(val)
+        case @type
+        when AsmType::Scalar, AsmType::Pointer, AsmType::Array
+          @arena[@origin] = val
+          
+        when AsmType::StructMember, AsmType::PointedData
+          @arena[@origin + @type.offset / AsmType::MACHINE_WORD.size] = val
+
+        end
+      end
+    end
+  end
+end

data/lib/ytljit/asm.rb

@@ -77,12 +77,15 @@ module YTLJit
       # Instruction pach table for forwarding reference
       # This is array of proc object.
       @after_patch_tab = []
+      @patched_num = 0
+
       reset
     end
 
     def reset
       @current_address = @output_stream.base_address
       @offset = 0
+      @patched_num = 0
     end
 
     attr_accessor :current_address
@@ -131,9 +134,10 @@ module YTLJit
         @output_stream.update_refer
       end
 
-      @after_patch_tab.each do |patproc|
+      @after_patch_tab[@patched_num..-1].each do |patproc|
         patproc.call
       end
+      @patched_num = @after_patch_tab.size
       @retry_mode = org_retry_mode
     end
 

data/lib/ytljit/asmext.rb

@@ -22,26 +22,48 @@ module YTLJit
       base = @entity
       case @type
       when AsmType::Scalar, AsmType::Pointer, AsmType::Array
-        if base != TMPR then
+        if @type == AsmType::DOUBLE then
           code = ""
-          code += asm.update_state(gen.mov(TMPR, base))
+          code += asm.update_state(gen.movsd(XMM0, base))
           [code, @type]
         else
-          ["", @type]
+          if base != TMPR then
+            code = ""
+            code += asm.update_state(gen.mov(TMPR, base))
+            [code, @type]
+          else
+            ["", @type]
+          end
         end
 
       when AsmType::StructMember
         code = ""
-        if base != TMPR then
+
+        oi = nil
+        if base.is_a?(OpRegXMM) then
+          oi = base
+          
+        elsif base != TMPR then
+          code += asm.update_state(gen.call_stephandler)  if code != ""
           code += asm.update_state(gen.mov(TMPR, base))
+          oi = OpIndirect.new(TMPR, @type.offset)
+
+        else
+          oi = OpIndirect.new(TMPR, @type.offset)
         end
-        oi = OpIndirect.new(TMPR, @type.offset)
-        if @type.type.is_a?(AsmType::Array) then
+
+        if @type.type == AsmType::DOUBLE then
+          code += asm.update_state(gen.call_stephandler)  if code != ""
+          code += asm.update_state(gen.movsd(XMM0, oi))
+
+        elsif @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]
 
@@ -136,6 +158,20 @@ module YTLJit
           return [rcode, TypedData.new(rtype, dst)]
         end
 
+      when :movsd
+        case src
+        when TypedData
+          orgaddress = @asm.current_address
+          rcode = ""
+          rcode, rtype = src.gen_access(self)
+          if dst != XMM0 then
+            rcode += @asm.update_state(call_stephandler) if rcode != ""
+            rcode += @asm.update_state(movsd(dst, XMM0))
+          end
+          @asm.current_address = orgaddress
+          return [rcode, TypedData.new(rtype, dst)]
+        end
+
       when :push
         case dst
         when OpRegXMM

data/lib/ytljit/asmutil.rb

@@ -113,6 +113,7 @@ module YTLJit
     end
     INDIRECT_TMPR = OpIndirect.new(TMPR)
     INDIRECT_TMPR2 = OpIndirect.new(TMPR2)
+    INDIRECT_TMPR3 = OpIndirect.new(TMPR3)
     INDIRECT_RETR = OpIndirect.new(RETR)
     INDIRECT_SPR = OpIndirect.new(SPR)
     INDIRECT_BPR = OpIndirect.new(BPR)
@@ -133,6 +134,8 @@ module YTLJit
   module InternalRubyType
     include AbsArch
     VALUE = AsmType::MACHINE_WORD
+    P_VOID = AsmType::Pointer.new(VALUE)
+    P_VALUE = AsmType::Pointer.new(VALUE)
     P_CHAR = AsmType::Pointer.new(AsmType::INT8)
 
     RBasic = AsmType::Struct.new(
@@ -162,6 +165,29 @@ module YTLJit
                AsmType::DOUBLE, :float_value
               )
 
+    Arena = AsmType::Struct.new(
+              AsmType::MACHINE_WORD, :size,
+              AsmType::Array.new(AsmType::INT8, 0), :body
+            )
+
+    RData = AsmType::Struct.new(
+              RBasic, :basic,
+              P_VOID, :dmark,
+              P_VOID, :dfree,
+              AsmType::Pointer.new(Arena), :data)
+
+    RObject = AsmType::Struct.new(
+                RBasic, :basic,
+                AsmType::Union.new(
+                  AsmType::Struct.new(
+                    AsmType::INT32, :numiv,
+                    P_VALUE, :ivptr,
+                    P_VOID, :iv_index_tbl
+                  ), :heap,
+                  AsmType::Array.new(VALUE, 3), :ary
+                ), :as
+              )
+
     EMBEDER_FLAG = (1 << 13)
     def self.rstring_ptr(str, csstart, cscont)
       cs_embed = CodeSpace.new