rltk 2.2.1 → 3.0.0

data/lib/rltk/parsers/infix_calc.rb

@@ -14,7 +14,7 @@ require 'rltk/parser'
 # Classes and Modules #
 #######################
 
-module RLTK # :nodoc:
+module RLTK
 	
 	# The RLTK::Parsers module contains the parsers that are included as part
 	# of the RLKT project.

data/lib/rltk/parsers/postfix_calc.rb

@@ -14,8 +14,8 @@ require 'rltk/parser'
 # Classes and Modules #
 #######################
 
-module RLTK # :nodoc:
-	module Parsers # :nodoc:
+module RLTK
+	module Parsers
 		
 		# A parser for a simple post-fix calculator.
 		class PostfixCalc < Parser

data/lib/rltk/parsers/prefix_calc.rb

@@ -14,8 +14,8 @@ require 'rltk/parser'
 # Classes and Modules #
 #######################
 
-module RLTK # :nodoc:
-	module Parsers # :nodoc:
+module RLTK
+	module Parsers
 		
 		# A parser for a simple prefix calculator.
 		class PrefixCalc < Parser

data/lib/rltk/token.rb

@@ -7,8 +7,7 @@
 # Classes and Modules #
 #######################
 
-module RLTK # :nodoc:
-	
+module RLTK
 	# The StreamPosition class is used to indicate the position of a token or
 	# other text inside a stream.
 	class StreamPosition

data/lib/rltk/version.rb

@@ -3,9 +3,9 @@
 # Date:		2012/03/08
 # Description:	This file specifies the version number of RLTK.
 
-module RLTK # :nodoc:
+module RLTK
 	# The version number of the RLTK library.
-	VERSION			= '2.2.1'
+	VERSION			= '3.0.0'
 	# The version of LLVM targeted by RLTK.
-	LLVM_TARGET_VERSION	= '3.0'
+	LLVM_TARGET_VERSION	= '3.4'
 end

data/lib/rltk.rb

@@ -7,10 +7,10 @@
 # context-free grammars and code generation.  This includes a class for
 # representing CFGs, lexers, parsers, and generating code using LLVM.
 module RLTK
-	autoload :AST,		'rltk/ast'
-	autoload :CFG,		'rltk/cfg'
-	autoload :CG,		'rltk/cg'
-	autoload :Lexer,	'rltk/lexer'
-	autoload :Parser,	'rltk/parser'
-	autoload :Token,	'rltk/token'
+	autoload :AST,    'rltk/ast'
+	autoload :CFG,    'rltk/cfg'
+	autoload :CG,     'rltk/cg'
+	autoload :Lexer,  'rltk/lexer'
+	autoload :Parser, 'rltk/parser'
+	autoload :Token,  'rltk/token'
 end

data/test/cg/tc_basic_block.rb

