tombagby-llvmruby 0.0.1

data/test/test_basic.rb

@@ -0,0 +1,323 @@
+require 'test/unit'
+require 'llvm'
+
+include LLVM
+
+class BasicTests < Test::Unit::TestCase
+  def function_tester(expected)
+    m = LLVM::Module.new("test_module")
+    type = Type::function(MACHINE_WORD, [])
+    f = m.get_or_insert_function("test", type)
+    yield(f)
+    ExecutionEngine.get(m);
+    assert_equal(expected, ExecutionEngine.run_autoconvert(f))
+  end
+
+  def test_module
+    function_tester(5) do |f|
+      b = f.create_block.builder
+      v = b.add(2.llvm, 3.llvm)
+      b.return(v)
+    end
+  end
+
+  def bin_op(op, v1, v2, expected)
+    function_tester(expected) do |f|
+      b = f.create_block.builder 
+      ret = b.bin_op(op, v1.llvm, v2.llvm)
+      b.return(ret)
+    end
+  end
+
+  def test_bin_ops
+    bin_op(Instruction::Add, 2, 3, 5)
+    bin_op(Instruction::Sub, 5, 3, 2)
+    bin_op(Instruction::Mul, 2, 3, 6)
+    bin_op(Instruction::UDiv, 42, 6, 7)
+    bin_op(Instruction::SDiv, 42, 6, 7)
+    #bin_op(Instruction::FDiv, 23.0, 5, 0.23)
+    bin_op(Instruction::URem, 23, 5, 3)
+    bin_op(Instruction::SRem, 23, 5, 3)
+    #bin_op(Instruction::FRem, 23.0, 5, 0.23)
+
+    bin_op(Instruction::Shl, 2, 1, 4)
+    bin_op(Instruction::LShr, 8, 1, 4)
+    #bin_op(Instruction::AShr, 8, 1, 4) 
+    bin_op(Instruction::And, 8, 15, 8)
+    bin_op(Instruction::Or, 8, 15, 15)
+    bin_op(Instruction::Xor, 8, 15, 7)
+  end
+
+  def builder_bin_op(op, v1, v2, expected)
+    function_tester(expected) do |f|
+      b = f.create_block.builder
+      ret = b.send(op, v1.llvm, v2.llvm)
+      b.return(ret)
+    end
+  end
+
+  def test_builder_bin_ops
+    builder_bin_op(:add, 23, 42, 65)
+    builder_bin_op(:sub, 69, 13, 56)
+    builder_bin_op(:mul, 23, 5, 115)
+    builder_bin_op(:udiv, 23, 5, 4)
+    builder_bin_op(:sdiv, 99, 33, 3)
+    #builder_bin_op(:fdiv, 23, 42, 65)
+    builder_bin_op(:urem, 23, 42, 23)
+    builder_bin_op(:srem, 77, 5, 2)
+    #builder_bin_op(:frem, 23, 42, 65)
+    builder_bin_op(:shl, 15, 1, 30)
+    builder_bin_op(:lshr, 32, 2, 8)
+    #builder_bin_op(:ashr, 23, 42, 65)
+    builder_bin_op(:and, 32, 37, 32)
+    builder_bin_op(:or, 15, 8, 15)
+    builder_bin_op(:xor, 33, 15, 46)
+  end
+
+  def test_insert_point
+    function_tester(2) do |f|
+      b1 = f.create_block
+      b2 = f.create_block
+      builder = b1.builder
+      builder.br(b2)
+      builder.set_insert_point(b2)
+      builder.return(2.llvm)
+    end
+  end
+
+  def test_builder_utils
+    function_tester(5) do |f|
+      b = f.create_block.builder
+      b.write do
+        ret = add(2.llvm, 3.llvm) 
+        self.return(ret)
+      end
+    end
+  end
+
+  def test_cmps
+    m = LLVM::Module.new("test_cmps")
+    type = Type.function(MACHINE_WORD, [])
+    f = m.get_or_insert_function("sgt", type)
+    
+    entry_block = f.create_block
+    exit_block_true = f.create_block
+    exit_block_false = f.create_block
+    
+    b = entry_block.builder
+    cmp = b.icmp_sgt(-1.llvm, 1.llvm)
+    b.cond_br(cmp, exit_block_true, exit_block_false)
+
+    b = exit_block_true.builder
+    b.return(1.llvm)
+
+    b = exit_block_false.builder
+    b.return(0.llvm)
+ 
+    ExecutionEngine.get(m)
+    result = ExecutionEngine.run_autoconvert(f)
+    assert_equal(0, result)
+  end
+
+  def test_fcmps
+    m = LLVM::Module.new('test_fcmps')
+    type = Type.function(MACHINE_WORD, [])
+    f = m.get_or_insert_function('ult', type)
+  
+    entry_block = f.create_block
+    exit_block_true = f.create_block
+    exit_block_false = f.create_block
+  
+    b = entry_block.builder
+    cmp = b.fcmp_ult(1.0.llvm, 2.0.llvm)
+    b.cond_br(cmp, exit_block_true, exit_block_false)
+
+    b = exit_block_true.builder
+    b.return(0.llvm)
+
+    b = exit_block_false.builder
+    b.return(1.llvm)
+
+    ExecutionEngine.get(m)
+    result = ExecutionEngine.run_autoconvert(f)
+    assert_equal(0, result)
+  end
+
+  def test_function_calls
+    m = LLVM::Module.new('test_module')
+    type = Type::function(MACHINE_WORD, [])
+    f_caller = m.get_or_insert_function("caller", type)
+    type = Type::function(MACHINE_WORD, [MACHINE_WORD, MACHINE_WORD])
+    f_callee = m.get_or_insert_function("callee", type)
+
+    b = f_callee.create_block.builder
+    x, y = f_callee.arguments
+    sum = b.add(x, y)
+    b.return(sum)
+    
+    b = f_caller.create_block.builder
+    ret = b.call(f_callee, 2.llvm, 3.llvm)
+    b.return(ret)
+
+    ExecutionEngine.get(m)
+    result = ExecutionEngine.run_autoconvert(f_caller)
+    assert_equal(5, result)
+  end
+
+  def test_phi_node
+    m = LLVM::Module.new('test_module')
+    type = Type::function(MACHINE_WORD, [])
+    f = m.get_or_insert_function('phi_node', type)
+
+    entry_block = f.create_block
+    loop_block = f.create_block
+    exit_block = f.create_block
+
+    b = entry_block.builder
+    b.br(loop_block)
+
+    b = loop_block.builder
+    phi = b.phi(MACHINE_WORD)
+    phi.add_incoming(0.llvm, entry_block)
+    count = b.add(phi, 1.llvm)
+    phi.add_incoming(count, loop_block)
+    cmp = b.icmp_ult(count, 10.llvm)
+    b.cond_br(cmp, loop_block, exit_block)
+
+    b = exit_block.builder
+    b.return(phi)
+
+    ExecutionEngine.get(m)
+    result = ExecutionEngine.run_autoconvert(f)
+    assert_equal(9, result)
+  end
+
+  def test_bitcode_writer
+    m = LLVM::Module.new('static_module')
+    # create main function
+    type = Type.function(Type::Int32Ty, [
+      Type::Int32Ty,
+      Type.pointer(Type.pointer(Type::Int8Ty))
+    ])
+    f = m.get_or_insert_function('main', type)
+    b = f.create_block.builder
+    b.return(666.llvm(Type::Int32Ty))
+
+    m.write_bitcode("test/static.o")
+  end
+
+  def test_type_errors
+    m = LLVM::Module.new('type_errors')
+    ftype = Type.function(Type::Int32Ty, [])
+    assert_raise(TypeError) { f = LLVM::Module.new(5) }
+    assert_raise(TypeError) { m.get_or_insert_function(5, ftype) }
+    assert_raise(TypeError) { m.get_or_insert_function('bad_arg', 5) }
+    assert_raise(TypeError) { ExecutionEngine.get(5) }
+    assert_raise(TypeError) { m.external_function(5, ftype) }
+    assert_raise(TypeError) { m.external_function('fname', 5) }
+    assert_raise(TypeError) { m.write_bitcode(5) }
+    assert_raise(ArgumentError) { ExecutionEngine.run_function }
+    assert_raise(TypeError) { ExecutionEngine.run_function(5) }
+    assert_raise(TypeError) { ExecutionEngine.run_function(5, 5) }
+   
+    f = m.get_or_insert_function('test', ftype) 
+    block1 = f.create_block
+    block2 = f.create_block
+    b = block1.builder
+    assert_raise(TypeError) { b.set_insert_point(5) }
+    assert_raise(TypeError) { b.phi(5) }
+    phi = b.phi(Type::Int32Ty)
+    assert_raise(TypeError) { phi.add_incoming(5, 5) }
+    assert_raise(TypeError) { phi.add_incoming(5.llvm(Type::Int32Ty), 5) }
+    assert_raise(TypeError) { b.bin_op([], 2.llvm, 3.llvm) }
+    assert_raise(TypeError) { b.bin_op(Instruction::Add, 5, 3.llvm) }
+    assert_raise(TypeError) { b.bin_op(Instruction::Add, 3.llvm, 5) }
+  end
+
+  def test_inspectors
+    m = LLVM::Module.new('example')
+    ftype = Type.function(Type::Int32Ty, [])
+    f = m.get_or_insert_function('inspect', ftype)
+    b = f.create_block.builder
+    b.return(5.llvm(Type::Int32Ty))
+    
+    assert_match(/define i32 @inspect\(\)/, m.inspect)
+    assert_match(/define i32 @inspect\(\)/, f.inspect)
+  end
+
+  def test_global_strings
+    m = LLVM::Module.new('globalstrings')
+    ftype = Type.function(Type::Int32Ty, [])
+    f = m.get_or_insert_function('use_global_strings', ftype)
+    b = f.create_block.builder
+    v = b.create_global_string_ptr("SHAKA KHAN")
+  end
+
+  def test_var_arg_ftypes
+    ftype = Type.function(Type::Int32Ty, [], true)
+  end
+
+  def test_struct_constants
+    int_t = Type::Int32Ty
+    struct_type = Type.struct([int_t, int_t, int_t])
+    struct_const = Value.get_struct_constant(struct_type, 2.llvm(int_t), 3.llvm(int_t), 5.llvm(int_t))
+    assert_kind_of(Value, struct_const)
+
+    m = LLVM::Module.new('globals')
+    gv = m.global_variable(struct_type, struct_const)
+    assert_kind_of(Value, gv)
+  end
+
+  def test_malloc_free
+    function_tester(23) do |f|
+      b = f.create_block.builder
+      new_space = b.malloc(MACHINE_WORD, 1)
+      b.store(23.llvm(MACHINE_WORD), new_space)    
+      v = b.load(new_space)
+      b.free(new_space)
+      b.return(v)
+    end
+  end
+
+  def test_cast
+    function_tester(5) do |f|
+      b = f.create_block.builder
+      b.return(b.cast(Instruction::FPToSI, 5.0.llvm, MACHINE_WORD))
+    end
+  end
+
+  def test_switch
+    function_tester(23) do |f|
+      b = f.create_block.builder
+      default = f.create_block
+      on5 = f.create_block
+      switch = b.switch(5.llvm, default)
+      switch.add_case(5.llvm, on5)
+      assert_instance_of(SwitchInst, switch)
+      assert_equal(2, switch.get_num_cases);
+      
+      b = default.builder
+      b.return(7.llvm(MACHINE_WORD))
+
+      b = on5.builder
+      b.return(23.llvm)
+    end
+  end
+
+  def test_vector
+    function_tester(666) do |f|
+      b = f.create_block.builder
+      vt = Type.vector(MACHINE_WORD, 3) 
+      vp = b.alloca(vt, 0)
+      v = b.load(vp) 
+      v2 = b.insert_element(v, 666.llvm(MACHINE_WORD), 0.llvm(Type::Int32Ty))
+      r = b.extract_element(v2, 0.llvm(Type::Int32Ty))
+      b.return(r)
+    end
+  end
+
+  def test_pass_manager_run
+    m = LLVM::Module.new('test')
+    assert PassManager.new.run(m)
+  end
+end

