ytl 0.0.0

data/README

@@ -0,0 +1,37 @@
+1. Waht is ytl
+
+ Ytl is translator from CRuby VM (aka YARV) to X86-32/X86-64 Native Code.
+Ytl uses ytljit as code generate library.
+
+2. Install
+
+  Install ytljit
+    gem install ytljit
+
+  Enjoy or take pains
+
+3. Sample
+
+  ruby lib/ytl.rb test/basictest.rb
+
+"copy"     # This message is for debug
+"copy"     # This message is for debug
+"copy"     # This message is for debug
+"copy"     # This message is for debug
+1
+1.9
+3
+14930352
+4
+14
+
+3. License
+
+  Ruby's
+
+4. Author
+
+Miura Hideki
+m-72 at tf6.so-net.ne.jp (e-mail)
+http://twitter.com/miura1729    (twitter)
+http://d.hatena.ne.jp/miura1729 (blog in japanese)   

data/bin/ytl

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'ytl'
+
+opt = YTL::parse_opt(ARGV)
+if ARGV[0] == nil
+  print "#{$0} [OPTS] file.rb \n"
+  print "  use --help for detail \n"
+else
+  YTL::main(opt)
+end

data/lib/ytl/accmem.rb

@@ -0,0 +1,334 @@
+module YTL
+  class Memory
+  end
+  TheMemory = Memory.new
+end
+
+module YTLJit
+  module VM
+    module Node
+
+      class SendElementRefMemoryNode<SendElementRefNode
+        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)
+          if slf.ruby_type <= YTL::Memory then
+            kind = @arguments[4]
+            kvalue = kind.get_constant_value
+
+            if kvalue then
+              kvalue =kvalue[0]
+              
+              case kvalue
+              when :char, :word, :dword, :machine_word
+                fixtype = RubyType::BaseType.from_ruby_class(Fixnum)
+                add_type(context.to_signature, fixtype)
+                
+              when :float 
+                floattype = RubyType::BaseType.from_ruby_class(Float)
+                add_type(context.to_signature, 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)
+                  else
+                    raise "Unkown type #{kvalue.type} #{kvalue.type.kind}"
+                  end
+                else
+                  raise "Unkown type #{kvalue}"
+                end
+
+              when AsmType::Scalar
+                if kvalue.kind == :int then
+                  ttype = RubyType::BaseType.from_ruby_class(Fixnum)
+                  add_type(context.to_signature, ttype)
+
+                else
+                  raise "Unkown type"
+                end
+
+              else
+                raise "Unkown type #{kvalue}"
+
+              end
+              
+            else
+              fixtype = RubyType::BaseType.from_ruby_class(Fixnum)
+              add_type(context.to_signature, fixtype)
+            end
+
+            context
+
+          elsif slf.ruby_type <= AsmType::Pointer or
+              slf.ruby_type <= AsmType::Array then
+            tt = AsmType::PointedData
+            pointedtype = RubyType::BaseType.from_ruby_class(tt)
+            add_type(context.to_signature, pointedtype)
+            context
+
+          elsif slf.ruby_type <= AsmType::Struct or
+              slf.ruby_type <= AsmType::Union or 
+              slf.ruby_type <= AsmType::StructMember then
+            tt = AsmType::StructMember
+            stmemtype = RubyType::BaseType.from_ruby_class(tt)
+            add_type(context.to_signature, stmemtype)
+            context
+
+          else
+            super
+          end
+        end
+
+        def compile_ref_scalar(context, typeobj)
+          context
+        end
+
+        def gen_read_mem(context, size)
+          asm = context.assembler
+          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
+
+          context
+        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)
+
+            case kvalue
+            when :machine_word
+              asm.with_retry do
+                if context.ret_reg != TMPR then
+                  asm.mov(TMPR, context.ret_reg)
+                end
+                asm.mov(RETR, INDIRECT_TMPR)
+              end
+              context.ret_reg = RETR
+              
+            when :float
+              asm.with_retry do
+                if context.ret_reg != TMPR then
+                  asm.mov(TMPR, context.ret_reg)
+                end
+                asm.mov(RETFR, INDIRECT_TMPR)
+              end
+              context.ret_reg = RETFR
+              
+            when AsmType::Scalar
+              context = gen_read_mem(context, kvalue.size)
+              
+            when AsmType::StructMember
+              typeobj = kvalue.type
+              case typeobj
+              when AsmType::Scalar
+                context = gen_read_mem(context, typeobj.size)
+                
+              else
+                raise "Unkown Struct Member type #{kvalue}"
+              end
+            end
+            
+            context.ret_node = self
+            return context
+            
+          elsif slf.type.ruby_type <= AsmType::TypeCommon then
+            context = @arguments[2].compile(context)
+            obj = slf.get_constant_value
+            
+            if obj == nil and 
+                context.ret_reg.is_a?(OpVarImmidiateAddress) then
+              objid = (context.ret_reg.value >> 1)
+              obj = ObjectSpace._id2ref(objid)
+            else
+              obj = obj[0]
+            end
+            
+            if obj then
+              index = @arguments[3].get_constant_value
+
+              if index then
+                index = index[0]
+                val = obj[index]
+                add = lambda { val.address }
+                context.ret_reg = OpVarImmidiateAddress.new(add)
+                context.ret_node = self
+                
+                return context
+              end
+            end
+            
+            super
+          else
+            super
+          end
+        end
+      end
+
+      class SendNewArenaNode<SendNewNode
+        add_special_send_node :new
+
+        def traverse_childlen
+          @arguments.each do |arg|
+            yield arg
+          end
+          yield @func
+          yield @body
+        end
+
+        def collect_candidate_type_regident(context, slf)
+          if Runtime::Arena.is_a?(slf.ruby_type) then
+            slfcls = @arguments[2].get_constant_value
+            tt = RubyType::BaseType.from_ruby_class(slfcls[0])
+            add_type(context.to_signature, tt)
+              
+            if @initmethod.is_a?(SendInitializeNode) then
+              # Get alloc method call node
+              @initmethod = @initmethod.arguments[2]
+            end
+
+            return context
+          end
+
+          return super
+        end
+      end
+
+      class SendAddressNode<SendNode
+        include InternalRubyType
+        add_special_send_node :address
+
+        def collect_candidate_type_regident(context, slf)
+          if slf.ruby_type == Runtime::Arena then
+            tt = RubyType::BaseType.from_ruby_class(Fixnum)
+            add_type(context.to_signature, tt)
+
+            return context
+          end
+
+          super
+        end
+
+        def compile(context)
+          context = @arguments[2].compile(context)
+          @arguments[2].decide_type_once(context.to_signature)
+          rtype = @arguments[2].type
+          rrtype = rtype.ruby_type
+          if rrtype == Runtime::Arena then
+            asm = context.assembler
+            rsdata = TypedData.new(RData, context.ret_reg)
+            asm.with_retry do
+              dmy, arena = asm.mov(TMPR, rsdata[:data])
+              asm.mov(TMPR, arena[0][:body])
+            end
+            context.ret_reg = TMPR
+            context.ret_node = self
+            context
+          else
+            super
+          end
+        end
+      end
+
+      class SendInstanceMemoryNode<SendNode
+        add_special_send_node :instance
+
+        def collect_candidate_type_regident(context, slf)
+          if YTL::Memory.is_a?(slf.ruby_type) then
+            slfcls = @arguments[2].get_constant_value
+            if slfcls then
+              tt = RubyType::BaseType.from_ruby_class(slfcls[0])
+              add_type(context.to_signature, tt)
+            end
+
+            return context
+          end
+
+          super
+        end
+
+        def compile(context)
+          @arguments[2].decide_type_once(context.to_signature)
+          rtype = @arguments[2].type
+          rrtype = rtype.ruby_type
+          if YTL::Memory.is_a?(rrtype) then
+            objadd = lambda {
+              YTL::TheMemory.address
+            }
+            context.ret_reg = OpVarImmidiateAddress.new(objadd)
+            context.ret_node = self
+            context
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ytl/importobj.rb