@@ -0,0 +1,83 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Ruby Language Toolkit
+# Date:		2012/05/13
+# Description:	This file contains unit tests for the RLTK::CG::BasicBlock
+#			class.
+
+############
+# Requires #
+############
+
+# Gems
+require 'minitest/autorun'
+
+# Ruby Language Toolkit
+require 'rltk/cg/llvm'
+require 'rltk/cg/module'
+
+class BasicBlockTester < Minitest::Test
+	def setup
+		RLTK::CG::LLVM.init(:X86)
+		
+		@mod = RLTK::CG::Module.new('Testing Module')
+	end
+	
+	def test_basic_block
+		fun = @mod.functions.add('basic_block_tester', RLTK::CG::VoidType, [])
+		bb0 = fun.blocks.append
+		bb1 = fun.blocks.append
+		
+		assert_equal(fun, bb0.parent)
+		assert_equal(fun, bb1.parent)
+		
+		assert_equal(bb1, bb0.next)
+		assert_equal(bb0, bb1.previous)
+		
+		bb0.build { br(bb1) }
+		bb1.build { ret_void }
+		
+		assert_equal(bb0.instructions.first, bb0.instructions.last)
+		assert_equal(bb1.instructions.first, bb1.instructions.last)
+	end
+	
+	def test_basic_block_collection
+		fun = @mod.functions.add('basic_block_collection_tester', RLTK::CG::VoidType, [])
+		bb0 = fun.blocks.append
+		
+		assert_instance_of(RLTK::CG::BasicBlock, bb0)
+		
+		assert_equal(1, fun.blocks.size)
+		assert_equal(fun.blocks.first, fun.blocks.last)
+		assert_equal(fun.blocks.first, fun.blocks.entry)
+		
+		bb1 = fun.blocks.append
+		
+		assert_equal(2, fun.blocks.size)
+		assert_equal(bb0, fun.blocks.first)
+		assert_equal(bb1, fun.blocks.last)
+		
+		[fun.blocks.each.to_a, fun.blocks.to_a].each do |blocks|
+			assert_equal(2, blocks.size)
+			assert_equal(bb0, blocks[0])
+			assert_equal(bb1, blocks[1])
+		end
+	end
+	
+	def test_basic_block_enumeration
+		fun = @mod.functions.add('basic_block_enumeration_tester', RLTK::CG::DoubleType, [RLTK::CG::DoubleType])
+		bb0 = fun.blocks.append
+		
+		[bb0.instructions.each.to_a, bb0.instructions.to_a].each do |insts|
+			assert_equal(0, insts.size)
+		end
+		
+		bb0.build { ret(fadd(fun.params[0], RLTK::CG::Double.new(1.0))) }
+		
+		[bb0.instructions.each.to_a, bb0.instructions.to_a].each do |insts|
+			assert_equal(2, insts.size)
+			
+			assert_equal(bb0.instructions.first, insts[0])
+			assert_equal(bb0.instructions.last,  insts[1])
+		end
+	end
+end

data/test/cg/tc_control_flow.rb

