rltk 2.2.1 → 3.0.0

data/lib/rltk/cg/pass_manager.rb

@@ -14,7 +14,7 @@ require 'rltk/cg/bindings'
 # Classes and Modules #
 #######################
 
-module RLTK::CG # :nodoc:
+module RLTK::CG
 	
 	# A PassManager is responsible for scheduling and running optimization
 	# passes on modules.
@@ -27,48 +27,53 @@ module RLTK::CG # :nodoc:
 		# 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
+			: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
@@ -205,4 +210,43 @@ module RLTK::CG # :nodoc:
 			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

@@ -14,16 +14,14 @@ require 'rltk/cg/bindings'
 # Classes and Modules #
 #######################
 
-module RLTK::CG # :nodoc:
+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.
 		#
-		# @LLVMECB
-		#
-		# @param [String] lib Path to the shared library to load.
+		# @param [String]  lib  Path to the shared library to load
 		def self.load_library(lib)
 			Bindings.load_library_permanently(lib).to_bool
 		end

data/lib/rltk/cg/target.rb

@@ -15,20 +15,35 @@ require 'rltk/cg/triple'
 # Classes and Modules #
 #######################
 
-module RLTK::CG # :nodoc:
+module RLTK::CG
 
 	# Class binding for the LLVM Triple class.
 	class Target
 		include BindingClass
 		
-		# @return [Triple] Triple object for this target.
-		attr_reader :triple
+		#################
+		# 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.
 		#
@@ -36,10 +51,57 @@ module RLTK::CG # :nodoc:
 		def initialize(overloaded)
 			@ptr, @triple = 
 			case overloaded