@@ -0,0 +1,10 @@
+module YTL
+  include YTLJit
+  
+  def self.import_ruby_object(context)
+    context.import_object(Object, :Array, Array) 
+    context.import_object(Object, :String, String)
+    context.import_object(Object, :Math, Math)
+  end
+end
+  

data/lib/ytl.rb

@@ -0,0 +1,131 @@
+require 'ytljit'
+require 'ytl/accmem.rb'
+require 'ytl/importobj.rb'
+require 'pp'
+require 'optparse'
+
+include YTLJit
+module YTL
+  include YTLJit
+  
+  ISEQ_OPTS = {  
+    :peephole_optimization    => true,
+    :inline_const_cache       => false,
+    :specialized_instruction  => false,
+  }
+
+  def self.parse_opt(argv)
+    ytlopt = {}
+    prelude = File.join(File.dirname(__FILE__), "..", "runtime", "prelude.rb")
+    ytlopt[:execute_before_compile] = [prelude]
+    opt = OptionParser.new
+    
+    opt.on('--disasm', 'Disasemble generated code') do |f|
+      ytlopt[:disasm] = f
+    end
+
+    opt.on('--dump-yarv', 'Dump YARV byte code') do |f|
+      ytlopt[:dump_yarv] = f
+    end
+
+    opt.on('--disp-signature', 'Display signature of method') do |f|
+      ytlopt[:disp_signature] = f
+    end
+
+    opt.on('--dump-context', 'Dump context(registor/stack) for debug') do |f|
+      ytlopt[:dump_context] = f
+    end
+
+    opt.on('--write-code =FILE', 'Write generating code') do |f|
+      ytlopt[:write_code] = f
+    end
+
+    opt.on('--write-node-before-type-inference =FILE', 
+           'Write node of before type inference') do |f|
+      ytlopt[:write_node_before_ti] = f
+    end
+
+    opt.on('--write-node-after-type-inference =FILE', 
+           'Write node of after type inference') do |f|
+      ytlopt[:write_node_after_ti] = f
+    end
+
+    opt.on('-r FILE', '--execute-before-compile =FILE', 
+           'Execute ruby program (execute by CRuby)') do |f|
+      ytlopt[:execute_before_compile].push f
+    end
+
+    opt.parse!(argv)
+    ytlopt
+  end
+  
+  def self.main(options)
+    tr_context = VM::YARVContext.new
+    progs = []
+
+    import_ruby_object(tr_context)
+    options[:execute_before_compile].each do |fn|
+      rf = File.read(fn)
+      prog = eval(rf)
+      progs.push prog
+    end
+
+    prog = progs.join("\n") + File.read(ARGV[0])
+    is = RubyVM::InstructionSequence.compile(prog, ARGV[0], 
+                                             "", 0, ISEQ_OPTS).to_a
+    iseq = VMLib::InstSeqTree.new(nil, is)
+    if options[:dump_yarv] then
+      pp iseq
+    end
+    
+    tr = VM::YARVTranslatorCRubyObject.new([iseq])
+    tnode = tr.translate(tr_context)
+    ci_context = VM::CollectInfoContext.new(tnode)
+    tnode.collect_info(ci_context)
+
+    if fn = options[:write_node_before_ti] then
+      File.open(fn, "w") do |fp|
+        fp.print Marshal.dump(tnode)
+      end
+    end
+
+    dmylit = VM::Node::LiteralNode.new(tnode, nil)
+    arg = [dmylit, dmylit, dmylit]
+    sig = []
+    arg.each do |ele|
+      sig.push RubyType::BaseType.from_ruby_class(NilClass)
+    end
+
+    ti_context = VM::TypeInferenceContext.new(tnode)
+    begin
+      tnode.collect_candidate_type(ti_context, arg, sig)
+    end until ti_context.convergent
+    ti_context = tnode.collect_candidate_type(ti_context, arg, sig)
+    
+    c_context = VM::CompileContext.new(tnode)
+    c_context.current_method_signature.push sig
+    c_context.options = options
+    c_context = tnode.compile(c_context)
+
+    if fn = options[:write_node_after_ti] then
+      File.open(fn, "w") do |fp|
+        fp.print Marshal.dump(tnode)
+      end
+    end
+
+    if options[:disasm] then
+      tnode.code_space_tab.each do |cs|
+        cs.fill_disasm_cache
+      end
+      tnode.code_space.disassemble
+    end
+
+    tcs = tnode.code_space
+    STDOUT.flush
+    tcs.call(tcs.base_address)
+  end
+end
+
+if __FILE__ == $0 then
+  YTL::main(YTL::parse_opt(ARGV))
+end

