rltk3 3.0.2

data/test/cg/tc_instruction.rb

@@ -0,0 +1,256 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Ruby Language Toolkit
+# Date:		2012/05/09
+# Description:	This file contains unit tests for the RLTK::CG::Instruction
+#			class.
+
+############
+# Requires #
+############
+
+# Gems
+require 'minitest/autorun'
+
+# Ruby Language Toolkit
+require 'rltk/cg/llvm'
+require 'rltk/cg/module'
+require 'rltk/cg/instruction'
+
+class InstructionTester < Minitest::Test
+	def setup
+		RLTK::CG::LLVM.init(:X86)
+
+		@mod = RLTK::CG::Module.new('Testing Module')
+		@jit = RLTK::CG::JITCompiler.new(@mod)
+	end
+
+	def test_float_comparison
+		fcmp_assert(:oeq, 1.0, 1.0, true )
+		fcmp_assert(:one, 1.0, 1.0, false)
+		fcmp_assert(:ogt, 2.0, 2.0, false)
+		fcmp_assert(:oge, 2.0, 1.0, true )
+		fcmp_assert(:olt, 1.0, 1.0, false)
+		fcmp_assert(:ole, 1.0, 2.0, true )
+		fcmp_assert(:ord, 1.0, 2.0, true )
+		fcmp_assert(:ueq, 1.0, 1.0, true )
+		fcmp_assert(:une, 1.0, 1.0, false)
+		fcmp_assert(:ugt, 2.0, 2.0, false)
+		fcmp_assert(:uge, 2.0, 1.0, true )
+		fcmp_assert(:ult, 1.0, 1.0, false)
+		fcmp_assert(:ule, 1.0, 2.0, true )
+		fcmp_assert(:uno, 1.0, 2.0, false)
+	end
+
+	def test_instruction
+		fun = @mod.functions.add('instruction_tester', RLTK::CG::DoubleType, [RLTK::CG::DoubleType]) do |fun|
+			blocks.append do
+				ret(fadd(fun.params[0], RLTK::CG::Double.new(3.0)))
+			end
+		end
+
+		entry = fun.blocks.entry
+
+		inst0 = entry.instructions.first
+		inst1 = entry.instructions.last
+
+		assert_kind_of(RLTK::CG::Instruction, inst0)
+		assert_kind_of(RLTK::CG::Instruction, inst1)
+
+		assert_equal(inst1, inst0.next)
+		assert_equal(inst0, inst1.previous)
+
+		assert_equal(entry, inst0.parent)
+		assert_equal(entry, inst1.parent)
+	end
+
+	def test_integer_comparison
+		icmp_assert(:eq,   1, 1, true,  true )
+		icmp_assert(:ne,   1, 1, true,  false)
+		icmp_assert(:ugt,  2, 2, false, false)
+		icmp_assert(:uge,  2, 1, false, true )
+		icmp_assert(:ult,  1, 1, false, false)
+		icmp_assert(:ule,  1, 2, false, true )
+		icmp_assert(:sgt, -2, 2, true,  false)
+		icmp_assert(:sge, -2, 1, true,  false)
+		icmp_assert(:slt, -1, 2, true,  true )
+		icmp_assert(:sle, -1, 2, true,  true )
+	end
+
+	def test_array_memory_access
+		fun = @mod.functions.add('array_memory_access_tester', RLTK::CG::NativeIntType,
+		                         [RLTK::CG::NativeIntType, RLTK::CG::NativeIntType]) do |fun|
+
+			blocks.append do
+				ptr = array_alloca(RLTK::CG::NativeIntType, RLTK::CG::NativeInt.new(2))
+
+				store(fun.params[0], gep(ptr, [RLTK::CG::NativeInt.new(0)]))
+				store(fun.params[1], gep(ptr, [RLTK::CG::NativeInt.new(1)]))
+
+				ret(add(load(gep(ptr, [RLTK::CG::NativeInt.new(0)])), load(gep(ptr, [RLTK::CG::NativeInt.new(1)]))))
+			end
+		end
+
+		assert_equal(3, @jit.run_function(fun, 1, 2).to_i)
+	end
+
+	def test_simple_memory_access
+		fun = @mod.functions.add('simple_memory_access_tester', RLTK::CG::NativeIntType,
+		                         [RLTK::CG::NativeIntType, RLTK::CG::NativeIntType]) do |fun|
+
+			blocks.append do
+				p0 = alloca(RLTK::CG::NativeIntType)
+				p1 = alloca(RLTK::CG::NativeIntType)
+
+				store(fun.params[0], p0)
+				store(fun.params[1], p1)
+
+				ret(add(load(p0), load(p1)))
+			end
+		end
+
+		assert_equal(3, @jit.run_function(fun, 1, 2).to_i)
+	end
+
+	def test_struct_access
+		fun = @mod.functions.add('struct_access_tester', RLTK::CG::FloatType, [RLTK::CG::NativeIntType, RLTK::CG::FloatType]) do |fun|
+			blocks.append do
+				st0 = RLTK::CG::StructType.new([RLTK::CG::NativeIntType, RLTK::CG::FloatType])
+				st1 = RLTK::CG::StructType.new([RLTK::CG::FloatType, st0, RLTK::CG::NativeIntType])
+
+				ptr = alloca(st1)
+
+				store(fun.params[0], gep(ptr, [RLTK::CG::NativeInt.new(0), RLTK::CG::NativeInt.new(1), RLTK::CG::NativeInt.new(0)]))
+				store(fun.params[1], gep(ptr, [RLTK::CG::NativeInt.new(0), RLTK::CG::NativeInt.new(1), RLTK::CG::NativeInt.new(1)]))
+
+				addr0 = gep(ptr, [RLTK::CG::NativeInt.new(0), RLTK::CG::NativeInt.new(1), RLTK::CG::NativeInt.new(0)])
+				addr1 = gep(ptr, [RLTK::CG::NativeInt.new(0), RLTK::CG::NativeInt.new(1), RLTK::CG::NativeInt.new(1)])
+
+				ret(fadd(ui2fp(load(addr0), RLTK::CG::FloatType), load(addr1)))
+			end
+		end
+
+		assert_in_delta(5.3, @jit.run_function(fun, 2, 3.3).to_f, 0.001)
+	end
+
+	def test_struct_values
+		fun = @mod.functions.add('struct_values_tester', RLTK::CG::NativeIntType, [RLTK::CG::NativeIntType, RLTK::CG::NativeIntType]) do |fun|
+			blocks.append do
+				ptr = alloca(RLTK::CG::StructType.new([RLTK::CG::NativeIntType, RLTK::CG::NativeIntType]))
+
+				struct = load(ptr)
+				struct = insert_value(struct, fun.params[0], 0)
+				struct = insert_value(struct, fun.params[1], 1)
+
+				ret(add(extract_value(struct, 0), extract_value(struct, 1)))
+			end
+		end
+
+		assert_equal(5, @jit.run_function(fun, 2, 3).to_i)
+	end
+
+	####################
+	# Conversion Tests #
+	####################
+
+	def test_bitcast
+		difftype_assert(:bitcast, RLTK::CG::Int8.new(255), RLTK::CG::Int8Type, :integer, -1)
+	end
+
+	def test_fp2ui
+		difftype_assert(:fp2ui, RLTK::CG::Double.new(123.3), RLTK::CG::Int32Type, :integer, 123)
+		difftype_assert(:fp2ui, RLTK::CG::Double.new(0.7),   RLTK::CG::Int32Type, :integer,   0)
+		difftype_assert(:fp2ui, RLTK::CG::Double.new(1.7),   RLTK::CG::Int32Type, :integer,   1)
+	end
+
+	def test_fp2si
+		difftype_assert(:fp2si, RLTK::CG::Double.new(-123.3), RLTK::CG::Int32Type, :integer, -123)
+		difftype_assert(:fp2si, RLTK::CG::Double.new(0.7),    RLTK::CG::Int32Type, :integer,    0)
+		difftype_assert(:fp2si, RLTK::CG::Double.new(1.7),    RLTK::CG::Int32Type, :integer,    1)
+	end
+
+	def test_fpext
+		fconv_assert(:fp_ext, RLTK::CG::Float.new(123.0), RLTK::CG::DoubleType, 123.0)
+		fconv_assert(:fp_ext, RLTK::CG::Float.new(123.0), RLTK::CG::FloatType,  123.0)
+	end
+
+	def test_fptrunc
+		fconv_assert(:fp_trunc, RLTK::CG::Double.new(123.0), RLTK::CG::FloatType, 123.0)
+	end
+
+	def test_int64
+		iconv_assert(:zext, RLTK::CG::Int64.new( 2**62 + 123), RLTK::CG::Int64Type, true,   2**62 + 123)
+		iconv_assert(:zext, RLTK::CG::Int64.new(-2**62 - 123), RLTK::CG::Int64Type, true,  -2**62 - 123)
+		iconv_assert(:zext, RLTK::CG::Int64.new( 2**63 + 123), RLTK::CG::Int64Type, false,  2**63 + 123)
+	end
+
+	def test_sext
+		iconv_assert(:sext, RLTK::CG::Int1.new(1),  RLTK::CG::Int32Type, true,     -1)
+		iconv_assert(:sext, RLTK::CG::Int8.new(-1), RLTK::CG::Int16Type, false, 65535)
+	end
+
+	def test_si2fp
+		difftype_assert(:si2fp, RLTK::CG::Int32.new(257), RLTK::CG::FloatType,  :float, 257.0)
+		difftype_assert(:si2fp, RLTK::CG::Int8.new(-1),   RLTK::CG::DoubleType, :float,  -1.0)
+	end
+
+	def test_truncate
+		iconv_assert(:trunc, RLTK::CG::Int32.new(257), RLTK::CG::Int8Type, false, 1)
+		iconv_assert(:trunc, RLTK::CG::Int32.new(123), RLTK::CG::Int1Type, false, 1)
+		iconv_assert(:trunc, RLTK::CG::Int32.new(122), RLTK::CG::Int1Type, false, 0)
+	end
+
+	def test_ui2fp
+		difftype_assert(:ui2fp, RLTK::CG::Int32.new(257), RLTK::CG::FloatType,  :float, 257.0)
+		difftype_assert(:ui2fp, RLTK::CG::Int8.new(-1),   RLTK::CG::DoubleType, :float, 255.0)
+	end
+
+	def test_zext
+		iconv_assert(:zext, RLTK::CG::Int16.new(257), RLTK::CG::Int32Type, false, 257)
+	end
+
+	##################
+	# Helper Methods #
+	##################
+
+	def difftype_assert(op, operand, ret_type, assert_type, expected)
+		res = run_convert(op, operand, ret_type)
+
+		if assert_type == :integer then assert_equal(expected, res.to_i) else assert_in_delta(expected, res.to_f(ret_type), 0.001) end
+	end
+
+	def fcmp_assert(mode, operand0, operand1, expected)
+		res = run_cmp(:fcmp, mode, RLTK::CG::Float.new(operand0), RLTK::CG::Float.new(operand1), RLTK::CG::Int1Type).to_i(false)
+		assert_equal(expected.to_i, res)
+	end
+
+	def icmp_assert(mode, operand0, operand1, signed, expected)
+		res = run_cmp(:icmp, mode, RLTK::CG::NativeInt.new(operand0, signed),
+		              RLTK::CG::NativeInt.new(operand1, signed), RLTK::CG::Int1Type).to_i(false)
+
+		assert_equal(expected.to_i, res)
+	end
+
+	def fconv_assert(op, operand, ret_type, expected)
+		assert_in_delta(expected, run_convert(op, operand, ret_type).to_f(ret_type), 0.001)
+	end
+
+	def iconv_assert(op, operand, ret_type, signed, expected)
+		assert_equal(expected, run_convert(op, operand, ret_type).to_i(signed))
+	end
+
+	def run_cmp(op, mode, operand0, operand1, ret_type)
+		fun = @mod.functions.add("#{op}_#{mode}_tester", ret_type, []) do
+			blocks.append { ret(self.send(op, mode, operand0, operand1)) }
+		end
+
+		@jit.run_function(fun)
+	end
+
+	def run_convert(op, operand, ret_type)
+		fun = @mod.functions.add("#{op}_tester", ret_type, []) do
+			blocks.append { ret(self.send(op, operand, ret_type)) }
+		end
+
+		@jit.run_function(fun)
+	end
+end

