rltk3 3.0.2

data/lib/rltk/cg/pass_manager.rb

@@ -0,0 +1,252 @@
+# 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
+
+	# 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 = {
+			:ADCE               => :aggressive_dce,
+			:AlwaysInline       => :always_inliner,
+			:ArgPromote         => :argument_promotion,
+			:BasicAliasAnalysis => :basic_alias_analysis,
+			:BBVectorize        => :bb_vectorize,
+			: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,
+			:LoopReroll         => :loop_reroll,
+			:LoopRotate         => :loop_rotate,
+			:LoopUnroll         => :loop_unroll,
+			:LoopUnswitch       => :loop_unswitch,
+			:LoopVectorize      => :loop_vectorize,
+			:LEI                => :lower_expect_intrinsics,
+			:MemCopyOpt         => :mem_cpy_opt,
+			:PILC               => :partially_inline_lib_calls,
+			:PromoteMemToReg    => :promote_memory_to_register,
+			:PruneEH            => :prune_eh,
+			:Reassociate        => :reassociate,
+			:SCCP               => :sccp,
+			:ScalarRepl         => :scalar_repl_aggregates,
+			:SimplifyLibCalls   => :simplify_lib_calls,
+			:SLPVectorize       => :slp_vectorize,
+			:StripDeadProtos    => :strip_dead_prototypes,
+			:StripSymbols       => :strip_symbols,
+			:TailCallElim       => :tail_call_elimination,
+			: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.
+		#
+		# @see Module#pass_manager
+		#
+		# @param [Module] mod Module this pass manager belongs to.
+		def initialize(mod)
+			# 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)
+		# 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
+
+		# Set the target data for this pass manager.
+		#
+		# @param [TargetData] data
+		#
+		# @return [void]
+		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
+		# Create a new function pass manager.  You should never have to do
+		# this as {Module Modules} should create FunctionPassManagers for you
+		# whenever they are requested.
+		#
+		# @see Module#function_pass_manager
+		#
+		# @param [Module] mod Module this pass manager belongs to.
+		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.
+		#
+		# @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
+
+	PASS_GROUPS = [
+		:analysis,
+		:core,
+		:inst_combine,
+		:instrumentation,
+		:ipa,
+		:ipo,
+		:objc_arc_opts,
+		:scalar_opts,
+		:target,
+		: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/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
+
+	# 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

data/lib/rltk/cg/target.rb

@@ -0,0 +1,230 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Ruby Language Toolkit
+# Date:		2012/06/13
+# Description:	This file defines the Target class.
+
+############
+# Requires #
+############
+
+# Ruby Language Toolkit
+require 'rltk/cg/bindings'
+require 'rltk/cg/triple'
+
+#######################
+# Classes and Modules #
+#######################
+
+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 =
+			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.
+		#
+		# @param [Integer]  as  Address space
+		#
+		# @return [Integer]  Size of pointer
+		def pointer_size(as)
+			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_
+		# @see Bindings._enum_code_model_
+		#
+		# @param [Target]                                 target       Target description
+		# @param [String]                                 mcpu         Specific CPU type to target
+		# @param [Array<String>, String]                  features     Features present for this target machine
+		# @param [Symbol from _enum_code_gen_opt_level_]  opt_level    Optimization level
+		# @param [Symbol from _enum_reloc_mode_]          reloc_mode  Code relocation model
+		# @param [Symbol from _enum_code_model_]          code_model   Code generation model
+		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.
+		#
+		# @param [Module]              mod        Module to emit code for
+		# @param [String]              file_name  File to emit code to
+		# @param [:assembly, :object]  emit_type  Type of code to emit
+		#
+		# @return [void]
+		#
+		# @raise LLVM error message if unable to emite code for module
+		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
+		#
+		# @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
+		end
+	end
+end

data/lib/rltk/cg/triple.rb

@@ -0,0 +1,58 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Ruby Language Toolkit
+# Date:		2012/06/13
+# Description:	This file defines the Triple class.
+
+############
+# Requires #
+############
+
+# Ruby Language Toolkit
+require 'rltk/cg/bindings'
+
+#######################
+# Classes and Modules #
+#######################
+
+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 =
+			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)
+		end
+	end
+end