ytljit 0.0.6 → 0.0.7

data/ext/code_alloc.c

@@ -4,6 +4,7 @@
 #include <sys/mman.h>
 #include <stdlib.h>
 #include "ruby.h"
+#include "ytljit.h"
 
 
 /* CodeSpaceArena is memory area for allocate codespace
@@ -34,11 +35,10 @@ typedef struct {
   uint64_t bitmap[1];
 }  CodeSpaceArena;
 
-#define ARENA_SIZE 16 * 1024
 
 /* 2 * 64 means header and gatekeeper */
 #define BITMAP_SIZE(ALOCSIZ) \
-  (((ARENA_SIZE) * 8 - 2 * 64) / ((ALOCSIZ) * 8 + 1))
+  (((CODE_SPACE_SIZE) * 8 - 2 * 64) / ((ALOCSIZ) * 8 + 1))
 
 /* Last "+ 1" means gatekeeper */
 #define HEADER_SIZE(ALOCSIZ) \
@@ -64,31 +64,40 @@ static CodeSpaceArena *arena_search_tab[ALOCSIZLOG_MAX];
 
 static size_t page_size;
 
-CodeSpaceArena *
-alloc_arena(size_t aloclogsiz, CodeSpaceArena *prev_csa)
+static CodeSpaceArena *
+raw_alloc_arena(size_t size)
 {
-  uint64_t rbitmap;
   CodeSpaceArena *arena;
   void *newmem;
-  int allocsiz;
-  int bitmap_size;
-  int allff_size;
-  int rest_size;
-  
+
 #if !defined(__CYGWIN__)
-  if (posix_memalign(&newmem, ARENA_SIZE, ARENA_SIZE)) {
+  if (posix_memalign(&newmem, CODE_SPACE_SIZE, size)) {
     rb_raise(rb_eNoMemError, "Can't allocate code space area");
   }
-  if(mprotect(newmem, ARENA_SIZE, PROT_READ | PROT_WRITE | PROT_EXEC)) {
+  if(mprotect(newmem, CODE_SPACE_SIZE, PROT_READ | PROT_WRITE | PROT_EXEC)) {
     rb_raise(rb_eNoMemError, "mprotect failed");
   }
   arena = (CodeSpaceArena *)newmem;
 #else
-  if (!(arena = memalign(ARENA_SIZE, ARENA_SIZE))) {
+  if (!(arena = memalign(CODE_SPACE_SIZE, size))) {
     rb_raise(rb_eNoMemError, "Can't allocate code space area");
   }
 #endif
+
+  return arena;
+}
+
+static CodeSpaceArena *
+alloc_arena(size_t aloclogsiz, CodeSpaceArena *prev_csa)
+{
+  uint64_t rbitmap;
+  CodeSpaceArena *arena;
+  int allocsiz;
+  int bitmap_size;
+  int allff_size;
+  int rest_size;
   
+  arena = raw_alloc_arena(CODE_SPACE_SIZE);
   arena->next_and_size = ((uintptr_t)prev_csa) | aloclogsiz;
 
   /* fill bitmap: 1 means free */
@@ -202,8 +211,15 @@ csalloc(int size)
   void *res;
   
   logsize = bytes_to_bucket(size);
-  res = search_free_chunk(arena_search_tab[logsize]);
-  //  fprintf(stderr, "%x \n", res);
+  if (logsize < 10) {
+    /* Small code space (less than 8192 bytes) */
+    res = search_free_chunk(arena_search_tab[logsize]);
+  }
+  else {
+    res = raw_alloc_arena(16 << logsize);
+    ((struct CodeSpace *)res)->next_and_size = 0xf;
+  }
+
   return res;
 }
 
@@ -219,8 +235,14 @@ csfree(void *chunk)
   int logsize;
   int alocsize;
 
-  arena = (CodeSpaceArena *)(((uintptr_t)chunk) & (~(ARENA_SIZE - 1)));
+  arena = (CodeSpaceArena *)(((uintptr_t)chunk) & (~(CODE_SPACE_SIZE - 1)));
   logsize = arena->next_and_size & 0xf;
+  if (logsize == 0xf) {
+    /* Large area */
+    free(arena);
+    return;
+  }
+
   alocsize = 16 << logsize;
 
   alocoff = csarena_allocarea_tab[logsize];
@@ -262,7 +284,7 @@ init_csarena()
 #endif
 
   /* Check page_size is valid */
-  if ((ARENA_SIZE / page_size) * page_size != ARENA_SIZE) {
+  if ((CODE_SPACE_SIZE / page_size) * page_size != CODE_SPACE_SIZE) {
     rb_raise(rb_eNoMemError, "Not support this architecture");
   }
 

data/ext/memory.c

@@ -7,40 +7,173 @@
 VALUE ytl_mRuntime;
 VALUE ytl_cArena;
 
+void
+ytl_arena_mark(struct ArenaHeader *arenah)
+{
+  VALUE *base;
+  VALUE *start;
+  struct ArenaBody *bodyptr;
+  struct ArenaBody *next_bodyptr;
+  struct ArenaBody *lastbodyptr;
+  VALUE *bodyeleptr;
+  int appear;
+
+  lastbodyptr = (struct ArenaBody *)(((uintptr_t)arenah->lastptr) & (~(ARENA_SIZE - 1)));
+  appear = 0;
+
+  for (bodyptr = arenah->body; bodyptr; bodyptr = next_bodyptr) {
+    if (bodyptr == lastbodyptr) {
+      start = arenah->lastptr;
+      appear = 1;
+    } 
+    else if (appear)  {
+      start = bodyptr->body;
+    }
+    else {
+      next_bodyptr = bodyptr->next;
+      arenah->body = next_bodyptr;
+      free(bodyptr);
+      continue;
+    }
+
+    base = bodyptr->body + (bodyptr->size / sizeof(VALUE));
+    for (bodyeleptr = start; bodyeleptr < base; bodyeleptr++) {
+      rb_gc_mark_maybe(*bodyeleptr);
+    }
+    next_bodyptr = bodyptr->next;
+  }
+}
+
+void
+ytl_arena_free(struct ArenaHeader *arenah)
+{
+  VALUE *base;
+  VALUE *start;
+  struct ArenaBody *curptr;
+  struct ArenaBody *curptr_next;
+  
+  for (curptr = arenah->body; curptr; curptr = curptr_next) {
+    curptr_next = curptr->next;
+    free(curptr);
+  }
+  
+  free(arenah);
+}
+
+#define DO_RETRY                                               \
+do {                                                           \
+  if (retry_mode) {                                            \
+    rb_raise(rb_eNoMemError, "Can't allocate arena area");     \
+  }                                                            \
+  else {                                                       \
+    retry_mode = 1;                                            \
+    rb_gc();                                                   \
+    goto retry;                                                \
+  }                                                            \
+} while(0)
+
+
+struct ArenaBody *
+ytl_arena_allocate_body()
+{
+  void *newmem;
+  struct ArenaBody *abody;
+  int retry_mode = 0;
+
+ retry:
+
+#if !defined(__CYGWIN__)
+  if (posix_memalign(&newmem, ARENA_SIZE, ARENA_SIZE)) {
+    DO_RETRY;
+  }
+  abody = (struct ArenaBody *)newmem;
+#else
+  if (!(abody = memalign(ARENA_SIZE, ARENA_SIZE))) {
+    DO_RETRY;
+  }
+#endif
+
+  abody->size = ARENA_SIZE - sizeof(struct ArenaBody);
+  abody->next = 0;
+  return abody;
+}
+
 VALUE
 ytl_arena_allocate(VALUE klass)
 {
-  struct Arena *arena;
+  struct ArenaHeader *arenah;
+  struct ArenaBody *arenab;
 
-  arena = malloc(ARENA_SIZE);
-  arena->size = ARENA_SIZE - sizeof(struct Arena);
+  arenah = malloc(sizeof(struct ArenaHeader));
+  arenah->body = ytl_arena_allocate_body();
+  arenab = arenah->body;
+  arenab->header = arenah;
+  arenah->lastptr = arenab->body + (arenab->size / sizeof(VALUE));
 
-  return Data_Wrap_Struct(klass, NULL, free, (void *)arena);
+  return Data_Wrap_Struct(klass, ytl_arena_mark, ytl_arena_free, 
+			  (void *)arenah);
+}
+
+char *
+ytl_arena_alloca(char *stptr, int size)
+{
+  uintptr_t lsp;
+  struct ArenaHeader *arenah;
+  struct ArenaBody *oldbody;
+  struct ArenaBody *bodyptr;
+  struct ArenaBody *next_bodyptr;
+
+  lsp = (uintptr_t)stptr;
+  oldbody = (struct ArenaBody *)(lsp & (~(ARENA_SIZE -1)));
+  arenah  = oldbody->header;
+  size = size * 8;
+
+  for (bodyptr = arenah->body; bodyptr != oldbody; bodyptr = next_bodyptr) {
+    next_bodyptr = bodyptr->next;
+    arenah->body = next_bodyptr;
+    free(bodyptr);
+  }
+
+  if ((lsp & (ARENA_SIZE - 1)) < ((lsp - size - 64) & (ARENA_SIZE - 1))) {
+    struct ArenaBody *arenab;
+
+    arenah->lastptr = (void *)stptr;
+    arenab = arenah->body = ytl_arena_allocate_body();
+    if (arenab != oldbody) {
+      arenab->next = oldbody;
+    }
+    arenab->header = arenah;
+    arenah->lastptr = arenab->body + (arenab->size / sizeof(VALUE));
+    stptr = (char *)arenah->lastptr;
+  }
+  stptr -= size;
+
+  return stptr;
 }
 
 VALUE
 ytl_arena_ref(VALUE self, VALUE offset)
 {
-  struct Arena *raw_arena;
+  struct ArenaHeader *arenah;
   int raw_offset;
 
-  raw_arena = (struct Arena *)DATA_PTR(self);
+  Data_Get_Struct(self, struct ArenaHeader, arenah);
   raw_offset = FIX2INT(offset);
 
-  return ULONG2NUM(raw_arena->body[raw_offset]);
+  return ULONG2NUM(arenah->body->body[raw_offset]);
 }
 
 VALUE
 ytl_arena_emit(VALUE self, VALUE offset, VALUE src)
 {
-  struct Arena *raw_arena;
+  struct ArenaHeader *arenah;
 
   int raw_offset;
 
-  raw_arena = (struct Arena *)DATA_PTR(self);
+  Data_Get_Struct(self, struct ArenaHeader, arenah);
   raw_offset = NUM2ULONG(offset);
 
-  raw_arena->body[raw_offset] = FIX2INT(src);
+  arenah->body->body[raw_offset] = FIX2INT(src);
 
   return src;
 }
@@ -48,35 +181,50 @@ ytl_arena_emit(VALUE self, VALUE offset, VALUE src)
 VALUE
 ytl_arena_size(VALUE self)
 {
-  struct Arena *raw_arena;
+  struct ArenaHeader *arenah;
+  struct ArenaBody *arenab;
 
-  int raw_offset;
+  int totsize;
 
-  raw_arena = (struct Arena *)DATA_PTR(self);
+  Data_Get_Struct(self, struct ArenaHeader, arenah);
+  totsize = 0;
+  for (arenab = arenah->body; arenab; arenab = arenab->next) {
+    totsize += arenab->size;
+  }
 
-  return INT2FIX(raw_arena->size);
+  return INT2FIX(totsize);
 }
 
 VALUE
 ytl_arena_address(VALUE self)
 {
-  struct Arena *raw_arena;
+  struct ArenaHeader *arenah;
 
-  raw_arena = (struct Arena *)DATA_PTR(self);
+  Data_Get_Struct(self, struct ArenaHeader, arenah);
 
-  return ULONG2NUM((uintptr_t)raw_arena->body);
+  return ULONG2NUM((uintptr_t)arenah->body->body);
 }
 
+VALUE
+ytl_arena_raw_address(VALUE self)
+{
+  struct ArenaHeader *arenah;
+
+  Data_Get_Struct(self, struct ArenaHeader, arenah);
+
+  return ULONG2NUM((uintptr_t)arenah);
+}
 
 VALUE
 ytl_arena_to_s(VALUE self)
 {
-  struct Arena *raw_arena;
+  struct ArenaHeader *arenah;
 
-  raw_arena = (struct Arena *)DATA_PTR(self);
+  Data_Get_Struct(self, struct ArenaHeader, arenah);
 
-  return rb_sprintf("#<Arena %p size=%d body=%p>", 
+  return rb_sprintf("#<Arena %p size=%d body=%p last=%p>", 
 		    (void *)self, 
-		    raw_arena->size,
-		    (void *)raw_arena->body);
+		    ytl_arena_size(self) / 2,
+		    (void *)arenah->body->body,
+		    (void *)arenah->lastptr);
 }

data/ext/ytljit.c

@@ -262,7 +262,7 @@ ytl_code_space_emit(VALUE self, VALUE offset, VALUE src)
     void *new_cs = csalloc(newsize);
 
     //*(struct CodeSpace *)new_cs = *(struct CodeSpace *)raw_cs;
-    memcpy(new_cs, raw_cs, newsize / 2);
+    //memcpy(new_cs, raw_cs, newsize / 2);
     csfree(raw_cs);
     raw_cs = new_cs;
     raw_cs->size = newsize - sizeof(struct CodeSpace);
@@ -524,6 +524,60 @@ ytl_step_handler()
 #endif
 }
 
+VALUE 
+ytl_ivar_get_boxing(VALUE slf, int off)
+{
+  VALUE *ivptr;
+  VALUE rval;
+
+  ivptr = ROBJECT_IVPTR(slf);
+  rval = ivptr[off];
+  if (rval != Qundef) {
+    return rval;
+  }
+  else {
+    return Qnil;
+  }
+}
+
+VALUE 
+ytl_ivar_set_boxing(VALUE slf, int off, VALUE val)
+{
+  int len;
+  int i;
+
+  /* Copy from variable.c in ruby1.9 */
+  len = ROBJECT_NUMIV(slf);
+  if (len <= off) {
+    VALUE *ptr = ROBJECT_IVPTR(slf);
+    if (off < ROBJECT_EMBED_LEN_MAX) {
+      RBASIC(slf)->flags |= ROBJECT_EMBED;
+      ptr = ROBJECT(slf)->as.ary;
+      for (i = 0; i < ROBJECT_EMBED_LEN_MAX; i++) {
+	ptr[i] = Qundef;
+      }
+    }
+    else {
+      VALUE *newptr;
+      long newsize = (off+1) + (off+1)/4; /* (index+1)*1.25 */
+      if (RBASIC(slf)->flags & ROBJECT_EMBED) {
+	newptr = ALLOC_N(VALUE, newsize);
+	MEMCPY(newptr, ptr, VALUE, len);
+	RBASIC(slf)->flags &= ~ROBJECT_EMBED;
+	ROBJECT(slf)->as.heap.ivptr = newptr;
+      }
+      else {
+	REALLOC_N(ROBJECT(slf)->as.heap.ivptr, VALUE, newsize);
+	newptr = ROBJECT(slf)->as.heap.ivptr;
+      }
+      for (; len < newsize; len++)
+	newptr[len] = Qundef;
+      ROBJECT(slf)->as.heap.numiv = newsize;
+    }
+  }
+  ROBJECT_IVPTR(slf)[off] = val;
+}
+
 void 
 Init_ytljit_ext() 
 {
@@ -575,7 +629,8 @@ Init_ytljit_ext()
   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, "body_address", ytl_arena_address, 0);
+  rb_define_method(ytl_cArena, "raw_address", ytl_arena_raw_address, 0);
   rb_define_method(ytl_cArena, "to_s", ytl_arena_to_s, 0);
 
   /* Open Handles */

data/ext/ytljit.h

@@ -2,7 +2,8 @@
 #define INIT_CODE_SPACE_SIZE 64
 #define VALUE_SPACE_SIZE (8 * 1024)
 
-#define ARENA_SIZE 256 * 1024 /* 256 Kbytes */
+#define CODE_SPACE_SIZE (16 * 1024) /* 16 Kbytes */
+#define ARENA_SIZE (256 * 1024) /* 256 Kbytes */
 
 #define OPEN_CHECK(COND)                                        \
 do {                                                            \
@@ -12,13 +13,21 @@ do {                                                            \
  } while(0)
 
 struct CodeSpace {
+  uintptr_t next_and_size;
   size_t  size;
   size_t  used;
   char body[1];
 };
 
-struct Arena {
+struct ArenaHeader {
+  VALUE *lastptr;
+  struct ArenaBody *body;
+};
+
+struct ArenaBody {
   size_t size;
+  struct ArenaBody *next;
+  struct ArenaHeader *header;
   VALUE body[1];
 };
 
@@ -27,13 +36,17 @@ VALUE ytl_code_space_allocate(VALUE);
 VALUE ytl_code_value_allocate(VALUE);
 
 VALUE ytl_arena_allocate(VALUE);
+char *ytl_arena_alloca(char *, int);
 VALUE ytl_arena_emit(VALUE, VALUE, VALUE);
 VALUE ytl_arena_ref(VALUE, VALUE);
 VALUE ytl_arena_size(VALUE);
+VALUE ytl_arena_raw_address(VALUE);
 VALUE ytl_arena_address(VALUE);
 VALUE ytl_arena_to_s(VALUE);
 
 void ytl_step_handler(void);
+VALUE ytl_ivar_get_boxing(VALUE, int);
+VALUE ytl_ivar_set_boxing(VALUE, int, VALUE);
 
 void init_csarena();
 void *csalloc(int);

data/lib/ytljit/asm.rb

@@ -182,12 +182,33 @@ module YTLJit
       unless off = @@value_table_cache[val] then
         off = @@value_table_entity.current_pos
         @@value_table_entity.emit([val.value].pack("Q"))
+        stfunc = lambda {
+          oldpos = @@value_table_entity.current_pos
+          @@value_table_entity.current_pos = off
+          @@value_table_entity.emit([val.value].pack("Q"))
+          @@value_table_entity.current_pos = oldpos
+        }
+        val.add_refer(stfunc)
         @@value_table_cache[val] = off
       end
 
       @@value_table_entity.var_base_address(off)
     end
 
+    def add_value_entry_no_cache(val)
+      off = @@value_table_entity.current_pos
+      @@value_table_entity.emit([val.value].pack("Q"))
+      stfunc = lambda {
+        oldpos = @@value_table_entity.current_pos
+        @@value_table_entity.current_pos = off
+        @@value_table_entity.emit([val.value].pack("Q"))
+        @@value_table_entity.current_pos = oldpos
+      }
+      val.add_refer(stfunc)
+
+      @@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

data/lib/ytljit/asmext_x64.rb

@@ -171,7 +171,7 @@ module YTLJit
       orgaddress = @asm.current_address
       code = ""
 #      code += @asm.update_state(mov(RAX, OpImmidiate32.new(argnum)))
-      code += @asm.update_state(mov(RAX, OpImmidiate32.new(0)))
+#      code += @asm.update_state(mov(RAX, OpImmidiate32.new(0)))
       code += @asm.update_state(call(addr))
       callpos = @asm.current_address - @asm.output_stream.base_address
       if @asm.retry_mode == :change_op then

data/lib/ytljit/asmutil.rb

@@ -170,6 +170,7 @@ module YTLJit
               )
 
     Arena = AsmType::Struct.new(
+              AsmType::MACHINE_WORD, :used,
               AsmType::MACHINE_WORD, :size,
               AsmType::Array.new(AsmType::INT8, 0), :body
             )

data/lib/ytljit/instruction.rb

@@ -36,9 +36,11 @@ module YTLJit
   end
 
   module OpVarValueMixin
+    @@instances = []
     def initialize(var)
       @var = var
       @refer = []
+      @@instances.push self
     end
 
     def refer
@@ -56,6 +58,10 @@ module YTLJit
     def to_immidiate(klass = OpVarImmidiateAddress)
       klass.new(@var)
     end
+
+    def self.instances
+      @@instances
+    end
   end
 
   class OpVarImmidiate32<OpImmidiate32

data/lib/ytljit/instruction_ia.rb

@@ -780,6 +780,23 @@ module YTLJit
         return nosupported_addressing_mode(inst, dst, src)
       end
     end
+
+    def common_cvt(dst, src, op0, op1, inst)
+      if dst.is_a?(OpRegXMM) and
+          (src.is_a?(OpIndirect) or
+           src.is_a?(OpReg32) or
+           src.is_a?(OpReg64)) then
+        rexseq, rexfmt = rex(dst, src)
+        modseq, modfmt = modrm(inst, dst, src, dst, src)
+        if op0 then
+          ([op0] + rexseq + [0x0F, op1] + modseq).pack("C#{rexfmt}C2#{modfmt}")
+        else
+          (rexseq + [0x0F, op1] + modseq).pack("#{rexfmt}C2#{modfmt}")
+        end
+      else
+        return nosupported_addressing_mode(inst, dst, src)
+      end
+    end
   end
   
   class GeneratorIABinary<Generator
@@ -1138,7 +1155,7 @@ module YTLJit
       case addr2
       when Integer
         offset = addr2 - @asm.current_address - 2
-        if offset > -128 and offset < 127 then
+        if offset > -128 and offset < 127 and false then
           [0xeb, offset].pack("C2")
         else
           offset = addr2 - @asm.current_address - 5
@@ -1223,7 +1240,7 @@ module YTLJit
         case src
         when nil
           modseq, modfmt = modrm(:imul, 5, dst, dst, src)
-          return (rexseq + [0xF7] + modseq).pack("#{rexfmt}C#(modfmt}")
+          return (rexseq + [0xF7] + modseq).pack("#{rexfmt}C#{modfmt}")
           
         when OpReg32, OpMem32, OpIndirect, OpReg64
           modseq, modfmt = modrm(:imul, dst, src, dst, src, src2)
@@ -1367,8 +1384,20 @@ module YTLJit
       common_arithxmm(dst, src, 0x66, 0x2F, :comisd)
     end
 
+    def cvtsi2sd(dst, src)
+      common_cvt(dst, src, 0xf2, 0x2a, :cvtsi2sd)
+    end
+
+    def cvtsi2ss(dst, src)
+      common_cvt(dst, src, 0xf3, 0x2a, :cvtsi2ss)
+    end
+
     def int3
       [0xcc].pack("C")
     end
+
+    def ud2
+      [0x0f, 0x0b].pack("CC")
+    end
   end
 end

data/lib/ytljit/util.rb

@@ -55,9 +55,6 @@ module YTLJit
     @@instance_tab = {}
 
     def self.instance(clsobj)
-      if clsobj.is_a?(ClassClassWrapper)
-        clsobj = clsobj.value
-      end
       ins = @@instance_tab[clsobj] 
       if ins == nil then
         ins = ClassClassWrapper.new(clsobj)
@@ -67,6 +64,10 @@ module YTLJit
       ins
     end
 
+    def self.instance_tab
+      @@instance_tab
+    end
+
     def initialize(clsobj)
       @klass_object = clsobj
       @value = nil
@@ -98,7 +99,7 @@ module YTLJit
     end
     
     def marshal_load(obj)
-      @klass_object = obj
+      @klass_object = obj[0]
       @value = nil
     end