data/test/cg/tc_llvm.rb

@@ -0,0 +1,25 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Ruby Language Toolkit
+# Date:		2012/05/04
+# Description:	This file contains unit tests for rltk/cg/llvm.rb file.
+
+############
+# Requires #
+############
+
+# Gems
+require 'minitest/autorun'
+
+# Ruby Language Toolkit
+require 'rltk/version'
+require 'rltk/cg/llvm'
+
+#######################
+# Classes and Modules #
+#######################
+
+class LLVMTester < Minitest::Test
+	def test_init
+		assert_raises(ArgumentError) { RLTK::CG::LLVM.init(:foo) }
+	end
+end

data/test/cg/tc_math.rb

@@ -0,0 +1,88 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Ruby Language Toolkit
+# Date:		2012/05/09
+# Description:	This file contains unit tests for various math instructions.
+
+############
+# Requires #
+############
+
+# Gems
+require 'minitest/autorun'
+
+# Ruby Language Toolkit
+require 'rltk/cg/llvm'
+require 'rltk/cg/module'
+require 'rltk/cg/execution_engine'
+require 'rltk/cg/type'
+require 'rltk/cg/value'
+
+#######################
+# Classes and Modules #
+#######################
+
+class MathTester < Minitest::Test
+	def setup
+		RLTK::CG::LLVM.init(:X86)
+
+		@mod = RLTK::CG::Module.new('Testing Module')
+		@jit = RLTK::CG::JITCompiler.new(@mod)
+	end
+
+	def test_integer_binary_operations
+		int_binop_assert(:add,   3, 2,  3 + 2)
+		int_binop_assert(:sub,   3, 2,  3 - 2)
+		int_binop_assert(:mul,   3, 2,  3 * 2)
+		int_binop_assert(:udiv, 10, 2, 10 / 2)
+		int_binop_assert(:sdiv, 10, 2, 10 / 2)
+		int_binop_assert(:urem, 10, 3, 10 % 3)
+		int_binop_assert(:srem, 10, 3, 10 % 3)
+	end
+
+	def test_integer_bitwise_binary_operations
+		int_binop_assert(:shl,   2, 3,  2 << 3)
+		int_binop_assert(:lshr, 16, 3, 16 >> 3)
+		int_binop_assert(:ashr, 16, 3, 16 >> 3)
+		int_binop_assert(:and,   2, 1,  2 & 1)
+		int_binop_assert(:or,    2, 1,  2 | 1)
+		int_binop_assert(:xor,   3, 2,  3 ^ 2)
+	end
+
+	def test_float_binary_operations
+		float_binop_assert(:fadd, 3.1, 2.2, 3.1 + 2.2)
+		float_binop_assert(:fsub, 3.1, 2.2, 3.1 - 2.2)
+		float_binop_assert(:fmul, 3.1, 2.2, 3.1 * 2.2)
+		float_binop_assert(:fdiv, 3.1, 2.2, 3.1 / 2.2)
+		float_binop_assert(:frem, 3.1, 2.2, 3.1 % 2.2)
+	end
+
+	def test_simple_math_fun
+		fun = @mod.functions.add('simple_math_tester', RLTK::CG::FloatType, [RLTK::CG::FloatType]) do |fun|
+			blocks.append do
+				ret(fadd(fun.params[0], RLTK::CG::Float.new(1.0)))
+			end
+		end
+
+		assert_equal(6.0, @jit.run_function(fun, 5.0).to_f)
+	end
+
+	##################
+	# Helper Methods #
+	##################
+
+	def float_binop_assert(op, operand0, operand1, expected)
+		assert_in_delta(expected, run_binop(op, RLTK::CG::Float.new(operand0), RLTK::CG::Float.new(operand1), RLTK::CG::FloatType).to_f, 0.001)
+	end
+
+	def int_binop_assert(op, operand0, operand1, expected)
+		assert_equal(expected, run_binop(op, RLTK::CG::NativeInt.new(operand0), RLTK::CG::NativeInt.new(operand1), RLTK::CG::NativeIntType).to_i)
+	end
+
+	def run_binop(op, operand0, operand1, ret_type)
+		fun = @mod.functions.add(op.to_s + '_tester', ret_type, []) do
+			blocks.append { ret(self.send(op, operand0, operand1)) }
+		end
+
+		@jit.run_function(fun)
+	end
+end

