rltk 3.0.0 → 3.0.1

data/lib/rltk/cg/pass_manager.rb

@@ -15,15 +15,15 @@ require 'rltk/cg/bindings'
 #######################
 
 module RLTK::CG
-	
+
 	# A PassManager is responsible for scheduling and running optimization
 	# passes on modules.
 	class PassManager
 		include BindingClass
-		
+
 		# The Proc object called by the garbage collector to free resources used by LLVM.
 		CLASS_FINALIZER = Proc.new { |id| Bindings.dispose_pass_manager(ptr) if ptr = ObjectSpace._id2ref(id).ptr }
-		
+
 		# A list of passes that are available to be added to the pass
 		# manager via the {PassManager#add} method.
 		PASSES = {
@@ -75,7 +75,7 @@ module RLTK::CG
 			:TBAA               => :type_based_alias_analysis,
 			:Verifier           => :verifier
 		}
-		
+
 		# Create a new pass manager.  You should never have to do this as
 		# {Module Modules} should create PassManagers for you whenever they
 		# are requested.
@@ -87,18 +87,18 @@ module RLTK::CG
 			# LLVM Initialization
 			@ptr = Bindings.create_pass_manager
 			@mod = mod
-			
+
 			# Set the target data if the module is associated with a execution engine.
 			self.target_data = mod.engine.target_data if mod.engine
-			
+
 			# RLTK Initialization
 			@enabled = Array.new
-			
+
 			# Define a finalizer to free the memory used by LLVM for this
 			# pass manager.
 			ObjectSpace.define_finalizer(self, CLASS_FINALIZER)
 		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)
@@ -112,47 +112,47 @@ module RLTK::CG
 		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
-		
+
 		# Set the target data for this pass manager.
 		#
 		# @param [TargetData] data
@@ -161,13 +161,13 @@ module RLTK::CG
 		def target_data=(data)
 			Bindings.add_target_data(check_type(data, TargetData, 'data'), @ptr)
 		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
@@ -181,16 +181,16 @@ module RLTK::CG
 		def initialize(mod)
 			# LLVM Initialization
 			@ptr = Bindings.create_function_pass_manager_for_module(mod)
-			
+
 			# Set the target data if the module is associated with a execution engine.
 			self.target_data = mod.engine.target_data if mod.engine
-			
+
 			Bindings.initialize_function_pass_manager(@ptr)
-			
+
 			# RLTK Initialization
 			@enabled = Array.new
 		end
-		
+
 		# Run the enabled passes on the given function inside the execution
 		# engine's module.
 		#
@@ -200,7 +200,7 @@ module RLTK::CG
 		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.
@@ -210,7 +210,7 @@ module RLTK::CG
 			Bindings.finalize_function_pass_manager(@ptr).to_bool
 		end
 	end
-	
+
 	PASS_GROUPS = [
 		:analysis,
 		:core,
@@ -224,29 +224,29 @@ module RLTK::CG
 		:transform_utils,
 		:vectorization
 	]
-	
+
 	class PassRegistry
 		include BindingClass
-		
+
 		def self.global
 			PassRegistry.allocate.tap { |pr| pr.ptr = Bindings.get_global_pass_registry }
 		end
-		
+
 		def initialize
 			@ptr = Bindings::OpaquePassRegistry.new
 		end
-		
+
 		def init(pass_group = :all)
 			if pass_group == :all
 				PASS_GROUPS.each { |pg| Bindings.send("initialize_#{pg}", @ptr) }
-				
+
 			elsif PASS_GROUPS.include?(pass_group)
 				Bindings.send("initialize_#{pass_group}", @ptr)
 			end
 		end
-		
+
 		def init(pass_group)
-			
+
 		end
 	end
 end

data/lib/rltk/cg/target.rb

@@ -20,100 +20,100 @@ module RLTK::CG
 	# Class binding for the LLVM Triple class.
 	class Target
 		include BindingClass
-		
+
 		#################
 		# Class Methods #
 		#################
-		
+
 		# @return [Target]  First target in the target list
 		def self.first
 			@first ||= self.new(Bindings.get_first_target)
 		end
-		
+
 		# @return [Target] Target object for the host architecture.
 		def self.host
 			@host ||= self.new(Triple.host)
 		end
-		
+
 		# @return [Target]  Next target in the target list
 		def self.next_target(target)
 			self.new(Bindings.get_next_target(target))
 		end
-		
+
 		####################
 		# Instance Methods #
 		####################
-		
+
 		# Create an object representing a particular code generation target.
 		# You can create a target either from a string or a Triple.
 		#
 		# @param [Triple, String] overloaded Object describing the target.
 		def initialize(overloaded)
-			@ptr, @triple = 
+			@ptr, @triple =
 			case overloaded
 			when String
 				[Bindings.get_target_from_name(overloaded), Triple.new(overloaded)]
-				
+
 			when RLTK::CG::Triple
 				ptr    = FFI::MemoryPointer.new(:pointer)
 				error  = FFI::MemoryPointer.new(:pointer)
 				status = Bindings.get_target_from_triple(overloaded.to_s, ptr, error)
-				
+
 				if status.zero?
 					[ptr, overloaded]
-				
+
 				else
 					errorp  = error.read_pointer
 					message = errorp.null? ? 'Unknown' : errorp.read_string
-		
+
 					error.autorelease = false
-		
+
 					Bindings.dispose_message(error)
-		
+
 					raise "Error creating target: #{message}"
 				end
-				
+
 			when RLTK::CG::Bindings::Triple
 				[overloaded, nil]
 			end
 		end
-		
+
 		# @return [Boolean]  Whether or not the target has an ASM backend
 		def asm_backend?
 			Bindings.target_has_asm_backend(@ptr).to_bool
 		end
