ytl 0.0.4 → 0.0.5

data/lib/ytl.rb

@@ -9,7 +9,7 @@ include YTLJit
 module YTL
   include YTLJit
 
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
   
   ISEQ_OPTS = {  
     :peephole_optimization    => true,
@@ -33,6 +33,10 @@ module YTL
     opt.on('--disp-signature', 'Display signature of method') do |f|
       ytlopt[:disp_signature] = f
     end
+
+    opt.on('--insert-signature-comment', 'insert comment of signature') do |f|
+      ytlopt[:insert_signature_comment] = f
+    end
     
     opt.on('--dump-context', 'Dump context(registor/stack) for debug') do |f|
       ytlopt[:dump_context] = f
@@ -76,8 +80,8 @@ module YTL
     prelude = File.join(File.dirname(__FILE__), "..", "runtime", "prelude.rb")
     rf = File.read(prelude)
     prog = eval(rf)
-    is = RubyVM::InstructionSequence.compile(prog, ARGV[0], 
-                                             "", 0, ISEQ_OPTS).to_a
+    is = RubyVM::InstructionSequence.compile(prog, prelude, 
+                                             "", 1, ISEQ_OPTS).to_a
     VMLib::InstSeqTree.new(nil, is)
   end
     
@@ -106,7 +110,7 @@ module YTL
     
     tnode = nil
     is = RubyVM::InstructionSequence.compile(prog, ARGV[0], 
-                                             "", 0, ISEQ_OPTS).to_a
+                                             "", 1, ISEQ_OPTS).to_a
     iseq = VMLib::InstSeqTree.new(nil, is)
     iseqs = [prelude_iseq, iseq]
     
@@ -118,6 +122,7 @@ module YTL
     tnode.collect_info(ci_context)
     
     dmylit = VM::Node::LiteralNode.new(tnode, nil)
+    dmylit2 = VM::Node::LiteralNode.new(tnode, Object.new)
     arg = [dmylit, dmylit, dmylit]
     sig = []
     arg.each do |ele|
@@ -150,8 +155,8 @@ module YTL
       rf = File.read(fn)
       prog = eval(rf)
       progs.push prog
-      is = RubyVM::InstructionSequence.compile(prog, ARGV[0], 
-                                               "", 0, ISEQ_OPTS).to_a
+      is = RubyVM::InstructionSequence.compile(prog, fn, 
+                                               "", 1, ISEQ_OPTS).to_a
       iseq = VMLib::InstSeqTree.new(nil, is)
       tr = VM::YARVTranslatorCRubyObject.new([iseq])
       tr_context.current_file_name = fn
@@ -159,6 +164,7 @@ module YTL
     end
     
     tnode = nil
+    progarray = nil
     case File.extname(ARGV[0])
     when ".ytl"
       File.open(ARGV[0]) do |fp|
@@ -172,8 +178,11 @@ module YTL
       
     when ".rb"
       prog = File.read(ARGV[0])
+      if options[:insert_signature_comment] then
+        progarray = prog.split(/\n/)
+      end
       is = RubyVM::InstructionSequence.compile(prog, ARGV[0], 
-                                               "", 0, ISEQ_OPTS).to_a
+                                               "", 1, ISEQ_OPTS).to_a
       iseq = VMLib::InstSeqTree.new(nil, is)
       if options[:dump_yarv] then
         pp iseq
@@ -184,6 +193,9 @@ module YTL
       tr_context.current_file_name = ARGV[0]
       tnode = tr.translate(tr_context)
     end
+    $0 = ARGV[0]
+    file_name = ARGV[0]
+    ARGV.shift
     
     ci_context = VM::CollectInfoContext.new(tnode)
     ci_context.options = options
@@ -194,6 +206,7 @@ module YTL
     end
     
     dmylit = VM::Node::LiteralNode.new(tnode, nil)
+    dmylit2 = VM::Node::LiteralNode.new(tnode, Object.new)
     arg = [dmylit, dmylit, dmylit]
     sig = []
     arg.each do |ele|
@@ -230,6 +243,32 @@ module YTL
       tnode.code_space.disassemble
     end
     