data/test/test_basic_block.rb

@@ -0,0 +1,65 @@
+require 'test/unit'
+require 'llvm'
+
+include LLVM
+
+class BasicBlockTests < Test::Unit::TestCase
+
+  def setup
+
+    @assembly_gcd=<<-EOF
+    ; ModuleID = 'gcd.o'
+    target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
+    target triple = "i386-apple-darwin9"
+
+    define i32 @gcd(i32 %a, i32 %b) nounwind {
+    entry:
+    	%tmp2 = icmp eq i32 %a, 0		; <i1> [#uses=1]
+    	br i1 %tmp2, label %bb26, label %bb19
+
+    bb5:		; preds = %bb19, %bb11
+    	%indvar48 = phi i32 [ %indvar.next49, %bb11 ], [ 0, %bb19 ]		; <i32> [#uses=2]
+    	%tmp50 = sub i32 0, %b_addr.0		; <i32> [#uses=1]
+    	%tmp51 = mul i32 %indvar48, %tmp50		; <i32> [#uses=1]
+    	%a_addr.0.reg2mem.0 = add i32 %tmp51, %a_addr.0		; <i32> [#uses=3]
+    	%tmp8 = icmp sgt i32 %a_addr.0.reg2mem.0, %b_addr.0		; <i1> [#uses=1]
+    	br i1 %tmp8, label %bb11, label %bb15.split
+
+    bb11:		; preds = %bb5
+    	%indvar.next49 = add i32 %indvar48, 1		; <i32> [#uses=1]
+    	br label %bb5
+
+    bb15.split:		; preds = %bb5
+    	%tmp18 = sub i32 %b_addr.0, %a_addr.0.reg2mem.0		; <i32> [#uses=1]
+    	br label %bb19
+
+    bb19:		; preds = %bb15.split, %entry
+    	%b_addr.0 = phi i32 [ %tmp18, %bb15.split ], [ %b, %entry ]		; <i32> [#uses=4]
+    	%a_addr.0 = phi i32 [ %a_addr.0.reg2mem.0, %bb15.split ], [ %a, %entry ]		; <i32> [#uses=2]
+    	%tmp21 = icmp eq i32 %b_addr.0, 0		; <i1> [#uses=1]
+    	br i1 %tmp21, label %bb26, label %bb5
+
+    bb26:		; preds = %bb19, %entry
+    	%tmp.0 = phi i32 [ %b, %entry ], [ %a_addr.0, %bb19 ]		; <i32> [#uses=1]
+    	ret i32 %tmp.0
+    }
+    EOF
+
+  end
+
+
+  def test_count_intructions_in_basic_block
+    m = LLVM::Module.read_assembly(@assembly_gcd)
+    gcd = m.get_function("gcd")
+    assert(gcd)
+
+    bbs = gcd.get_basic_block_list
+    expected = { 'entry' => 2, 'bb5' => 6, 'bb11' => 2, 'bb15.split' => 2, 'bb19' => 4, 'bb26' => 2 }
+    res = Hash.new
+    bbs.each { |b|
+      res[b.get_name] = b.size
+    }
+    assert_equal(expected,res)
+  end
+
+end

data/test/test_instructions.rb

@@ -0,0 +1,46 @@
+require 'test/unit'
+require 'llvm'
+
+include LLVM
+
+class InstructionTests < Test::Unit::TestCase
+
+  def setup
+
+    @assembly_byteswap=<<-EOF
+    ; ModuleID = 'byteswap.bc'
+    target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
+    target triple = "i386-apple-darwin9"
+
+    define i32 @bswap(i32 %x) nounwind {
+    entry:
+    	%tmp3 = shl i32 %x, 24		; <i32> [#uses=1]
+    	%tmp5 = shl i32 %x, 8		; <i32> [#uses=1]
+    	%tmp6 = and i32 %tmp5, 16711680		; <i32> [#uses=1]
+    	%tmp9 = lshr i32 %x, 8		; <i32> [#uses=1]
+    	%tmp1018 = and i32 %tmp9, 65280		; <i32> [#uses=1]
+    	%tmp7 = or i32 %tmp1018, %tmp3		; <i32> [#uses=1]
+    	%tmp11 = or i32 %tmp7, %tmp6		; <i32> [#uses=1]
+    	ret i32 %tmp11
+    }
+    EOF
+
+  end
+
+  def test_count_intructions_in_basic_block
+    m = LLVM::Module.read_assembly(@assembly_byteswap)
+    bswap = m.get_function("bswap")
+    assert(bswap)
+
+    bbs = bswap.get_basic_block_list
+    assert_equal(1,bbs.size)
+    b = bbs[0]
+    assert_equal(8,b.size)
+
+    expected_opcodes_in_bswap = ["shl", "shl", "and", "lshr", "and", "lshr", "and", "or", "or", "ret"]
+    ins = b.get_instruction_list
+    actual_opcodes_in_bswap = ins.map { |i| i.get_opcode_name}
+    assert(expected_opcodes_in_bswap, actual_opcodes_in_bswap)
+  end
+
+end

data/test/test_read_bitcode.rb

@@ -0,0 +1,38 @@
+require 'test/unit'
+require 'llvm'
+
+include LLVM
+
+class BitcodeReadTests < Test::Unit::TestCase
+
+  def test_read_bitcode
+    bc = File.open("test/byteswap.bc").read
+    m = LLVM::Module.read_bitcode(bc)
+    assert_match(/define i32 @bswap\(i32 \%x\) nounwind/, m.inspect) 
+  end
+
+  def test_read_assembly
+    assembly =<<-END_ASSEMBLY
+    ; ModuleID = 'test/byteswap.bc'
+    target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f3
+    2:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
+    target triple = "i386-apple-darwin9"
+
+    define i32 @bswap(i32 %x) nounwind {
+    entry:
+            %tmp3 = shl i32 %x, 24          ; <i32> [#uses=1]
+            %tmp5 = shl i32 %x, 8           ; <i32> [#uses=1]
+            %tmp6 = and i32 %tmp5, 16711680         ; <i32> [#uses=1]
+            %tmp9 = lshr i32 %x, 8          ; <i32> [#uses=1]
+            %tmp1018 = and i32 %tmp9, 65280         ; <i32> [#uses=1]
+            %tmp7 = or i32 %tmp1018, %tmp3          ; <i32> [#uses=1]
+            %tmp11 = or i32 %tmp7, %tmp6            ; <i32> [#uses=1]
+            ret i32 %tmp11
+    }
+    END_ASSEMBLY
+    m = LLVM::Module.read_assembly(assembly)
+    assert_match(/define i32 @bswap\(i32 \%x\) nounwind/, m.inspect)
+    assert(m.get_function("bswap"))
+  end
+
+end

data/test/test_ruby_vm.rb

@@ -0,0 +1,172 @@
+require 'test/unit'
+require 'llvm'
+require 'ruby_vm'
+
+include LLVM
+RubyVM.start
+
+class RubyVMTests < Test::Unit::TestCase
+  def test_getinstancevariable
+    bytecode = [
+      [:putobject, nil.immediate],
+      [:getinstancevariable, :@shaka]
+    ]
+
+    obj = Object.new
+    obj.instance_variable_set(:@shaka, 'khan')
+    compiled_method = RubyVM.compile_bytecode(bytecode)
+    assert_equal('khan', RubyVM.method_send(obj, compiled_method))
+  end
+
+  def test_setinstancevariable
+    bytecode = [
+      [:putobject, 'puter'],
+      [:setinstancevariable, :@fem]
+    ]
+
+    obj = Object.new
+    compiled_method = RubyVM.compile_bytecode(bytecode)
+    RubyVM.method_send(obj, compiled_method)
+    assert_equal('puter', obj.instance_variable_get(:@fem))
+  end
+
+  def test_opt_aset
+    bytecode = [
+      [:newarray],
+      [:dup],
+      [:putobject, 0.immediate],
+      [:putobject, 'shaka'.immediate],
+      [:opt_aset],
+      [:pop]
+    ]
+  
+    ret = RubyVM.call_bytecode(bytecode, nil)
+    assert_equal(ret, ['shaka'])
+  end
+
+  def opt_cmp_tester(op, truth_table)
+    truth_table.each do |x, y, z|
+      bytecode = [
+        [:putobject, x.immediate],
+        [:putobject, y.immediate],
+        [op]
+      ]
+      ret = RubyVM.call_bytecode(bytecode, nil)
+      assert_equal(z, ret) 
+    end
+  end
+
+  def test_opt_lt
+    opt_cmp_tester(:opt_lt, [
+      [0, 1, true],
+      [1, 0, false],
+      [1, 1, false]
+    ])
+  end
+
+  def test_opt_gt
+    opt_cmp_tester(:opt_gt, [
+      [0, 1, false],
+      [1, 0, true],
+      [1, 1, false]
+    ])
+  end
+
+  def test_opt_ge
+    opt_cmp_tester(:opt_ge, [
+      [0, 1, false],
+      [1, 0, true],
+      [1, 1, true]
+    ])
+  end
+
+  def test_opt_length
+    bytecode = [
+      [:opt_length]
+    ]
+
+    ret1 = RubyVM.call_bytecode(bytecode, [])
+    assert_equal(0, ret1)
+
+    ret2 = RubyVM.call_bytecode(bytecode, [1,2,3,4,5])
+    assert_equal(5, ret2)
+  end
+
+  def test_simple_loop
+    bytecode = [
+      [:putobject, 1.immediate],
+      [:opt_plus],
+      [:dup],
+      [:putobject, 10.immediate],
+      [:opt_lt],
+      [:branchif, 0]
+    ]
+
+    ret = RubyVM.call_bytecode(bytecode, 6)
+    assert_equal(10, ret)
+  end
+
+  def test_array_loop
+    bytecode = [
+      [:dup],
+      [:setlocal, 0],
+      [:opt_length],
+      [:putobject, 1.immediate],
+      [:opt_minus],
+      [:dup],
+      [:getlocal, 0],
+      [:swap],
+      [:opt_aref],
+      [:putobject, 2.immediate],
+      [:opt_mult],
+      [:setlocal, 1],
+      [:dup],
+      [:getlocal, 0],
+      [:swap],
+      [:getlocal, 1],
+      [:opt_aset],
+      [:pop],
+      [:dup],
+      [:putobject, 0.immediate],
+      [:opt_gt],
+      [:branchif, 3],
+      [:getlocal, 0]
+    ]
+
+    ret = RubyVM.call_bytecode(bytecode, [1,2,3,4,5,6])
+    assert_equal([2,4,6,8,10,12], ret)
+  end
+
+  def test_send
+    bytecode = [
+      [:send]
+    ]
+
+    ret = RubyVM.call_bytecode(bytecode, nil)
+    assert_equal('nil', ret)
+  end
+
+  def test_putself
+    bytecode = [
+      [:putobject, 5.immediate],
+      [:putself]
+    ]
+    compiled_method = RubyVM.compile_bytecode(bytecode)
+    ret = RubyVM.method_send('me', compiled_method) 
+    assert_equal('me', ret)
+  end
+
+  def test_newhash
+    bytecode = [
+      [:putobject, 'one'.immediate],
+      [:putobject, 1.immediate],
+      [:putobject, 'two'.immediate],
+      [:putobject, 2.immediate],
+      [:putobject, 'three'.immediate],
+      [:putobject, 3.immediate],
+      [:newhash, 6]
+    ]
+    ret = RubyVM.call_bytecode(bytecode, nil)
+    assert_equal({'one' => 1, 'two' => 2, 'three' => 3}, ret)
+  end
+end