@@ -0,0 +1,191 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Ruby Language Toolkit
+# Date:		2012/05/09
+# Description:	This file contains unit tests for control flow instructions.
+
+############
+# Requires #
+############
+
+# Gems
+require 'minitest/autorun'
+
+# Ruby Language Toolkit
+require 'rltk/cg/llvm'
+require 'rltk/cg/execution_engine'
+require 'rltk/cg/module'
+require 'rltk/cg/function'
+require 'rltk/cg/type'
+
+class ControlFlowTester < Minitest::Test
+	def setup
+		RLTK::CG::LLVM.init(:X86)
+		
+		@mod = RLTK::CG::Module.new('Testing Module')
+		@jit = RLTK::CG::JITCompiler.new(@mod)
+	end
+	
+	##############
+	# Call Tests #
+	##############
+	
+	def test_external_call
+		extern = @mod.functions.add('abs', RLTK::CG::NativeIntType, [RLTK::CG::NativeIntType])
+		
+		fun = @mod.functions.add('external_call_tester', RLTK::CG::NativeIntType, [RLTK::CG::NativeIntType]) do |fun|
+			blocks.append { ret call(extern, fun.params[0]) }
+		end
+		
+		assert_equal(10, @jit.run_function(fun, -10).to_i)
+	end
+	
+	def test_external_string_call
+		global = @mod.globals.add(RLTK::CG::ArrayType.new(RLTK::CG::Int8Type, 5), "path")
+		global.linkage = :internal
+		global.initializer = RLTK::CG::ConstantString.new('PATH')
+		
+		external = @mod.functions.add('getenv', RLTK::CG::PointerType.new(RLTK::CG::Int8Type), [RLTK::CG::PointerType.new(RLTK::CG::Int8Type)])
+		
+		fun = @mod.functions.add('external_string_call_tester', RLTK::CG::PointerType.new(RLTK::CG::Int8Type), []) do
+			blocks.append do
+				param = gep(global, [RLTK::CG::NativeInt.new(0), RLTK::CG::NativeInt.new(0)])
+				
+				ret call(external, param)
+			end
+		end
+		
+		assert_equal(ENV['PATH'], @jit.run_function(fun).ptr.read_pointer.read_string)
+	end
+	
+	def test_nested_call
+		fun0 = @mod.functions.add('simple_call_tester0', RLTK::CG::NativeIntType, []) do
+			blocks.append { ret RLTK::CG::NativeInt.new(1) }
+		end
+		
+		fun1 = @mod.functions.add('simple_call_tester1', RLTK::CG::NativeIntType, []) do
+			blocks.append { ret call(fun0) }
+		end
+		
+		assert_equal(1, @jit.run_function(fun1).to_i)
+	end
+	
+	def test_recursive_call
+		fun = @mod.functions.add('recursive_call_tester', RLTK::CG::NativeIntType, [RLTK::CG::NativeIntType]) do |fun|
+			entry	= blocks.append
+			recurse	= blocks.append
+			exit		= blocks.append
+			
+			entry.build do
+				cond(icmp(:uge, fun.params[0], RLTK::CG::NativeInt.new(5)), exit, recurse)
+			end
+			
+			result =
+			recurse.build do
+				call(fun, add(fun.params[0], RLTK::CG::NativeInt.new(1))).tap { br exit }
+			end
+			
+			exit.build do
+				ret(phi(RLTK::CG::NativeIntType, {entry => fun.params[0], recurse => result}))
+			end
+		end
+		
+		assert_equal(5, @jit.run_function(fun, 1).to_i)
+		assert_equal(6, @jit.run_function(fun, 6).to_i)
+	end
+	
+	##############
+	# Jump Tests #
+	##############
+	
+	def test_cond_jump
+		fun = @mod.functions.add('direct_jump_tester', RLTK::CG::NativeIntType, []) do |fun|
+			entry = blocks.append
+			
+			bb0 = blocks.append { ret RLTK::CG::NativeInt.new(1) }
+			bb1 = blocks.append { ret RLTK::CG::NativeInt.new(0) }
+			
+			entry.build do
+				cond(icmp(:eq, RLTK::CG::NativeInt.new(1), RLTK::CG::NativeInt.new(2)), bb0, bb1)
+			end
+		end
+		
+		assert_equal(0, @jit.run_function(fun).to_i)
+	end
+	
+	def test_direct_jump
+		fun = @mod.functions.add('direct_jump_tester', RLTK::CG::NativeIntType, []) do |fun|
+			entry = blocks.append
+			
+			bb0 = blocks.append { ret(RLTK::CG::NativeInt.new(1)) }
+			bb1 = blocks.append { ret(RLTK::CG::NativeInt.new(0)) }
+			
+			entry.build { br bb1 }
+		end
+		
+		assert_equal(0, @jit.run_function(fun).to_i)
+	end
+	
+	def test_switched_jump
+		fun = @mod.functions.add('direct_jump_tester', RLTK::CG::NativeIntType, []) do |fun|
+			entry = blocks.append
+			
+			bb0 = blocks.append { ret RLTK::CG::NativeInt.new(1) }
+			bb1 = blocks.append { ret RLTK::CG::NativeInt.new(0) }
+			
+			entry.build do
+				switch(RLTK::CG::NativeInt.new(1), bb0, {RLTK::CG::NativeInt.new(1) => bb1})
+			end
+		end
+		
+		assert_equal(0, @jit.run_function(fun).to_i)
+	end
+	
+	##############
+	# Misc Tests #
+	##############
+	
+	def test_select
+		fun = @mod.functions.add('select_tester', RLTK::CG::Int1Type, [RLTK::CG::NativeIntType]) do |fun|
+			blocks.append do
+				ret select(fun.params[0], RLTK::CG::Int1.new(0), RLTK::CG::Int1.new(1))
+			end
+		end
+		
+		assert_equal(0, @jit.run_function(fun, 1).to_i(false))
+		assert_equal(1, @jit.run_function(fun, 0).to_i(false))
+	end
+	
+	#############
+	# Phi Tests #
+	#############
+	
+	def test_phi
+		fun = @mod.functions.add('phi_tester', RLTK::CG::NativeIntType, [RLTK::CG::NativeIntType]) do |fun|
+			entry	= blocks.append('entry')
+			block0	= blocks.append('block0')
+			block1	= blocks.append('block1')
+			exit		= blocks.append('exit')
+		
+			entry.build do
+				cond(icmp(:eq, fun.params[0], RLTK::CG::NativeInt.new(0)), block0, block1)
+			end
+		
+			result0 =
+			block0.build do
+				add(fun.params[0], RLTK::CG::NativeInt.new(1)).tap { br(exit) }
+			end
+		
+			result1 =
+			block1.build do
+				sub(fun.params[0], RLTK::CG::NativeInt.new(1)).tap { br(exit) }
+			end
+		
+			exit.build do
+				ret(phi(RLTK::CG::NativeIntType, {block0 => result0, block1 => result1}))
+			end
+		end
+		
+		assert_equal(1, @jit.run_function(fun, 0).to_i)
+		assert_equal(0, @jit.run_function(fun, 1).to_i)
+	end
+end