+    if options[:insert_signature_comment] then
+      progarray.each_with_index do |lin, lno|
+        if cinfos = c_context.comment[file_name][lno] # and cinfo[0] then
+          cinfos.each do |cinfo|
+            case cinfo[0]
+            when 1
+              print "#  #{cinfo[1]} \n"
+              cinfo[2..-1].each do |sig, res|
+                print "#     #{sig[3..-1]} -> #{res.inspect} \n"
+                print "#     self    #{sig[2].inspect} \n"
+                print "#     block   #{sig[1].inspect} \n"
+                print "# \n"
+              end
+            when 2
+              print "# #{cinfo[1]} #{cinfo[2].inspect} \n"
+            when 3
+              if cinfo[1] == :local_export then
+                print "# please do't unroll stack \n"
+              end
+            end
+          end
+        end
+        print lin, "\n"
+      end
+    end
+
     tcs = tnode.code_space
     STDOUT.flush
     if !options[:compile_only] then

data/lib/ytl/accmem.rb

@@ -7,31 +7,15 @@ end
 module YTLJit
   module VM
     module Node
-
-      class SendElementRefMemoryNode<SendElementRefNode
+      
+      module AccMemUtil
         include SendUtil
         include X86
         include X64
 
-        add_special_send_node :[]
-
-        def fill_result_cache(context)
-          slf = @arguments[2]
-          slfval = @arguments[2].get_constant_value
-          if slfval then
-            slfval =slfval[0]
-
-            idxval = @arguments[3].get_constant_value
-            if idxval then
-              idxval = idxval[0]
-              @result_cache = slfval[idxval]
-            end
-          end
-
-          context
-        end
-
         def collect_candidate_type_regident(context, slf)
+          cursig = context.to_signature
+          @arguments[3].decide_type_once(cursig)
           if slf.ruby_type <= YTL::Memory then
             kind = @arguments[4]
             kvalue = kind.get_constant_value
@@ -42,17 +26,20 @@ module YTLJit
               case kvalue
               when :char, :word, :dword, :machine_word
                 fixtype = RubyType::BaseType.from_ruby_class(Fixnum)
-                add_type(context.to_signature, fixtype)
+                add_type(cursig, fixtype)
                 
               when :float 
                 floattype = RubyType::BaseType.from_ruby_class(Float)
-                add_type(context.to_signature, floattype)
+                add_type(cursig, floattype)
                 
               when AsmType::StructMember
                 if kvalue.type.is_a?(AsmType::Scalar) then
                   if kvalue.type.kind == :int then
                     ttype = RubyType::BaseType.from_ruby_class(Fixnum)
-                    add_type(context.to_signature, ttype)
+                    add_type(cursig, ttype)
+                  elsif kvalue.type.kind == :float then
+                    ttype = RubyType::BaseType.from_ruby_class(Float)
+                    add_type(cursig, ttype)
                   else
                     raise "Unkown type #{kvalue.type} #{kvalue.type.kind}"
                   end
@@ -63,7 +50,7 @@ module YTLJit
               when AsmType::Scalar
                 if kvalue.kind == :int then
                   ttype = RubyType::BaseType.from_ruby_class(Fixnum)
-                  add_type(context.to_signature, ttype)
+                  add_type(cursig, ttype)
 
                 else
                   raise "Unkown type"
@@ -76,7 +63,7 @@ module YTLJit
               
             else
               fixtype = RubyType::BaseType.from_ruby_class(Fixnum)
-              add_type(context.to_signature, fixtype)
+              add_type(cursig, fixtype)
             end
 
             context
@@ -85,7 +72,7 @@ module YTLJit
               slf.ruby_type <= AsmType::Array then
             tt = AsmType::PointedData
             pointedtype = RubyType::BaseType.from_ruby_class(tt)
-            add_type(context.to_signature, pointedtype)
+            add_type(cursig, pointedtype)
             context
 
           elsif slf.ruby_type <= AsmType::Struct or
@@ -93,7 +80,7 @@ module YTLJit
               slf.ruby_type <= AsmType::StructMember then
             tt = AsmType::StructMember
             stmemtype = RubyType::BaseType.from_ruby_class(tt)
