ytljit 0.0.5 → 0.0.6

data/ext/extconf.rb

@@ -1,3 +1,3 @@
 require 'mkmf'
-
+$CFLAGS += ' -fomit-frame-pointer '
 create_makefile("ytljit_ext");

data/ext/memory.c

@@ -27,7 +27,7 @@ ytl_arena_ref(VALUE self, VALUE offset)
   raw_arena = (struct Arena *)DATA_PTR(self);
   raw_offset = FIX2INT(offset);
 
-  return INT2FIX(raw_arena->body[raw_offset]);
+  return ULONG2NUM(raw_arena->body[raw_offset]);
 }
 
 VALUE
@@ -38,7 +38,7 @@ ytl_arena_emit(VALUE self, VALUE offset, VALUE src)
   int raw_offset;
 
   raw_arena = (struct Arena *)DATA_PTR(self);
-  raw_offset = FIX2INT(offset);
+  raw_offset = NUM2ULONG(offset);
 
   raw_arena->body[raw_offset] = FIX2INT(src);
 
@@ -64,7 +64,7 @@ ytl_arena_address(VALUE self)
 
   raw_arena = (struct Arena *)DATA_PTR(self);
 
-  return INT2FIX(raw_arena->body);
+  return ULONG2NUM((uintptr_t)raw_arena->body);
 }
 
 

data/ext/ytljit.c

@@ -213,7 +213,7 @@ ytl_proc_copy(VALUE self, VALUE procval)
 VALUE 
 ytl_memref(VALUE self, VALUE addr)
 {
-  return UINT2NUM(*((char *)NUM2LONG(addr)));
+  return ULONG2NUM(*((uintptr_t *)NUM2LONG(addr)));
 }
 
 VALUE
@@ -396,93 +396,132 @@ ytl_value_space_to_s(VALUE self)
   return rb_sprintf("#<valueSpace %p base=%p:...>", (void *)self, (void *)raw_cs->body);
 }
 
-static VALUE *
-get_registers(unsigned long *regs, VALUE *argv)
-{
-  argv[0] = ULONG2NUM((unsigned long)__builtin_return_address(1));
-
-  /* regs[0]   old bp
-     regs[-1]  old ebx (maybe gcc depend)
-     regs[-2]  return address
-     regs[-3]  pusha starts
-  */
-  argv[1] = ULONG2NUM(regs[-3]);   /* eax */
-  argv[2] = ULONG2NUM(regs[-4]);   /* ecx */
-  argv[3] = ULONG2NUM(regs[-5]);   /* edx */
-  argv[4] = ULONG2NUM(regs[-6]);   /* ebx */
-  argv[5] = ULONG2NUM(regs[-7]);   /* ebp */
-  argv[6] = ULONG2NUM(regs[-8]);   /* esi */
-  argv[7] = ULONG2NUM(regs[-9]);   /* edi */
-
-  return argv;
-}
+#ifdef __x86_64__
+#define NUMREGS 16
+#elif  __i386__
+#define NUMREGS 8
+#else
+#error "only i386 or x86-64 is supported"
+#endif
 
 static void
-body(void)
+body(uintptr_t *regbuf)
 {
   VALUE *argv;
-  unsigned long *regs;
-
-#if defined(__i386__) || defined(__i386)
-  asm("mov (%%ebp), %0"
-      : "=r" (regs) : : "%eax");
-#elif defined(__x86_64__) || defined(__x86_64)
-  asm("mov (%%rbp), %0"
-      : "=r" (regs) : : "%rax");
-#else
-#error "only i386 or x86-64 is supported"
-#endif
-  argv = ALLOCA_N(VALUE, 8);
-  argv = get_registers(regs, argv);
+  uintptr_t sp;
+  int i;
+
+  argv = ALLOCA_N(VALUE, NUMREGS + 1);
+
+  for (i = 0; i < NUMREGS; i++) {
+    argv[i] = ULONG2NUM((uintptr_t)regbuf[NUMREGS - i - 1]);
+  }
+  sp = (uintptr_t)regbuf;
+  sp += NUMREGS * sizeof(uintptr_t); /* reg save area */
+  sp += sizeof(uintptr_t); 	/* stored pc by call instruction */
+  argv[NUMREGS] = ULONG2NUM(sp);
 
-  rb_funcall2(ytl_eStepHandler, ytl_v_step_handler_id, 8, argv);
+  rb_funcall2(ytl_eStepHandler, ytl_v_step_handler_id, NUMREGS + 1, argv);
 }
 