data/runtime/prelude.rb

@@ -0,0 +1,30 @@
+# runtime library written in ytl
+<<-'EOS'
+#
+class Array
+  def each
+    i = 0
+    e = self.size
+    while i < e
+      yield self[i]
+      i = i + 1
+    end
+
+    self
+  end
+end
+
+class Fixnum
+  def times
+    i = 0
+    while i < self
+      yield i
+      i = i + 1
+    end
+
+    self
+  end
+end
+
+EOS
+

data/runtime/type.rb

@@ -0,0 +1,10 @@
+include YTLJit
+include InternalRubyType
+
+tr_context.import_object(YTLJit::AsmType, :VALUE, VALUE)
+tr_context.import_object(YTLJit::AsmType, :P_CHAR, P_CHAR)
+tr_context.import_object(YTLJit::AsmType, :RBasic, RBasic)
+tr_context.import_object(YTLJit::AsmType, :RString, RString)
+tr_context.import_object(YTLJit::AsmType, :RFloat, RFloat)
+tr_context.import_object(YTLJit::Runtime, :Arena, Runtime::Arena)
+""

data/test/basictest.rb

@@ -0,0 +1,146 @@
+def id (x)
+  x
+end
+
+p id(1)
+p id(1.9)
+
+def array
+  a = [3, 5, 6]
+  p a
+  a[1] = 1
+  p a
+  [1, 2, 3][0] + [1, 2, 3][1]  
+end
+p array
+
+def fib(x)
+  if x < 2 then
+    1
+  else
+    fib(x-1) + fib(x-2)
+  end
+end
+
+p fib(35)
+
+def fib2(x)
+  if x < 2 then
+    1.0
+  else
+    fib2(x-1) + fib2(x-2)
+  end
+end
+
+p fib2(35)
+
+def blk0(x)
+  yield(x) + 2
+end
+
+def blk1(x)
+  yield(x) + 10
+end
+
+p blk0(1) {|a| a + 1}
+p blk1(1) {|a| blk0(a) {|b| b + a}}
+
+def blk3
+  yield
+end
+
+p id(blk3 { "abc"})
+p id(blk3 { 1 })
+
+def mul(x, y)
+  x * y
+end
+
+p mul(30, 40)
+p mul(30, -40)
+p mul(-30, 40)
+p mul(-30, -40)
+p mul(30.0, 40.0)
+p mul(30.0, -40.0)
+p mul(-30.0, 40.0)
+p mul(-30.0, -40.0)
+
+def div(x, y)
+  x / y
+end
+
+p div(30, 4)
+p div(30, -4)
+p div(-30, 4)
+p div(-30, -4)
+p div(30.0, 7.0)
+p div(30.0, -7.0)
+p div(-30.0, 7.0)
+p div(-30.0, -7.0)
+p div(35, 7)
+p div(35, -7)
+p div(-35, 7)
+p div(-35, -7)
+
+p 1 < 1
+p 1 > 1
+p 1 <= 1
+p 1 >= 1
+
+p 1 < 2
+p 1 > 2
+p 1 <= 2
+p 1 >= 2
+
+p 1.0 < 2.0
+p 1.0 > 2.0
+p 1.0 <= 2.0
+p 1.0 >= 2.0
+
+p 1.0 < 1e-17
+p 1.0 > 1e-17
+p 1.0 <= 1e-17
+p 3.0 > 2.0
+p :foo
+p :foo == :foo
+p :foo == :bar
+p :foo != :foo
+p :foo != :bar
+
+def multi_type_var
+  a = 1
+  p a
+  a = "a"
+  p a
+  a = 1.0
+  p a
+#  p 1.0
+end
+
+multi_type_var
+
+def test_while
+  i = 10
+  j = 0
+  k = 10
+  while i > 0
+    while k > 0
+      j = j + i
+      k = k - 1
+    end
+    i = i - 1
+    k = 10
+  end
+  p j
+
+  i = 10
+  j = 0
+  while i > 0
+    i = i - 1
+    j = j + i
+  end
+  p j
+end
+
+test_while
+