-            add_type(context.to_signature, stmemtype)
+            add_type(cursig, stmemtype)
             context
 
           else
@@ -101,45 +88,165 @@ module YTLJit
           end
         end
 
-        def compile_ref_scalar(context, typeobj)
+        def gen_read_mem(context, type)
+          size = type.size
+          asm = context.assembler
+          case type.kind
+          when :int
+            case size
+            when 8
+              asm.with_retry do
+                if context.ret_reg != RAX then
+                  asm.mov(RAX, context.ret_reg)
+                end
+                asm.mov(RAX, INDIRECT_RAX)
+              end
+              context.ret_reg = RAX
+              
+            when 4
+              asm.with_retry do
+                if context.ret_reg != EAX then
+                  asm.mov(EAX, context.ret_reg)
+                end
+                asm.mov(EAX, INDIRECT_EAX)
+              end
+              context.ret_reg = EAX
+              
+            when 2
+              asm.with_retry do
+                asm.mov(AL, context.ret_reg)
+                asm.mov(AL, INDIRECT_AL)
+              end
+              context.ret_reg = EAX
+              
+            else
+              raise "Unkown Scalar size #{kvalue}"
+            end
+
+          when :float
+            case size
+            when 8
+              asm.with_retry do
+                if context.ret_reg != RAX then
+                  asm.mov(RAX, context.ret_reg)
+                end
+                asm.movsd(RETFR, INDIRECT_RAX)
+              end
+              context.ret_reg = RETFR
+              
+            when 4
+              asm.with_retry do
+                if context.ret_reg != EAX then
+                  asm.mov(EAX, context.ret_reg)
+                end
+                asm.movss(RETFR, INDIRECT_EAX)
+              end
+              context.ret_reg = RETFR
+              
+            else
+              raise "Unkown Scalar size #{kvalue}"
+            end
+          end
+
           context
         end
 
-        def gen_read_mem(context, size)
+        def gen_write_mem(context, type)
+          size = type.size
           asm = context.assembler
-          case size
-          when 8
-            asm.with_retry do
-              if context.ret_reg != RAX then
-                asm.mov(RAX, context.ret_reg)
+          case type.kind
+          when :int
+            case size
+            when 8
+              asm.with_retry do
+                if context.ret_reg != RAX then
+                  asm.mov(RAX, context.ret_reg)
+                end
+                asm.mov(INDIRECT_TMPR2, RAX)
+              end
+              context.ret_reg = RAX
+              
+            when 4
+              asm.with_retry do
+                if context.ret_reg != EAX then
+                  asm.mov(EAX, context.ret_reg)
+                end
+                asm.mov(INDIRECT_TMPR2, EAX)
               end
-              asm.mov(RAX, INDIRECT_RAX)
+              context.ret_reg = EAX
+              
+            when 2
+              asm.with_retry do
+                asm.mov(AL, context.ret_reg)
+                asm.mov(INDIRECT_TMPR2, AL)
+              end
+              context.ret_reg = EAX
+              
+            else
+              raise "Unkown Scalar size #{kvalue}"
             end
-            context.ret_reg = RAX
-            
-          when 4
-            asm.with_retry do
-              if context.ret_reg != EAX then
-                asm.mov(EAX, context.ret_reg)
+
+          when :float
+            case size
+            when 8
+              asm.with_retry do
+                if context.ret_reg != RETFR then
+                  asm.mov(RETFR, context.ret_reg)
+                end
+                asm.movsd(INDIRECT_TMPR2, RETFR)
               end
-              asm.mov(EAX, INDIRECT_EAX)
+              context.ret_reg = RETFR
+              
+            when 4
+              asm.with_retry do
+                if context.ret_reg != RETFR then
+                  asm.mov(RETFR, context.ret_reg)
+                end
+                asm.movss(INDIRECT_TMPR2, RETFR)
+              end
+              context.ret_reg = RETFR
+              
+            else
+              raise "Unkown Scalar size #{kvalue}"
             end