-static void
+static uintptr_t * __attribute__ ((noinline, optimize("omit-frame-pointer")))
 pushall(void)
 {
 #ifdef __x86_64__
-  asm("push %rax");
+  asm("pop %rax");
   asm("push %rcx");
   asm("push %rdx");
   asm("push %rbx");
   asm("push %rbp");
   asm("push %rsi");
   asm("push %rdi");
+  asm("push %r8");
+  asm("push %r9");
+  asm("push %r10");
+  asm("push %r11");
+  asm("push %r12");
+  asm("push %r13");
+  asm("push %r14");
+  asm("push %r15");
+  asm("mov  %rax, %rcx");	/* return %rsp */
+  asm("mov  %rsp, %rax");	/* return %rsp */
+  asm("push %rcx");
 #elif __i386__
-  asm("pushal");
+  asm("pop %eax");
+  asm("push %ecx");
+  asm("push %edx");
+  asm("push %ebx");
+  asm("push %ebp");
+  asm("push %esi");
+  asm("push %edi");
+  asm("mov  %eax, %ecx");	/* return %rsp */
+  asm("mov  %esp, %eax");	/* return %rsp */
+  asm("push %ecx");
 #else
 #error "only i386 or x86-64 is supported"
 #endif
 }
 
-static void
+static void __attribute__ ((noinline, optimize("omit-frame-pointer")))
 popall(void)
 {
 #ifdef __x86_64__
+  asm("pop %rax");
+  asm("pop %r15");
+  asm("pop %r14");
+  asm("pop %r13");
+  asm("pop %r12");
+  asm("pop %r11");
+  asm("pop %r10");
+  asm("pop %r9");
+  asm("pop %r8");
   asm("pop %rdi");
   asm("pop %rsi");
   asm("pop %rbp");
   asm("pop %rbx");
   asm("pop %rdx");
   asm("pop %rcx");
-  asm("pop %rax");
+  asm("push %rax");
 #elif __i386__
-  asm("popal");
+  asm("pop %eax");
+  asm("pop %edi");
+  asm("pop %esi");
+  asm("pop %ebp");
+  asm("pop %ebx");
+  asm("pop %edx");
+  asm("pop %ecx");
+  asm("push %eax");
 #else
 #error "only i386 or x86-64 is supported"
 #endif
 }
 
-void
+void __attribute__ ((optimize("omit-frame-pointer")))
 ytl_step_handler()
 {
-
-  /* Don't add local variables. Maybe break consistency of stack */
-
-  pushall();
-  body();
+#ifdef __x86_64__
+  asm("push %rax");
+  asm("add $0x8, %rsp");
+  asm("mov %0, %%rax" : : "g"(__builtin_return_address(0)));
+  asm("sub $0x8, %rsp");
+  asm("push %rax");
+  body(pushall());
+  popall();
+  asm("pop %rax");
+  asm("pop %rax");
+#elif __i386__
+  asm("push %eax");
+  asm("add $0x4, %esp");
+  asm("mov %0, %%eax" : : "g"(__builtin_return_address(0)));
+  asm("sub $0x4, %esp");
+  asm("push %eax");
+  body(pushall());
   popall();
+  asm("pop %eax");
+  asm("pop %eax");
+#else
+#error "only i386 or x86-64 is supported"
+#endif
 }
 
 void 

data/ext/ytljit.h

@@ -33,6 +33,8 @@ VALUE ytl_arena_size(VALUE);
 VALUE ytl_arena_address(VALUE);
 VALUE ytl_arena_to_s(VALUE);
 
+void ytl_step_handler(void);
+
 void init_csarena();
 void *csalloc(int);
 void csfree(void *);

data/lib/ytljit/asm.rb

@@ -1,16 +1,49 @@
 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]
