rltk 1.2.0 → 2.0.0

data/lib/rltk/cg/memory_buffer.rb

@@ -0,0 +1,62 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Ruby Language Toolkit
+# Date:		2012/04/16
+# Description:	This file defines the MemoryBuffer class.
+
+############
+# Requires #
+############
+
+# Ruby Language Toolkit
+require 'rltk/cg/bindings'
+
+#######################
+# Classes and Modules #
+#######################
+
+module RLTK::CG # :nodoc:
+
+	# This class is used by the {Module} class to dump and load LLVM bitcode.
+	class MemoryBuffer
+		include BindingClass
+		
+		# Create a new memory buffer.
+		#
+		# @param [FFI::Pointer, String, nil] overloaded This parameter may be either a pointer to an existing memory
+		#   buffer, the name of a file containing LLVM bitcode, or nil.  If it is nil the memory buffer will read
+		#   from standard in.
+		def initialize(overloaded = nil)
+			@ptr =
+			case overloaded
+			when FFI::Pointer
+				overloaded
+			else
+				buf_ptr = FFI::MemoryPointer.new(:pointer)
+				msg_ptr = FFI::MemoryPointer.new(:pointer)
+				
+				status =
+				case overloaded
+				when String
+					Bindings.create_memory_buffer_with_contents_of_file(overloaded, buf_ptr, msg_ptr)
+				else
+					Bindings.create_memory_buffer_with_stdin(buf_ptr, msg_ptr)
+				end
+				
+				raise msg_ptr.get_pointer(0).get_string(0) if status != 0
+				
+				buf_ptr.get_pointer(0)
+			end
+		end
+		
+		# Frees the resources used by LLVM for this memory buffer.
+		#
+		# @return [void]
+		def dispose
+			if @ptr
+				Bindings.dispose_memory_buffer(@ptr)
+				
+				@ptr = nil
+			end
+		end
+	end
+end

data/lib/rltk/cg/module.rb