-            context.ret_reg = EAX
-            
-          when 2
-            asm.with_retry do
-              asm.mov(AL, context.ret_reg)
-              asm.mov(AL, INDIRECT_AL)
+          end
+
+          context
+        end
+
+        def fill_result_cache(context)
+          slf = @arguments[2]
+          slfval = @arguments[2].get_constant_value
+          if slfval then
+            slfval =slfval[0]
+
+            idxval = @arguments[3].get_constant_value
+            if idxval then
+              idxval = idxval[0]
+              @result_cache = slfval[idxval]
             end
-            context.ret_reg = EAX
-            
-          else
-            raise "Unkown Scalar size #{kvalue}"
           end
 
           context
         end
-        
+      end
+
+      class SendElementRefMemoryNode<SendElementRefNode
+        include AccMemUtil
+        include SendUtil
+        include X86
+        include X64
+
+        add_special_send_node :[]
+
+        def collect_candidate_type_regident(context, slf)
+          super
+        end
+
+        def compile_ref_scalar(context, typeobj)
+          context
+        end
+
         def compile(context)
           slf = @arguments[2]
           slf.decide_type_once(context.to_signature)
@@ -182,13 +289,16 @@ module YTLJit
               context.ret_reg = RETFR
               
             when AsmType::Scalar
-              context = gen_read_mem(context, kvalue.size)
+              context = gen_read_mem(context, kvalue)
               
             when AsmType::StructMember
               typeobj = kvalue.type
               case typeobj
               when AsmType::Scalar
-                context = gen_read_mem(context, typeobj.size)
+                asm.with_retry do
+                  asm.add(context.ret_reg, kvalue.offset)
+                end
+                context = gen_read_mem(context, typeobj)
                 
               else
                 raise "Unkown Struct Member type #{kvalue}"
@@ -231,6 +341,95 @@ module YTLJit
         end
       end
 
+      class SendElementAssignMemoryNode<SendElementAssignNode
+        include AccMemUtil
+        include SendUtil
+        include X86
+        include X64
+
+        add_special_send_node :[]=
+
+        def collect_candidate_type_regident(context, slf)
+          # value to set
+          if slf.ruby_type <= YTL::Memory then
+            context = @arguments[5].collect_candidate_type(context)
+          end
+          super
+        end
+
+        def compile(context)
+          slf = @arguments[2]
+          slf.decide_type_once(context.to_signature)
+          if slf.type.ruby_type <= YTL::Memory then
+            asm = context.assembler
+
+            kind = @arguments[4]
+            kvalue = nil
+            case kind
+            when LiteralNode
+              kvalue = kind.value
+
+            else
+              context = kind.compile(context)
+              if context.ret_reg.is_a?(OpVarImmidiateAddress) then
+                objid = (context.ret_reg.value >> 1)
+                kvalue = ObjectSpace._id2ref(objid)
+              end
+            end
+
+            context = @arguments[3].compile(context)
+            context.start_using_reg(TMPR2)
+            asm.with_retry do
+              asm.mov(TMPR2, context.ret_reg)
+            end
+            context = @arguments[5].compile(context)
+
+            case kvalue
+            when :machine_word
+              asm.with_retry do
+                if context.ret_reg != RETR then
+                  asm.mov(RETR, context.ret_reg)
+                end
+                asm.mov(INDIRECT_TMPR2, RETR)
+              end
+              context.ret_reg = RETR
+              
+            when :float
+              asm.with_retry do
+                if context.ret_reg != RETFR then
+                  asm.mov(RETFR, context.ret_reg)
+                end
+                asm.mov(INDIRECT_TMPR, RETFR)
+              end
+              context.ret_reg = RETFR
+              
+            when AsmType::Scalar
+              context = gen_write_mem(context, kvalue)
+              
+            when AsmType::StructMember
+              typeobj = kvalue.type
+              case typeobj
+              when AsmType::Scalar
+                asm.with_retry do
+                  asm.add(TMPR2, kvalue.offset)
+                end
+                context = gen_write_mem(context, typeobj)
+                
+              else
+                raise "Unkown Struct Member type #{kvalue}"
+              end
+            end
+            
+            context.ret_node = self
+            context.end_using_reg(TMPR2)
+
+            @body.compile(context)
+          else
+            super
+          end
+        end
+      end
+
       class SendNewArenaNode<SendNewNode
         add_special_send_node :new