-			when String	then [Bindings.get_target_from_string(overloaded), Triple.new(overloaded)]
-			when Triple	then [Bindings.get_target_from_triple(overloaded), 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
@@ -51,6 +113,16 @@ module RLTK::CG # :nodoc:
 		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
@@ -58,18 +130,8 @@ module RLTK::CG # :nodoc:
 	class TargetMachine
 		include BindingClass
 		
-		# Convert an array of strings representing features of a target
-		# machine into a single string.
-		#
-		# @param [Array<String>] features Strings representing features of a target machine.
-		#
-		# @return [String] A single string representing all of the given features.
-		def self.build_feature_string(features)
-			strings_ptr = FFI::MemoryPointer.new(:pointer, features.length)
-			strings_ptr.write_array_of_pointer(features.map { |str| FFI::MemoryPointer.from_string(str) })
-			
-			Bindings.build_features_string(strings_ptr, features.length)
-		end
+		# 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
@@ -81,20 +143,88 @@ module RLTK::CG # :nodoc:
 		# @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]				reloc_model	Code relocation model.
-		# @param [Symbol]				code_model	Code generation model.
-		def initialize(target, mcpu = '', features = '', reloc_model = :default, code_model = :default)
-			# Just to make things easier on developers.
-			reloc_model = :default_rmodel if reloc_model == :default
-			code_model  = :default_cmodel if code_model  == :default
-			
+		# @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, reloc_model, code_model)
+			@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

@@ -14,7 +14,7 @@ require 'rltk/cg/bindings'
 # Classes and Modules #
 #######################
 
-module RLTK::CG # :nodoc:
+module RLTK::CG
 
 	# Class binding for the LLVM Triple class.
 	class Triple
@@ -26,12 +26,12 @@ module RLTK::CG # :nodoc:
 		
 		# @return [Triple] Object representing the host architecture, vendor, OS, and environment.
 		def self.host
-			@host ||= self.new(Bindings.get_host_triple)
+			@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_host_triple_string
+			@host_string ||= Bindings.get_default_target_triple
 		end
 		
 		####################
@@ -43,16 +43,16 @@ module RLTK::CG # :nodoc:
 		#
 		# @param [FFI::Pointer, String] overloaded
 		def initialize(overloaded)
-			@ptr = 
+			@ptr, @str = 
 			case overloaded
-			when FFI::Pointer	then overloaded
-			when String		then Bindings.triple_create(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
-			Bindings.get_triple_string(@ptr)
+			@str ||= Bindings.get_triple_string(@ptr)
 		end
 	end
 end

data/lib/rltk/cg/type.rb

@@ -10,8 +10,10 @@
 # Standard Library
 require 'singleton'
 
+# Gems
+require 'filigree/abstract_class'
+
 # Ruby Language Toolkit
-require 'rltk/util/abstract_class'
 require 'rltk/cg/bindings'
 require 'rltk/cg/context'
 	
@@ -19,7 +21,7 @@ require 'rltk/cg/context'
 # Classes and Modules #
 #######################
 
-module RLTK::CG # :nodoc:
+module RLTK::CG
 	
 	# The Type class and its sub-classes are used to describe the size and
 	# structure of various data objects inside LLVM and how different
@@ -29,7 +31,7 @@ module RLTK::CG # :nodoc:
 	# @abstract Root of the type class hierarchy.
 	class Type
 		include BindingClass
-		include AbstractClass
+		include Filigree::AbstractClass
 		
 		# Instantiate a Type object from a pointer.  This function is used
 		# internally, and as a library user you should never have to call it.
@@ -40,6 +42,7 @@ module RLTK::CG # :nodoc:
 		def self.from_ptr(ptr)
 			case Bindings.get_type_kind(ptr)
 			when :array		then ArrayType.new(ptr)
+			when :half          then HalfType.new
 			when :double		then DoubleType.new
 			when :float		then FloatType.new
 			when :function		then FunctionType.new(ptr)
@@ -73,7 +76,7 @@ module RLTK::CG # :nodoc:
 		
 		# @return [NativeInt] Alignment of the type.
 		def allignment
-			Int64.new(Bindings.align_of(@ptr))
+			NativeInt.new(Bindings.align_of(@ptr))
 		end
 		
 		# @return [Context] Context in which this type was created.
@@ -81,6 +84,13 @@ module RLTK::CG # :nodoc:
 			Context.new(Bindings.get_type_context(@ptr))
 		end
 		
+		# Dump a string representation of the type to stdout.
+		#
+		# @return [void]
+		def dump
+			Bindings.dump_type(@ptr)
+		end
+		
 		# @return [Fixnum] Hashed value of the pointer representing this type.
 		def hash
 			@ptr.address.hash
@@ -97,13 +107,18 @@ module RLTK::CG # :nodoc:
 		def size
 			Int64.new(Bindings.size_of(@ptr))
 		end
+		
+		# @return [String]  LLVM IR representation of the type
+		def to_s
+			Bindings.print_type_to_string(@ptr)
+		end
 	end
 	
 	# All types that are used to represent numbers inherit from this class.
 	#
 	# @abstract
 	class NumberType < Type
-		include AbstractClass
+		include Filigree::AbstractClass
 		
 		# @return [Value] The corresponding Value sub-class that is used to represent values of this type.
 		def self.value_class
@@ -126,7 +141,7 @@ module RLTK::CG # :nodoc:
 	#
 	# @abstract
 	class BasicIntType < NumberType
-		include AbstractClass
+		include Filigree::AbstractClass
 		
 		# @return [Integer] Number of bits used to represent an integer type.
 		def width
@@ -165,7 +180,7 @@ module RLTK::CG # :nodoc:
 	#
 	# @abstract
 	class SimpleIntType < BasicIntType
-		include AbstractClass
+		include Filigree::AbstractClass
 		include Singleton
 	end
 	
@@ -173,7 +188,7 @@ module RLTK::CG # :nodoc:
 	#
 	# @abstract
 	class RealType < NumberType
-		include AbstractClass
+		include Filigree::AbstractClass
 		include Singleton
 	end
 	
@@ -181,48 +196,77 @@ module RLTK::CG # :nodoc:
 	#
 	# @abstract
 	class SimpleType < Type
-		include AbstractClass
+		include Filigree::AbstractClass
 		include Singleton
 	end
 	
 	# 1 bit integer type.  Often used to represent Boolean values.
-	class Int1Type		< SimpleIntType; end
+	class Int1Type  < SimpleIntType; end
 	# 8 bit (1 byte) integer type.
-	class Int8Type		< SimpleIntType; end
+	class Int8Type  < SimpleIntType; end
 	# 16 bit (2 byte) integer type.
-	class Int16Type	< SimpleIntType; end
+	class Int16Type < SimpleIntType; end
 	# 32 bit (4 byte) integer type.
-	class Int32Type	< SimpleIntType; end
+	class Int32Type < SimpleIntType; end
 	# 64 bit (8 byte) integer type.
-	class Int64Type	< SimpleIntType; end
+	class Int64Type < SimpleIntType; end
+	
+	# Integer the same size as a native pointer.
+	class IntPtr < SimpleIntType
+		# Create an integer that is the same size as a pointer on the target
+		# machine.  Additionally, an address space and a context may be
+		# provided.
+		#
+		# @param [TargetData]  target_data  Data on compilation target
+		# @param [Integer]     addr_space   Target address space
+		# @param [Context]     context      Context in which to get the type
+		def initialize(target_data, addr_space = nil, context = nil)
+			call = 'int_type'
+			args = [target_data]
+			
+			if addr_space
+				call += '_for_as'
+				args << addr_space
+			end
+			
+			if context
+				call += '_in_context'
+				args << context
+			end
+			
+			Bindings.send(call.to_s, *args)
+		end
+	end
 	
 	# The native integer type on the current (not the target) platform.
 	NativeIntType = RLTK::CG.const_get("Int#{FFI.type_size(:int) * 8}Type")
 	
+	# A 16-bit floating point number type.
+	class HalfType     < RealType; end      
 	# A double precision floating point number type.
-	class DoubleType	< RealType; end
+	class DoubleType   < RealType; end
 	# A single precision floating point number type.
-	class FloatType	< RealType; end
+	class FloatType    < RealType; end
 	# A 128 bit (16 byte) floating point number type.
-	class FP128Type	< RealType; end
+	class FP128Type    < RealType; end
 	# A 128 bit (16 byte) floating point number type for the PPC architecture.
-	class PPCFP128Type	< RealType; end
+	class PPCFP128Type < RealType; end
 	# A 80 bit (10 byte) floating point number type for the x86 architecture.
-	class X86FP80Type	< RealType; end
+	class X86FP80Type  < RealType; end
 	
 	# A type for x86 MMX instructions.
-	class X86MMXType	< SimpleType; end
+	class X86MMXType   < SimpleType; end
 	
 	# A type used in representing void pointers and functions that return no values.
-	class VoidType		< SimpleType; end
+	class VoidType     < SimpleType; end
 	# A type used to represent labels in LLVM IR.
-	class LabelType	< SimpleType; end
+	class LabelType    < SimpleType; end
 	
 	# The common ancestor for array, pointer, and struct types.
 	#
 	# @abstract
 	class AggregateType < Type
-		include AbstractClass
+		include Filigree::AbstractClass
 	end
 	
 	# {ArrayType} and {PointerType} inherit from this class so they can share
@@ -230,7 +274,7 @@ module RLTK::CG # :nodoc:
 	#
 	# @abstract
 	class SimpleAggregateType < AggregateType
-		include AbstractClass
+		include Filigree::AbstractClass
 		
 		# Used to initialize {ArrayType ArrayTypes} and {PointerType PointerTypes}.
 		#
@@ -376,7 +420,7 @@ module RLTK::CG # :nodoc:
 				if name
 					@name = check_type(name, String, 'name')
 			
-					returning Bindings.struct_create_named(Context.global, @name) do |ptr|
+					Bindings.struct_create_named(Context.global, @name).tap do |ptr|
 						Bindings.struct_set_body(ptr, el_types_ptr, @element_types.length, packed.to_i) unless @element_types.empty?
 					end