@@ -0,0 +1,328 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Ruby Language Toolkit
+# Date:		2012/03/20
+# Description:	This file defines the Module class.
+
+############
+# Requires #
+############
+
+# Ruby Language Toolkit
+require 'rltk/cg/bindings'
+require 'rltk/cg/context'
+
+#######################
+# Classes and Modules #
+#######################
+
+module RLTK::CG # :nodoc:
+	
+	# This class represents a collection of functions, constants, and global
+	# variables.
+	class Module
+		include BindingClass
+		
+		# Load a module from LLVM bitcode.
+		#
+		# @see MemoryBuffer#initialize
+		#
+		# @param [MemoryBuffer, FFI::Pointer, String, nil] overloaded Where to read the bytecode from.
+		#
+		# @return [Module]
+		def self.read_bitcode(overloaded)
+			buffer = if overloaded.is_a?(MemoryBuffer) then overloaded else MemoryBuffer.new(overloaded) end
+			
+			mod_ptr = FFI::MemoryPointer.new(:pointer)
+			msg_ptr = FFI::MemoryPointer.new(:pointer)
+			
+			status = Bindings.parse_bitcode(buffer, mod_ptr, msg_ptr)
+			
+			if status != 0
+				raise msg_ptr.get_pointer(0).get_string(0)
+			else
+				Module.new(mod_ptr.get_pointer(0))
+			end
+		end
+		
+		# Create a new LLVM module.
+		#
+		# @param [FFI::Pointer, String]	overloaded	Pointer to existing module or name of new module. 
+		# @param [Context, nil]			context		Optional context in which to create the module.
+		# @param [Proc]				block		Block to be executed inside the context of the module.
+		def initialize(overloaded, context = nil, &block)
+			@ptr =
+			case overloaded
+			when FFI::Pointer
+				overloaded
+				
+			when String
+				if context
+					Bindings.module_create_with_name_in_context(overloaded, check_type(context, Context, 'context'))
+				else
+					Bindings.module_create_with_name(overloaded)
+				end
+			end
+			
+			self.instance_exec(&block) if block
+		end
+		
+		# @return [Context] Context in which this module exists.
+		def context
+			Context.new(Bindings.get_module_context(@ptr))
+		end
+		
+		# Frees the resources used by LLVM for this module.
+		#
+		# @return [void]
+		def dispose
+			if @ptr
+				Bindings.dispose_module(@ptr)
+				
+				@ptr = nil
+			end
+		end
+		
+		# Print the IR of this module to standard out.
+		#
+		# @return [void]
+		def dump
+			Bindings.dump_module(@ptr)
+		end
+		
+		# @return [FunctionCollection] Proxy object for inspecting this module's functions.
+		def functions
+			@functions ||= FunctionCollection.new(self)
+		end
+		alias :funs :functions
+		
+		# @return [GlobalCollection] Proxy object for inspecting this module's global values and variables.
+		def globals
+			@globals ||= GlobalCollection.new(self)
+		end
+		
+		# Write the module as LLVM bitcode to a file.
+		#
+		# @param [#path, #fileno, Integer, String] overloaded Where to write the bitcode.
+		#
+		# @return [Boolean] If the write was successful.
+		def write_bitcode(overloaded)
+			0 ==
+			if overloaded.respond_to?(:path)
+				Bindings.write_bitcode_to_file(@ptr, overloaded.path)
+				
+			elsif overloaded.respond_to?(:fileno)
+				Bindings.write_bitcode_to_fd(@ptr, overloaded.fileno, 0, 1)
+				
+			elsif overloaded.is_a?(Integer)
+				Bindings.write_bitcode_to_fd(@ptr, overloaded, 0, 1)
+				
+			elsif overloaded.is_a?(String)
+				Bindings.write_bitcode_to_file(@ptr, overloaded)
+			end
+		end
+		
+		# Verify that the module is valid LLVM IR.
+		#
+		# @return [nil, String] Human-readable description of any invalid constructs if invalid.
+		def verify
+			do_verification(:return_status)
+		end
+		
+		# Verify that a module is valid LLVM IR and abort the process if it isn't.
+		#
+		# @return [nil]
+		def verify!
+			do_verification(:abort_process)
+		end
+		
+		# Helper function for {#verify} and {#verify!}
+		def do_verification(action)
+			str_ptr	= FFI::MemoryPointer.new(:pointer)
+			status	= Bindings.verify_module(@ptr, action, str_ptr)
+			
+			returning(status == 1 ? str_ptr.read_string : nil) { Bindings.dispose_message(str_ptr.read_pointer) }
+		end
+		private :do_verification
+		
+		# This class is used to access a module's {Function Functions}.
+		class FunctionCollection
+			include Enumerable
+			
+			# @param [Module] mod Module for which this is a proxy.
+			def initialize(mod)
+				@module = mod
+			end
+			
+			# Retreive a Function object.
+			#
+			# @param [String, Symbol, Integer] key Function identifier.  Either the name of the function or its index.
+			#
+			# @return [Function]
+			def [](key)
+				case key
+				when String, Symbol
+					self.named(key)
+					
+				when Integer
+					(1...key).inject(self.first) { |fun| if fun then self.next(fun) else break end }
+				end
+			end
+			
+			# Add a Function to this module.
+			#
+			# @param [String]							name		Name of the module in LLVM IR.
+			# @param [FunctionType, Array(Type, Array<Type>)]	type_info	FunctionType or Values that will be passed to {FunctionType#initialize}.
+			# @param [Proc]							block	Block to be executed inside the context of the function.
+			#
+			# @return [Function]
+			def add(name, *type_info, &block)
+				Function.new(@module, name, *type_info, &block)
+			end
+			
+			# Remove a function from the module.
+			#
+			# @param [Function] fun Function to remove.
+			#
+			# @return [void]
+			def delete(fun)
+				Bindings.delete_function(fun)
+			end
+			
+			# An iterator for each function inside this collection.
+			#
+			# @yieldparam fun [Function]
+			#
+			# @return [Enumerator] Returns an Enumerator if no block is given.
+			def each
+				return to_enum(:each) unless block_given?
+				
+				fun = self.first
+				
+				while fun
+					yield fun
+					fun = self.next(fun)
+				end
+			end
+			
+			# @return [Function, nil] The module's first function if one has been added.
+			def first
+				if (ptr = Bindings.get_first_function(@module)).null? then nil else Function.new(ptr) end
+			end
+			
+			# @return [Function, nil] The module's last function if one has been added.
+			def last
+				if (ptr = Bindings.get_last_function(@module)).null? then nil else Function.new(ptr) end
+			end
+			
+			# @param [String, Symbol] name Name of the desired function.
+			#
+			# @return [Function, nil] The function with the given name.
+			def named(name)
+				if (ptr = Bindings.get_named_function(@module, name)).null? then nil else Function.new(ptr) end
+			end
+			
+			# @param [Function] fun Function you want the successor for.
+			#
+			# @return [Function, nil] Next function in the collection.
+			def next(fun)
+				if (ptr = Bindings.get_next_function(fun)).null? then nil else Function.new(ptr) end
+			end
+			
+			# @param [Function] fun Function you want the predecessor for.
+			#
+			# @return [Function, nil] Previous function in the collection.
+			def previous(fun)
+				if (ptr = Bindings.get_previous_function(fun)).null? then nil else Function.new(ptr) end
+			end
+		end
+		
+		# This class is used to access a module's global variables.
+		class GlobalCollection
+			include Enumerable
+			
+			# @param [Module] mod Module for which this is a proxy.
+			def initialize(mod)
+				@module = mod
+			end
+			
+			# Retreive a GlobalVariable object.
+			#
+			# @param [String, Symbol, Integer] key Global variable identifier.  Either the name of the variable or its index.
+			#
+			# @return [GlobalVariable]
+			def [](key)
+				case key
+				when String, Symbol
+					self.named(key)
+					
+				when Integer
+					(1...key).inject(self.first) { |global| if global then self.next(global) else break end }
+				end
+			end
+			
+			# Add a global variable to a module.
+			#
+			# @param [Type]	type	Type of the global variable.
+			# @param [String]	name	Name of the global variable in LLVM IR.
+			def add(type, name)
+				GlobalVariable.new(Bindings.add_global(@module, type, name))
+			end
+			
+			# Remove a global variable from the module.
+			#
+			# @param [GlobalVariable] global Global variable to remove.
+			#
+			# @return [void]
+			def delete(global)
+				Bindings.delete_global(global)
+			end
+			
+			# An iterator for each global variable inside this collection.
+			#
+			# @yieldparam fun [GlobalVariable]
+			#
+			# @return [Enumerator] Returns an Enumerator if no block is given.
+			def each
+				return to_enum(:each) unless block_given?
+				
+				global = self.first
+				
+				while global
+					yield global
+					global = self.next(global)
+				end
+			end
+			
+			# @return [GlobalVariable, nil] The module's first global variable if one has been added.
+			def first
+				if (ptr = Bindings.get_first_global(@module)).null? then nil else GlobalValue.new(ptr) end
+			end
+			
+			# @return [GlobalVariable, nil] The module's last global variable if one has been added.
+			def last
+				if (ptr = Bindings.get_last_global(@module)).null? then nil else GlobalValue.new(ptr) end
+			end
+			
+			# @param [String, Symbol] name Name of the desired global variable.
+			#
+			# @return [GlobalVariable, nil] The global variable with the given name.
+			def named(name)
+				if (ptr = Bindings.get_named_global(@module, name)).null? then nil else GlobalValue.new(ptr) end
+			end
+			
+			# @param [GlobalVariable] global Global variable you want the successor for.
+			#
+			# @return [GlobalVariable, nil] global Next global variable in the collection.
+			def next(global)
+				if (ptr = Bindings.get_next_global(global)).null? then nil else GlobalValue.new(ptr) end
+			end
+			
+			# @param [GlobalVariable] global Global variable you want the predecessor for.
+			#
+			# @return [GlobalVariable, nil] Previous global variable in the collection.
+			def previous(global)
+				if (ptr = Bindings.get_previous_global(global)).null? then nil else GlobalValue.new(ptr) end
+			end
+		end
+	end
+end