data/test/cg/tc_module.rb

@@ -0,0 +1,89 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Ruby Language Toolkit
+# Date:		2012/05/04
+# Description:	This file contains unit tests for the RLTK::CG::Module class.
+
+############
+# Requires #
+############
+
+# Standard Library
+require 'tempfile'
+
+# Gems
+require 'minitest/autorun'
+
+# Ruby Language Toolkit
+require 'rltk/cg/llvm'
+require 'rltk/cg/module'
+require 'rltk/cg/execution_engine'
+require 'rltk/cg/type'
+require 'rltk/cg/value'
+
+#######################
+# Classes and Modules #
+#######################
+
+class ModuleTester < Minitest::Test
+	def setup
+		RLTK::CG::LLVM.init(:X86)
+
+		@mod = RLTK::CG::Module.new('Testing Module')
+		@jit = RLTK::CG::JITCompiler.new(@mod)
+
+		@mod.functions.add('int_function_tester', RLTK::CG::NativeIntType, []) do
+			blocks.append { ret RLTK::CG::NativeInt.new(1) }
+		end
+	end
+
+	def test_bitcode
+		Tempfile.open('bitcode') do |tmp|
+			assert(@mod.write_bitcode(tmp))
+
+			new_mod = RLTK::CG::Module.read_bitcode(tmp.path)
+			new_jit = RLTK::CG::JITCompiler.new(new_mod)
+
+			assert_equal(1, new_jit.run_function(new_mod.functions['int_function_tester']).to_i)
+		end
+	end
+
+	def test_equality
+		mod0 = RLTK::CG::Module.new('foo')
+		mod1 = RLTK::CG::Module.new('bar')
+		mod2 = RLTK::CG::Module.new(mod0.ptr)
+
+		assert_equal(mod0, mod2)
+		refute_equal(mod0, mod1)
+	end
+
+	def test_external_fun
+		fun = @mod.functions.add(:sin, RLTK::CG::DoubleType, [RLTK::CG::DoubleType])
+		res = @jit.run_function(fun, RLTK::CG::GenericValue.new(1.0, RLTK::CG::DoubleType)).to_f(RLTK::CG::DoubleType)
+
+		assert_in_delta(Math.sin(1.0), res, 1e-10)
+	end
+
+	def test_simple_int_fun
+		assert_equal(1, @jit.run_function(@mod.functions['int_function_tester']).to_i)
+	end
+
+	def test_simple_float_fun
+		fun = @mod.functions.add('float_function_tester', RLTK::CG::FloatType, []) do
+			blocks.append do
+				ret RLTK::CG::Float.new(1.5)
+			end
+		end
+
+		assert_equal(1.5, @jit.run_function(fun).to_f(RLTK::CG::FloatType))
+	end
+
+	def test_simple_double_fun
+		fun = @mod.functions.add('double_function_tester', RLTK::CG::DoubleType, []) do
+			blocks.append do
+				ret RLTK::CG::Double.new(1.6)
+			end
+		end
+
+		assert_equal(1.6, @jit.run_function(fun).to_f(RLTK::CG::DoubleType))
+	end
+end

