plessl-llvmruby 0.0.3

data/lib/version.rb

@@ -0,0 +1,11 @@
+module LLVM
+
+  module Version
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 1
+
+    STRING = [ MAJOR, MINOR, TINY ].join( "." )
+  end
+
+end

data/test/test_basic.rb

@@ -0,0 +1,340 @@
+require 'test/unit'
+$:.unshift File.dirname(__FILE__) + "/../ext"
+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)
+      assert_kind_of(AllocationInst, new_space)
+      assert(!new_space.array_allocation?)
+      assert_kind_of(Value, new_space.array_size)
+      assert_kind_of(Type, new_space.allocated_type)
+      assert_equal(0, new_space.alignment)
+
+      store_inst = b.store(23.llvm(MACHINE_WORD), new_space)    
+      assert(store_inst.may_write_to_memory?)
+      v = b.load(new_space)
+      free_inst = b.free(new_space)
+      assert_kind_of(FreeInst, free_inst)
+      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
+  
+  def test_type_to_s
+    assert_equal "i32", 2.llvm.type.to_s
+  end
+
+  def test_type_type_id
+    assert_equal IntegerTyID, 2.llvm.type.type_id
+  end
+end

data/test/test_basic_block.rb

@@ -0,0 +1,80 @@
+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.name] = b.size
+    }
+    assert_equal(expected,res)
+  end
+
+  def test_manipulate_values
+    m = LLVM::Module.read_assembly(@assembly_gcd)
+    gcd = m.get_function("gcd")
+
+    bbs = gcd.get_basic_block_list
+    bb = bbs.first
+    assert_equal('entry', bb.name)
+    bb.name = 'first_block'
+    assert_equal('first_block', bb.name)
+    assert_equal(3, bb.num_uses)
+    bb2 = bbs.find {|x| x.name == 'bb19'}
+    assert(bb.used_in_basic_block?(bb2))
+    bb3 = bbs.find {|x| x.name = 'bb26'}
+    assert(!bb.used_in_basic_block?(bb3))
+  end
+end

data/test/test_instructions.rb

@@ -0,0 +1,112 @@
+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", "or", "or", "ret"]
+    ins = b.get_instruction_list
+    actual_opcodes_in_bswap = ins.map { |i| i.get_opcode_name}
+    assert_equal(expected_opcodes_in_bswap, actual_opcodes_in_bswap)
+    
+    assert_kind_of(BinaryOperator, ins.first)
+    assert_kind_of(ReturnInst, ins.last)
+ 
+    f1, f2 = ins[0], ins[1]
+    assert(!f1.may_read_from_memory?)
+    assert(!f1.may_write_to_memory?)
+    assert(!f1.identical_to?(f2))
+    assert(f1.identical_to?(f1))
+    assert(f1.same_operation_as?(f2))
+    assert(f1.same_operation_as?(f1))
+    assert(!f1.used_outside_of_block?(b))
+  end
+
+  def test_instruction_classes
+    #m = LLVM::Module.read_assembly(@assembly_byteswap)
+    #bswap = m.get_function('bswap')
+  end
+
+  def test_branch_instructions
+    m = LLVM::Module.new('branch_instructions')
+    ExecutionEngine.get(m)
+    type = Type::function(MACHINE_WORD, [])
+
+    f = m.get_or_insert_function("test_br", type)
+    b1 = f.create_block
+    b2 = f.create_block
+    b3 = f.create_block
+    b4 = f.create_block
+    b5 = f.create_block
+
+    b = b1.builder
+    br_inst = b.br(b2)
+
+    b = b2.builder
+    cmp1 = b.icmp_sgt(-1.llvm, 1.llvm)
+    cmp2 = b.icmp_slt(-1.llvm, 1.llvm)
+    cond_br_inst = b.cond_br(cmp1, b3, b4)
+
+    b = b3.builder
+    b.return(23.llvm)
+
+    b = b4.builder
+    b.return(5.llvm)
+
+    b = b5.builder
+    ret_inst = b.return(1999.llvm)
+
+    assert_kind_of(BranchInst, br_inst)
+    assert(br_inst.unconditional?)
+    assert(!br_inst.conditional?)
+    assert_equal(1, br_inst.num_successors)
+    assert_kind_of(BasicBlock, br_inst.get_successor(0))
+
+    assert_kind_of(BranchInst, cond_br_inst)
+    assert(cond_br_inst.conditional?)
+    assert(!cond_br_inst.unconditional?)
+    assert_kind_of(Value, cond_br_inst.condition)
+    assert_equal(2, cond_br_inst.num_successors)
+    assert_kind_of(BasicBlock, cond_br_inst.get_successor(1))
+
+    assert_kind_of(ReturnInst, ret_inst)
+    assert_equal(0, ret_inst.num_successors)
+
+    cond_br_inst.condition = cmp2
+    cond_br_inst.set_successor(0, b5)
+    assert_equal(1999, ExecutionEngine.run_autoconvert(f))
+  end
+end