data/test/cg/tc_function.rb

@@ -0,0 +1,54 @@
+# 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::Function class.
+
+############
+# Requires #
+############
+
+# Gems
+require 'minitest/autorun'
+
+# Ruby Language Toolkit
+require 'rltk/cg/llvm'
+require 'rltk/cg/module'
+require 'rltk/cg/function'
+require 'rltk/cg/type'
+
+class FunctionTester < Minitest::Test
+	def setup
+		@mod = RLTK::CG::Module.new('Testing Module')
+		@fun = @mod.functions.add('testing_function', RLTK::CG::NativeIntType, [RLTK::CG::NativeIntType, RLTK::CG::NativeIntType])
+		
+		@fun.params[0].name = 'foo'
+		@fun.params[1].name = 'bar'
+	end
+	
+	def test_equality
+		fun0 = @mod.functions.add('fun0', RLTK::CG::NativeIntType, [])
+		fun1 = @mod.functions.add('fun0', RLTK::CG::FloatType, [])
+		fun2 = RLTK::CG::Function.new(fun0.ptr)
+		
+		assert_equal(fun0, fun2)
+		refute_equal(fun0, fun1)
+	end
+	
+	def test_positive_index_in_range
+		assert_equal('foo', @fun.params[0].name)
+		assert_equal('bar', @fun.params[1].name)
+	end
+
+	def test_negative_index_in_range
+		assert_equal('bar', @fun.params[-1].name)
+		assert_equal('foo', @fun.params[-2].name)
+	end
+
+	def test_positive_index_out_of_range
+		assert_nil(@fun.params[2])
+	end
+
+	def test_negative_index_out_of_range
+		assert_nil(@fun.params[-3])
+	end
+end

data/test/cg/tc_generic_value.rb

@@ -0,0 +1,33 @@
+# 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::GenericValue
+#			class.
+
+############
+# Requires #
+############
+
+# Gems
+require 'minitest/autorun'
+
+# Ruby Language Toolkit
+require 'rltk/cg/generic_value'
+
+class GenericValueTester < Minitest::Test
+	def setup
+		RLTK::CG::LLVM.init(:X86)
+	end
+	
+	def test_integer
+		assert_equal(2, RLTK::CG::GenericValue.new(2).to_i)
+	end
+	
+	def test_float
+		assert_in_delta(3.1415926, RLTK::CG::GenericValue.new(3.1415926).to_f, 1e-6)
+	end
+	
+	def test_double
+		assert_in_delta(3.1415926, RLTK::CG::GenericValue.new(3.1415926, RLTK::CG::DoubleType).to_f(RLTK::CG::DoubleType), 1e-6)
+	end
+end

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