data/test/classtest.rb

@@ -0,0 +1,50 @@
+class Foo
+  def bar
+    p "Foo#bar"
+  end
+
+  def baz
+    p "Foo#baz"
+    p @a
+  end
+
+  def initialize
+    @a = 4
+    p "initialize Foo"
+    p self
+  end
+end
+
+class Bar<Foo
+  def bar
+    p "Bar#bar"
+  end
+end
+
+a = Foo.new
+p a
+a.bar
+a.baz
+b = Bar.new
+p b
+b.bar
+b.baz
+
+class Baz
+  def self.alloc
+    p "alloc"
+  end
+  p self
+end
+
+p Baz.new
+p Baz.alloc
+
+#=end
+=begin
+class Asd
+end
+
+class <<self
+end
+=end

data/test/exceptiontest.rb

@@ -0,0 +1,21 @@
+def foo
+  begin
+    a = 1
+    raise ArgumentError
+  rescue IndexError
+    p "index"
+  end
+
+  begin
+    b = 2
+    raise ArgumentError
+  rescue IndexError
+    p "index2"
+  end
+end
+
+begin
+  foo
+rescue ArgumentError
+  p "bar"
+end

data/test/exttest.rb

@@ -0,0 +1,35 @@
+# Please Execute 
+# ruby -I lib lib/ytl.rb -r runtime/type.rb test/exttest.rb
+module YTL
+  class Memory
+  end
+end
+
+module YTLJit
+  module AsmType
+  end
+
+  module Runtime
+  end
+end
+
+def id(x)
+  x
+end
+
+c = YTLJit::Runtime::Arena.new
+a = YTL::Memory.instance
+# b = 0x1046ce30
+b = c.address
+p b
+p c
+p YTLJit::AsmType::VALUE
+p YTLJit::AsmType::RBasic[:klass]
+p YTLJit::AsmType::RString[:as][:heap][:len]
+p YTLJit::AsmType::RString[:basic][:flags]
+p a[b, :machine_word]
+p a[b, :float]
+#p a[0x106667b8, YTLJit::AsmType::RString[:as][:heap][:ptr]]
+p a[b, YTLJit::AsmType::RString[:basic][:flags]]
+p a[b, YTLJit::AsmType::RString[:as][:heap][:len]]
+p a[b, :machine_word]