data/test/cg/tc_transforms.rb

@@ -0,0 +1,68 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Ruby Language Toolkit
+# Date:		2012/05/11
+# Description:	This file contains unit tests for the mechanics beind
+#			transformation passes.
+
+############
+# Requires #
+############
+
+# Gems
+require 'minitest/autorun'
+
+# Ruby Language Toolkit
+require 'rltk/cg/llvm'
+require 'rltk/cg/module'
+require 'rltk/cg/execution_engine'
+require 'rltk/cg/type'
+require 'rltk/cg/value'
+
+class TransformTester < Minitest::Test
+	def setup
+		RLTK::CG::LLVM.init(:X86)
+
+		@mod = RLTK::CG::Module.new('Testing Module')
+		@jit = RLTK::CG::JITCompiler.new(@mod)
+	end
+
+	def test_gdce
+		fn0 = @mod.functions.add('fn0', RLTK::CG::VoidType, []) do |fun|
+			fun.linkage = :internal
+
+			blocks.append do
+				ret_void
+			end
+		end
+
+		fn1 = @mod.functions.add('fn1', RLTK::CG::VoidType, []) do |fun|
+			fun.linkage = :internal
+
+			blocks.append do
+				ret_void
+			end
+		end
+
+		main = @mod.functions.add('main', RLTK::CG::VoidType, []) do
+			blocks.append do
+				call(fn0)
+				ret_void
+			end
+		end
+
+		funs = @mod.functions.to_a
+
+		assert(funs.include?(fn0))
+		assert(funs.include?(fn1))
+		assert(funs.include?(main))
+
+		@mod.pass_manager << :GDCE
+		assert(@mod.pass_manager.run)
+
+		funs = @mod.functions.to_a
+
+		assert( funs.include?(fn0))
+		assert(!funs.include?(fn1))
+		assert( funs.include?(main))
+	end
+end