+    case $ruby_platform
+    when /x86_64/
+      REGS = {
+        "RAX" => 0, "RCX" => 2, "RDX" => 3, "RBX" => 4, 
+        "RBP" => 5, "RSP" => 16, "RDI" => 6, "RSI" => 7,
+        "R8" => 8, "R9" => 9, "R10" => 10, "R11" => 11, "R12" => 12,
+        "R13" => 13, "R14" => 14, "R15" => 15
+      }
+
+    when /i.86/
+      REGS = {
+        "EAX" => 0, "ECX" => 2, "EDX" => 3, "EBX" => 4, 
+        "EBP" => 5, "ESP" => 8, "EDI" => 6, "ESI" => 7
+      }
+    end
+
+    def backtrace(bp)
+      bp = memref(bp)
+      pc = memref(bp + AsmType::MACHINE_WORD.size)
+      frame_struct_tab = VM::Node::TopTopNode.get_frame_struct_tab
+      if frame_struct_tab[pc] then
+        STDERR.print frame_struct_tab[pc][0].class, "\n"
+        STDERR.print frame_struct_tab[pc][0].debug_info, "\n"
+        STDERR.print frame_struct_tab[pc][2].map {|n| n.class}, "\n"
+        bp = memref(bp)
+        backtrace(bp)
+      end
+    end
+    
+    def step_handler(*regval)
+      STDERR.print "#{regval[1].to_s(16)} "
+      STDERR.print CodeSpace.disasm_cache[regval[1].to_s(16)], "\n"
+      frame_struct_tab = VM::Node::TopTopNode.get_frame_struct_tab
+      STDERR.print frame_struct_tab[regval[1]][0].debug_info, "\n"
+      STDERR.print frame_struct_tab[regval[1]][2].map {|n| n.class}, "\n"
+      REGS.each do |rname, no|
+        STDERR.print rname
         STDERR.print ": 0x"
-        STDERR.print val.to_s(16)
+        STDERR.print regval[no].to_s(16)
         STDERR.print " "
       end
+      STDERR.print "\nbacktrace\n"
+      backtrace(regval[5])
       STDERR.print "\n"
      end
   end
@@ -94,6 +127,7 @@ module YTLJit
     attr          :output_stream
     attr          :after_patch_tab
     attr          :retry_mode
+    attr          :generator
 
     def var_current_address
       current_address = @current_address
@@ -124,10 +158,12 @@ module YTLJit
 
       org_retry_mode = @retry_mode
       @retry_mode = :change_org
-      while org_base_address != @output_stream.base_address do
+      while org_base_address != @output_stream.base_address
         org_base_address = @output_stream.base_address
         reset
         @output_stream.reset
+        @generator.funcarg_info.used_arg_tab = []
+        @generator.funcarg_info.area_allocate_pos = []
         @asmsend_history.each do |arg|
           send(arg[0], *arg[1])
         end

data/lib/ytljit/asmext.rb

@@ -124,7 +124,7 @@ module YTLJit
 
     attr_accessor :used_arg_tab
     attr          :maxargs
-    attr          :area_allocate_pos
+    attr_accessor :area_allocate_pos
 
     def update_maxargs(args)
       if @maxargs < args then

data/lib/ytljit/asmext_x64.rb

@@ -148,7 +148,7 @@ module YTLJit
         case src
         when Integer
           disp = dst.disp
-          dst2 = dst.class.new(dst.reg, disp + 4)
+          dst2 = dst.class.new(dst.reg, disp.value + 4)
           bit32val = 1 << 32
           code = mov(dst2, src / bit32val)
           code += mov(dst, src % bit32val)
@@ -162,7 +162,7 @@ module YTLJit
     end
 
     def call_with_arg_get_argsize(addr, argnum)
-      argnum * 8
+      ((argnum > 4) ? argnum : 4 )* 8
     end
 
     def call_with_arg(addr, argnum, argsize)
@@ -170,47 +170,31 @@ module YTLJit
 
       orgaddress = @asm.current_address
       code = ""
-      code += @asm.update_state(mov(RAX, OpImmidiate32.new(argnum)))
+#      code += @asm.update_state(mov(RAX, OpImmidiate32.new(argnum)))
+      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
         return [code, callpos]
       end
 