-		
+
 		# @return [Boolean]  Whether or not the target has a JIT
 		def jit?
 			Bindings.target_has_jit(@ptr).to_bool
 		end
-		
+
 		# @return [Boolean]  Whether or not the target has a TargetMachine
 		def target_machine?
 			Bindings.target_has_target_machine(@ptr).to_bool
 		end
-		
+
 		# @return [String]  Description of the target
 		def describe
 			Bindings.get_target_description(@ptr)
 		end
-		
+
 		# @return [Triple]  Triple object for this target
 		def triple
 			@triple ||= Triple.new(Bindings.get_target_name(@ptr))
 		end
 	end
-	
+
 	# This class represents data about a specific architecture.  Currently it
 	# is for internal use only and should not be instantiated by users.
 	class TargetData
 		include BindingClass
-		
+
 		# @param [FFI::Pointer] ptr
 		def initialize(ptr)
 			@ptr = ptr
 		end
-		
+
 		# Gets the pointer size for this target machine and address space
 		# combination.
 		#
@@ -124,20 +124,20 @@ module RLTK::CG
 			Bindings.pointer_size_for_as(@ptr, as)
 		end
 	end
-	
+
 	# This class represents a specific architecture that wil be targeted by
 	# LLVM's compilation process.
 	class TargetMachine
 		include BindingClass
-		
+
 		# The Proc object called by the garbage collector to free resources used by LLVM.
 		CLASS_FINALIZER = Proc.new { |id| Bindings.dispose_target_machine(ptr) if ptr = ObjectSpace._id2ref(id).ptr }
-		
+
 		# @return [TargetMachine] TargetMachine representation of the host machine.
 		def self.host
 			@host ||= self.new(Target.host)
 		end
-		
+
 		# Create a new object describing a target machine.
 		#
 		# @see Bindings._enum_reloc_model_
@@ -152,24 +152,24 @@ module RLTK::CG
 		def initialize(target, mcpu = '', features = '', opt_level = :none, reloc_mode = :default, code_model = :default)
 			# Convert the features parameter if necessary.
 			features = TargetMachine.build_feature_string(features) if features.is_a?(Array)
-			
+
 			@ptr = Bindings.create_target_machine(target, target.triple.to_s, mcpu, features, opt_level, reloc_mode, code_model)
-			
+
 			# Define a finalizer to free the memory used by LLVM for
 			# this target machine.
 			ObjectSpace.define_finalizer(self, CLASS_FINALIZER)
 		end
-		
+
 		# @return [String]  Name of the target machine's CPU
 		def cpu
 			Bindings.get_target_machine_cpu(@ptr)
 		end
-		
+
 		# @return [TargetData]
 		def data
 			TargetData.new(Bindings.get_target_machine_data(@pt))
 		end
-		
+
 		# Emit assembly or object code for the given module to the file
 		# specified.
 		#
@@ -183,34 +183,34 @@ module RLTK::CG
 		def emit_module(mod, file_name, emit_type)
 			error  = FFI::MemoryPointer.new(:pointer)
 			status = Bindings.target_machine_emit_to_file(@ptr, mod, file_name, emit_type, error)
-			
+
 			if not status.zero?
 				errorp  = error.read_pointer
 				message = errorp.null? ? 'Unknown' : errorp.read_string
-	
+
 				error.autorelease = false
-	
+
 				Bindings.dispose_message(error)
-	
+
 				raise "Error emiting code for module: #{message}"
 			end
 		end
-		
+
 		# @return [String]  Feature string for this target machine
 		def feature_string
 			Bindings.get_target_machine_feature_string(@ptr)
 		end
-		
+
 		# @return [Target]
 		def target
 			Target.new(Bindings.get_target_machine_target(@ptr))
 		end
-		
+
 		# @return [Triple]
 		def triple
 			Triple.new(Bindings.get_target_machine_triple(@ptr))
 		end
-		
+
 		# Set verbose ASM property.
 		#
 		# @param [Boolean]  bool  Verbose ASM or not
@@ -218,10 +218,10 @@ module RLTK::CG
 		# @return [void]
 		def verbose_asm=(bool)
 			@verbose_asm = bool
-			
+
 			Bindings.set_target_machine_asm_verbosity(@ptr, bool.to_i)
 		end
-		
+
 		# @return [Boolean]  If this target machine should print verbose ASM
 		def verbose_asm?
 			@verbose_asm ||= false

data/lib/rltk/cg/triple.rb

@@ -19,37 +19,37 @@ module RLTK::CG
 	# Class binding for the LLVM Triple class.
 	class Triple
 		include BindingClass
-		
+
 		#################
 		# Class Methods #
 		#################
-		
+
 		# @return [Triple] Object representing the host architecture, vendor, OS, and environment.
 		def self.host
 			@host ||= Triple.new(host_string)
 		end
-	
+
 		# @return [String] String representation of the host architecture, vendor, OS, and environment.
 		def self.host_string
 			@host_string ||= Bindings.get_default_target_triple
 		end
-		
+
 		####################
 		# Instance Methods #
 		####################
-		
+
 		# Create a new triple describing the host architecture, vendor, OS,
 		# and (optionally) environment.
 		#
 		# @param [FFI::Pointer, String] overloaded
 		def initialize(overloaded)
-			@ptr, @str = 
+			@ptr, @str =
 			case overloaded
 			when FFI::Pointer then [overloaded, nil]
 			when String       then [Bindings.triple_create(overloaded), overloaded]
 			end
 		end
-		
+
 		# @return [String] String representation of this triple.
 		def to_s
 			@str ||= Bindings.get_triple_string(@ptr)