data/test/cg/tc_type.rb

@@ -0,0 +1,69 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Ruby Language Toolkit
+# Date:		2012/05/09
+# Description:	This file contains unit tests for the RLTK::CG::Type class and
+#			its subclasses.
+
+############
+# Requires #
+############
+
+# Gems
+require 'minitest/autorun'
+
+# Ruby Language Toolkit
+require 'rltk/cg/type'
+
+class TypeTester < Minitest::Test
+	def setup
+		@pointee = RLTK::CG::NativeIntType.instance
+		@pointer = RLTK::CG::PointerType.new(@pointee)
+	end
+
+	def test_deferrent_element_type_stuct_type
+		type = RLTK::CG::StructType.new([], 'test_struct')
+		type.element_types = [RLTK::CG::NativeIntType, RLTK::CG::FloatType]
+
+		assert_equal(2, type.element_types.size)
+		assert_equal(RLTK::CG::NativeIntType.instance, type.element_types[0])
+		assert_equal(RLTK::CG::FloatType.instance, type.element_types[1])
+
+	end
+
+	def test_element_type
+		assert_equal(@pointee, @pointer.element_type)
+	end
+
+	def test_equality
+		assert_equal(RLTK::CG::NativeIntType, RLTK::CG::NativeIntType)
+		refute_equal(RLTK::CG::NativeIntType, RLTK::CG::FloatType)
+
+		at0 = RLTK::CG::ArrayType.new(RLTK::CG::NativeIntType, 2)
+		at1 = RLTK::CG::ArrayType.new(RLTK::CG::NativeIntType, 2)
+		at2 = RLTK::CG::ArrayType.new(RLTK::CG::FloatType, 2)
+
+		assert_equal(at0, at1)
+		refute_equal(at0, at2)
+	end
+
+	def test_kind
+		assert_equal(:pointer, @pointer.kind)
+		assert_equal(:integer, @pointee.kind)
+	end
+
+	def test_named_struct_type
+		type = RLTK::CG::StructType.new([RLTK::CG::NativeIntType, RLTK::CG::FloatType], 'test_struct')
+
+		assert_instance_of(RLTK::CG::StructType, type)
+		assert_equal('test_struct', type.name)
+	end
+
+	def test_simple_struct_type
+		type = RLTK::CG::StructType.new([RLTK::CG::NativeIntType, RLTK::CG::FloatType])
+
+		assert_instance_of(RLTK::CG::StructType, type)
+		assert_equal(2, type.element_types.size)
+		assert_equal(RLTK::CG::NativeIntType.instance, type.element_types[0])
+		assert_equal(RLTK::CG::FloatType.instance, type.element_types[1])
+	end
+end