-      offset = @funcarg_info.area_allocate_pos.pop
-      if offset then
-        imm = OpImmidiate8.new(argsize)
-        code += @asm.update_state(add(SPR, imm))
-        alloc_argument_area = lambda {
-          @asm.with_current_address(@asm.output_stream.base_address + offset) {
-            @asm.output_stream[offset] = sub(SPR, argsize)
+      # no argument this not allocate 4 words for callee working
+      if argnum != 0 then
+        offset = @funcarg_info.area_allocate_pos.pop
+        if offset then
+          imm = OpImmidiate8.new(argsize)
+          code += @asm.update_state(add(SPR, imm))
+          alloc_argument_area = lambda {
+            @asm.with_current_address(@asm.output_stream.base_address + offset) {
+              @asm.output_stream[offset] = sub(SPR, argsize)
+            }
           }
-        }
-        @asm.after_patch_tab.push alloc_argument_area
-      end
-
-      @funcarg_info.update_maxargs(argnum)
-      @funcarg_info.used_arg_tab.pop
-
-=begin
-      # Save already stored restorer
-      uat = @funcarg_info.used_arg_tab.last
-      while !fainfo.empty? do
-        nreg = fainfo.pop
-        if argpos = ARGPOS2REG.index(nreg) then
-          if uat[argpos] then
-            fainfo.push nreg
-            break
-          else
-            code += @asm.update_state(pop(nreg))
-            uat[argpos] = true
-          end
-        else
-          fainfo.push nreg
-          break
+          @asm.after_patch_tab.push alloc_argument_area
         end
+        
+        @funcarg_info.update_maxargs(argnum)
+        @funcarg_info.used_arg_tab.pop
       end
-=end
 
       @asm.current_address = orgaddress
 

data/lib/ytljit/asmext_x86.rb

@@ -73,9 +73,9 @@ module YTLJit
       case dst
       when OpIndirect
         case src
-          when Integer
+        when Integer
           disp = dst.disp
-          dst2 = dst.class.new(dst.reg, disp + 4)
+          dst2 = dst.class.new(dst.reg, disp.value + 4)
           bit32val = 1 << 32
           code = mov(dst2, src / bit32val)
           code += mov(dst, src % bit32val)
@@ -108,18 +108,20 @@ module YTLJit
       if @asm.retry_mode == :change_op then
         return [code, callpos]
       end
-
-      code += @asm.update_state(add(SPR, OpImmidiate8.new(argsize)))
-      offset = @funcarg_info.area_allocate_pos.pop
-      alloc_argument_area = lambda {
-        asm.with_current_address(asm.output_stream.base_address + offset) {
-          asm.output_stream[offset] = sub(SPR, argsize)
+      
+      if argnum != 0 then
+        code += @asm.update_state(add(SPR, OpImmidiate8.new(argsize)))
+        offset = @funcarg_info.area_allocate_pos.pop
+        alloc_argument_area = lambda {
+          asm.with_current_address(asm.output_stream.base_address + offset) {
+            asm.output_stream[offset] = sub(SPR, argsize)
+          }
         }
-      }
-      asm.after_patch_tab.push alloc_argument_area
-
-      @funcarg_info.update_maxargs(argnum)
-      @funcarg_info.used_arg_tab.pop
+        asm.after_patch_tab.push alloc_argument_area
+        
+        @funcarg_info.update_maxargs(argnum)
+        @funcarg_info.used_arg_tab.pop
+      end
       @asm.current_address = orgaddress
       
       [code, callpos]

data/lib/ytljit/asmutil.rb

@@ -92,6 +92,8 @@ module YTLJit
       TMPR = OpEAX.instance
       TMPR2 = OpEDX.instance
       TMPR3 = OpECX.instance
+      PTMPR = OpEBX.instance
+      THEPR = OpEDI.instance    # Temporary Heap pointer
       DBLLOR = OpEAX.instance
       DBLHIR = OpEDX.instance
       RETR = OpEAX.instance
@@ -104,6 +106,8 @@ module YTLJit
 #      TMPR3 = OpRCX.instance
       TMPR2 = OpR10.instance
       TMPR3 = OpR11.instance
+      PTMPR = OpRBX.instance
+      THEPR = OpR14.instance    # Temporary Heap pointer
       DBLLOR = OpRAX.instance
       DBLHIR = OpRDX.instance
       RETR = OpRAX.instance

data/lib/ytljit/instruction.rb

@@ -116,6 +116,9 @@ module YTLJit
   class OpIndirect<Operand
     def initialize(reg, disp = 0)
       @reg = reg
+      if disp.is_a?(Fixnum) then
+        disp = OpImmidiate.new(disp)
+      end
       @disp = disp
     end
 
@@ -124,7 +127,11 @@ module YTLJit
 
 
     def to_as
-      "#{@disp}(#{@reg.to_as})"
+      if @disp.is_a?(OpImmidiate) then
+        "#{@disp.value}(#{@reg.to_as})"
+      else
+        "#{@disp.value}(#{@reg.to_as})"
+      end
     end
 
     def using(reg)

data/lib/ytljit/instruction_ia.rb

@@ -465,7 +465,8 @@ module YTLJit
 
     def modrm_indirect_off32(regv, rm_reg, rm_disp)
       fstb = 0b10000000 | ((regv & 7) << 3) | (rm_reg.reg_no & 7)
-      if rm_reg.is_a?(OpESP) or rm_reg.is_a?(OpRSP) then
+      if rm_reg.is_a?(OpESP) or 
+          rm_reg.is_a?(OpRSP) or rm_reg.is_a?(OpR12) then
         [[fstb, 0b00100100, rm_disp], "C2L"]
       else
         [[fstb, rm_disp], "CL"]
@@ -474,7 +475,8 @@ module YTLJit
 
     def modrm_indirect_off8(regv, rm_reg, rm_disp)
       fstb = 0b01000000 | ((regv & 7) << 3) | (rm_reg.reg_no & 7)
-      if rm_reg.is_a?(OpESP) or rm_reg.is_a?(OpRSP) then
+      if rm_reg.is_a?(OpESP) or 
+          rm_reg.is_a?(OpRSP) or rm_reg.is_a?(OpR12) then
         [[fstb, 0b00100100, rm_disp], "C3"]
       else
         [[fstb, rm_disp], "CC"]
@@ -491,13 +493,20 @@ module YTLJit
         regv = reg.value
       end
 
-      case rm.disp
+      rmdisp = rm.disp
+      if rmdisp.class == OpImmidiate then
+        rmdisp = rmdisp.value
+      end
+
+      case rmdisp
       when 0
-        if rm.reg.is_a?(OpEBP) or rm.reg.is_a?(OpRBP) then
+        if rm.reg.is_a?(OpEBP) or 
+            rm.reg.is_a?(OpRBP) or rm.reg.is_a?(OpR13) then
           modrm_indirect_off8(regv, rm.reg, 0)
         else
           fstb = 0b00000000 | ((regv & 7) << 3) | (rm.reg.reg_no & 7)
-          if rm.reg.is_a?(OpESP) or rm.reg.is_a?(OpRSP)  then
+          if rm.reg.is_a?(OpESP) or 
+              rm.reg.is_a?(OpRSP) or rm.reg.is_a?(OpR12) then
             [[fstb, 0x24], "C2"]
           else
             [[fstb], "C"]
@@ -505,16 +514,16 @@ module YTLJit
         end
         
       when OpImmidiate8
-        modrm_indirect_off8(regv, rm.reg, rm.disp.value)
+        modrm_indirect_off8(regv, rm.reg, rmdisp.value)
         
       when OpImmidiate32
-        modrm_indirect_off32(regv, rm.reg, rm.disp.value)
+        modrm_indirect_off32(regv, rm.reg, rmdisp.value)
 
       when Integer
-        if small_integer_8bit?(rm.disp.abs) then
-          modrm_indirect_off8(regv, rm.reg, rm.disp)
+        if small_integer_8bit?(rmdisp.abs) then
+          modrm_indirect_off8(regv, rm.reg, rmdisp)
         else
-          modrm_indirect_off32(regv, rm.reg, rm.disp)
+          modrm_indirect_off32(regv, rm.reg, rmdisp)
         end
       end
     end
@@ -685,10 +694,11 @@ module YTLJit
     end
 
     def common_setcc(dst, opc, inst)
+      rexseq, rexfmt = rex(nil, dst)
       case dst
       when OpReg8, OpIndirect, OpMem8
         modseq, modfmt = modrm(inst, 0, dst, dst, nil)
-        ([0x0F, opc] + modseq).pack("C2#{modfmt}")
+        (rexseq + [0x0F, opc] + modseq).pack("#{rexfmt}C2#{modfmt}")
       else
         return nosupported_addressing_mode(inst, dst, nil)
       end
@@ -709,16 +719,17 @@ module YTLJit
     end
 
     def common_movssd(dst, src, op, inst)
+      rexseq, rexfmt = rex(dst, src)
       case dst
       when OpRegXMM
         case src
         when OpRegXMM
           modseq, modfmt = modrm(inst, dst, src, dst, src)
-          ([op, 0x0F, 0x10] + modseq).pack("C3#{modfmt}")
+          ([op] + rexseq + [0x0F, 0x10] + modseq).pack("C#{rexfmt}C2#{modfmt}")
 
         when OpIndirect
           modseq, modfmt = modrm(inst, dst, src, dst, src)
-          ([op, 0x0F, 0x10] + modseq).pack("C3#{modfmt}")
+          ([op] + rexseq + [0x0F, 0x10] + modseq).pack("C#{rexfmt}C2#{modfmt}")
 
         else
           return nosupported_addressing_mode(inst, dst, src)
@@ -728,7 +739,7 @@ module YTLJit
         case src
         when OpRegXMM
           modseq, modfmt = modrm(inst, src, dst, dst, src)
-          ([op, 0x0F, 0x11] + modseq).pack("C3#{modfmt}")
+          ([op] + rexseq + [0x0F, 0x11] + modseq).pack("C#{rexfmt}C2#{modfmt}")
           
         else
           return nosupported_addressing_mode(inst, dst, src)
@@ -747,7 +758,7 @@ module YTLJit
           rexseq, rexfmt = rex(dst, src)
           modseq, modfmt = modrm(inst, dst, src, dst, src)
           if op0 then
-            (rexseq + [op0, 0x0F, op1] + modseq).pack("#{rexfmt}C3#{modfmt}")
+            ([op0] + rexseq + [0x0F, op1] + modseq).pack("C#{rexfmt}C2#{modfmt}")
           else
             (rexseq + [0x0F, op1] + modseq).pack("#{rexfmt}C2#{modfmt}")
           end
@@ -756,7 +767,7 @@ module YTLJit
           rexseq, rexfmt = rex(dst, src)
           modseq, modfmt = modrm(inst, dst, src, dst, src)
           if op0 then
-            (rexseq + [op0, 0x0F, op1] + modseq).pack("#{rexfmt}C3#{modfmt}")
+            ([op0] + rexseq + [0x0F, op1] + modseq).pack("C#{rexfmt}C2#{modfmt}")
           else
             (rexseq + [0x0F, op1] + modseq).pack("#{rexfmt}C2#{modfmt}")
           end

data/lib/ytljit/instruction_x64.rb

@@ -11,7 +11,6 @@ module YTLJit
       
       if dst.is_a?(OpIndirect) and dst.reg.is_a?(OpReg64) then
         if dst.reg_no >= 8 then
-          rrex |= 0b1000
           rrex |= 0b1
         end
       end
@@ -24,8 +23,7 @@ module YTLJit
       end
 
       if src.is_a?(OpIndirect) and src.reg.is_a?(OpReg64) then
-        if dst.reg_no >= 8 then
-          rrex |= 0b1000
+        if src.reg_no >= 8 then
           rrex |= 0b1
         end
       end

data/lib/ytljit/util.rb

@@ -52,10 +52,29 @@ module YTLJit
   # Singleton class can't be marshaled.
   # So this class wrap to marshal singleton class
   class ClassClassWrapper
+    @@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)
+        @@instance_tab[clsobj] = ins
+      end
+
+      ins
+    end
+
     def initialize(clsobj)
       @klass_object = clsobj
       @value = nil
     end
+
+    def to_s
+      "#<Ytljit::ClassClassWrapper type=#{value.inspect}"
+    end
     
     def value
       if @value then
@@ -82,6 +101,16 @@ module YTLJit
       @klass_object = obj
       @value = nil
     end
+
+    def superclass
+      sup = value.superclass
+      ins = @@instance_tab[sup]
+      if ins then
+        ins
+      else
+        sup
+      end
+    end
   end
 end