data/lib/rltk/cg/pass_manager.rb

@@ -0,0 +1,201 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Ruby Language Toolkit
+# Date:		2012/03/15
+# Description:	This file defines the PassManager class.
+
+############
+# Requires #
+############
+
+# Ruby Language Toolkit
+require 'rltk/cg/bindings'
+
+#######################
+# Classes and Modules #
+#######################
+
+module RLTK::CG # :nodoc:
+	
+	# A PassManager is responsible for scheduling and running optimization
+	# passes on modules.
+	class PassManager
+		include BindingClass
+		
+		# A list of passes that are available to be added to the pass
+		# manager via the {PassManager#add} method.
+		PASSES = {
+			:ADCE			=> :agressive_dce,
+			:AlwaysInline		=> :always_inliner,
+			:ArgPromote		=> :argument_promotion,
+			:BasicAliasAnalysis	=> :basic_alias_analysis,
+			:CFGSimplify		=> :cfg_simplification,
+			:ConstMerge		=> :constant_merge,
+			:ConstProp		=> :constant_propagation,
+			:CorValProp		=> :correlated_value_propagation,
+			:DAE				=> :dead_arg_elimination,
+			:DSE				=> :dead_store_elimination,
+			:DemoteMemToReg	=> :demote_memory_to_register,
+			:EarlyCSE			=> :early_cse,
+			:FunctionAttrs		=> :function_attrs,
+			:FunctionInline	=> :function_inlining,
+			:GDCE			=> :global_dce,
+			:GlobalOpt		=> :global_optimizer,
+			:GVN				=> :gvn,
+			:Internalize		=> :internalize,
+			:IndVarSimplify	=> :ind_var_simplify,
+			:InstCombine		=> :instruction_combining,
+			:IPConstProp		=> :ip_constant_propagation,
+			:IPSCCP			=> :ipsccp,
+			:JumpThreading		=> :jump_threading,
+			:LICM			=> :licm,
+			:LoopDeletion		=> :loop_deletion,
+			:LoopIdiom		=> :loop_idiom,
+			:LoopRotate		=> :loop_rotate,
+			:LoopUnroll		=> :loop_unroll,
+			:LoopUnswitch		=> :loop_unswitch,
+			:LEI				=> :lower_expect_intrinsics,
+			:MemCopyOpt		=> :mem_cpy_opt,
+			:PromoteMemToReg	=> :promote_memory_to_register,
+			:PruneEH			=> :prune_eh,
+			:Reassociate		=> :reassociate,
+			:SCCP			=> :sccp,
+			:ScalarRepl		=> :scalar_repl_aggregates,
+			:SimplifyLibCalls	=> :simplify_lib_calls,
+			:StripDeadProtos	=> :strip_dead_prototypes,
+			:StripSymbols		=> :strip_symbols,
+			:TailCallElim		=> :tail_call_elimination,
+			:TBAA			=> :type_based_alias_analysis,
+			:Verifier			=> :verifier
+		}
+		
+		# Creat a new pass manager.  You should never have to do this as
+		# {ExecutionEngine ExecutionEngines} creates a PassManager whenever
+		# one is requested.
+		#
+		# @param [ExecutionEngine]	engine	ExecutionEngine this pass manager belongs to.
+		# @param [Module]			mod		Module this pass manager belongs to.
+		def initialize(engine, mod)
+			# LLVM Initialization
+			@ptr = Bindings.create_pass_manager
+			@mod = mod
+			
+			Bindings.add_target_data(Bindings.get_execution_engine_target_data(engine), @ptr)
+			
+			# RLTK Initialization
+			@enabled = Array.new
+		end
+		
+		# Frees the resources used by LLVM for this pass manager.
+		#
+		# @return [void]
+		def dispose
+			if @ptr
+				self.finalize
+				
+				Bindings.dispose_pass_manager(@ptr)
+				
+				@ptr = nil
+			end
+		end
+		
+		# Add a pass or passes to this pass manager.  Passes may either be
+		# specified via the keys for the PASSES hash or any string that will
+		# be turned into a string (via the {Bindings.get_bname} method)
+		# appearing as a value of the PASSES hash.
+		#
+		# @see PASSES
+		#
+		# @param [Array<Symbol>] names Passes to add to the pass manager.
+		#
+		# @return [PassManager] self
+		def add(*names)
+			names.each do |name|
+				name = name.to_sym
+				
+				if PASSES.has_key?(name)
+					next if @enabled.include?(name)
+				
+					Bindings.send("add_#{PASSES[name]}_pass", @ptr)
+				
+					@enabled << name
+				
+				elsif PASSES.has_value?(bname = Bindings.get_bname(name))
+					next if @enabled.include?(PASSES.key(bname))
+				
+					Bindings.send("add_#{bname}_pass", @ptr)
+				
+					@enabled << PASSES.key(bname)
+				
+				else
+					raise "Unknown pass: #{name}"
+				end
+			end
+			
+			self
+		end
+		alias :<< :add
+		
+		# @return [Array<Symbol>] List of passes that have been enabled.
+		def enabled
+			@enabled.clone
+		end
+		
+		# @return [Boolean] Weather the pass has been enabled or not.
+		def enabled?(name)
+			@enabled.include?(name) or @enabled.include?(PASSES.key(Bindings.get_bname(name)))
+		end
+		
+		# Run the enabled passes on the execution engine's module.
+		#
+		# @return [void]
+		def run
+			Bindings.run_pass_manager(@ptr, @mod).to_bool
+		end
+		
+		protected
+		# Empty method used by {FunctionPassManager} to clean up resources.
+		def finalize
+		end
+	end
+	
+	# A FunctionPassManager is responsible for scheduling and running optimization
+	# passes on individual functions inside the context of a module.
+	class FunctionPassManager < PassManager
+		# Creat a new function pass manager.  You should never have to do
+		# this as {ExecutionEngine ExecutionEngines} creates a
+		# FunctionPassManager whenever one is requested.
+		#
+		# @param [ExecutionEngine]	engine	ExecutionEngine this pass manager belongs to.
+		# @param [Module]			mod		Module this pass manager belongs to.
+		def initialize(engine, mod)
+			# LLVM Initialization
+			@ptr = Bindings.create_function_pass_manager_for_module(mod)
+			
+			Bindings.add_target_data(Bindings.get_execution_engine_target_data(engine), @ptr)
+			
+			Bindings.initialize_function_pass_manager(@ptr).to_bool
+			
+			# RLTK Initialization
+			@enabled = Array.new
+		end
+		
+		# Run the enabled passes on the given function inside the execution
+		# engine's module.
+		#
+		# @param [Function] fun Function to optimize.
+		#
+		# @return [void]
+		def run(fun)
+			Bindings.run_function_pass_manager(@ptr, fun).to_bool
+		end
+		
+		protected
+		# Called by {#dispose} to finalize any operations of the function
+		# pass manager.
+		#
+		# @return [void]
+		def finalize
+			Bindings.finalize_function_pass_manager(@ptr).to_bool
+		end
+	end
+end

data/lib/rltk/cg/support.rb

@@ -0,0 +1,29 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Ruby Language Toolkit
+# Date:		2012/03/15
+# Description:	This file defines the Support module.
+
+############
+# Requires #
+############
+
+# Ruby Language Toolkit
+require 'rltk/cg/bindings'
+
+#######################
+# Classes and Modules #
+#######################
+
+module RLTK::CG # :nodoc:
+
+	# Support functionality for LLVM code generation.
+	module Support
+		# Load a shared library into memory and make its exported symbols
+		# available to execution engines.
+		#
+		# @param [String] lib Path to the shared library to load.
+		def self.load_library(lib)
+			Bindings.load_library_permanently(lib).to_bool
+		end
+	end
+end