data/test/floattest.rb

@@ -0,0 +1,4 @@
+p "2.0".to_f
+p (7).to_f
+p Math.sin(3.14159265)
+p Math.sqrt(2.0)

data/test/looptest.rb

@@ -0,0 +1,20 @@
+class Fixnum
+  def times
+    i = 0
+    while i < self
+      yield i
+      i = i + 1
+    end
+
+    self
+  end
+end
+
+10.times do |i|
+  i.times do |j|
+    p i
+    j.times do |k|
+      p k
+    end
+  end
+end

data/test/tmp.rb

@@ -0,0 +1,7 @@
+def array
+  a = [3, 4, 5]
+  a[1] = 1
+  p a
+  [1, 2, 3][0] + [1, 2, 3][1]  
+end
+p array

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification 
+name: ytl
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 0
+  version: 0.0.0
+platform: ruby
+authors: 
+- Hideki Miura
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-10 00:00:00 +09:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ytljit
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 0
+        - 4
+        version: 0.0.4
+  type: :runtime
+  version_requirements: *id001
+description: 
+email: 
+executables: 
+- ytl
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/ytl.rb
+- lib/ytl/accmem.rb
+- lib/ytl/importobj.rb
+- runtime/prelude.rb
+- runtime/type.rb
+- test/basictest.rb
+- test/classtest.rb
+- test/exceptiontest.rb
+- test/exttest.rb
+- test/floattest.rb
+- test/looptest.rb
+- test/tmp.rb
+- bin/ytl
+- README
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Very tiny subset of YARV to native code translator
+test_files: 
+- test/basictest.rb
+- test/classtest.rb
+- test/exceptiontest.rb
+- test/exttest.rb
+- test/floattest.rb
+- test/looptest.rb
+- test/tmp.rb