rltk 2.0.0 → 2.1.0

data/lib/rltk/cg/generated_extended_bindings.rb

@@ -32,6 +32,52 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :target_version, :LLVMTargetVersion, [], :string
   
+  # (Not documented)
+  # 
+  # @method initialize_all_asm_parsers()
+  # @return [nil] 
+  # @scope class
+  attach_function :initialize_all_asm_parsers, :LLVMInitializeAllAsmParsers, [], :void
+  
+  # (Not documented)
+  # 
+  # @method initialize_all_asm_printers()
+  # @return [nil] 
+  # @scope class
+  attach_function :initialize_all_asm_printers, :LLVMInitializeAllAsmPrinters, [], :void
+  
+  # (Not documented)
+  # 
+  # @method initialize_native_target_asm_parser()
+  # @return [nil] 
+  # @scope class
+  attach_function :initialize_native_target_asm_parser, :LLVMInitializeNativeTargetAsmParser, [], :void
+  
+  # (Not documented)
+  # 
+  # @method initialize_native_target_asm_printer()
+  # @return [nil] 
+  # @scope class
+  attach_function :initialize_native_target_asm_printer, :LLVMInitializeNativeTargetAsmPrinter, [], :void
+  
+  # (Not documented)
+  # 
+  # @method load_module_from_ir_file(file_name, context)
+  # @param [String] file_name 
+  # @param [FFI::Pointer(ContextRef)] context 
+  # @return [FFI::Pointer(ModuleRef)] 
+  # @scope class
+  attach_function :load_module_from_ir_file, :LLVMLoadModuleFromIRFile, [:string, :pointer], :pointer
+  
+  # (Not documented)
+  # 
+  # @method print_module(mod, fd)
+  # @param [FFI::Pointer(ModuleRef)] mod 
+  # @param [Integer] fd 
+  # @return [nil] 
+  # @scope class
+  attach_function :print_module, :LLVMPrintModule, [:pointer, :int], :void
+  
   # (Not documented)
   # 
   # @method load_library_permanently(filename)
@@ -40,4 +86,202 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :load_library_permanently, :LLVMLoadLibraryPermanently, [:string], :int
   
+  # (Not documented)
+  # 
+  # @method print_value(val, fd)
+  # @param [FFI::Pointer(ValueRef)] val 
+  # @param [Integer] fd 
+  # @return [nil] 
+  # @scope class
+  attach_function :print_value, :LLVMPrintValue, [:pointer, :int], :void
+  
+  # (Not documented)
+  # 
+  # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:code_model).</em>
+  # 
+  # === Options:
+  # :default_cmodel ::
+  #   
+  # :kernel ::
+  #   
+  # :small ::
+  #   
+  # :medium ::
+  #   
+  # :large ::
+  #   
+  # 
+  # @method _enum_code_model_
+  # @return [Symbol]
+  # @scope class
+  enum :code_model, [
+    :default_cmodel, 0,
+    :kernel, 1,
+    :small, 2,
+    :medium, 3,
+    :large, 4
+  ]
+  
+  # (Not documented)
+  # 
+  # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:reloc_model).</em>
+  # 
+  # === Options:
+  # :default_rmodel ::
+  #   
+  # :static ::
+  #   
+  # :pic ::
+  #   
+  # :dynamic_no_pic ::
+  #   
+  # 
+  # @method _enum_reloc_model_
+  # @return [Symbol]
+  # @scope class
+  enum :reloc_model, [
+    :default_rmodel, 0,
+    :static, 1,
+    :pic, 2,
+    :dynamic_no_pic, 3
+  ]
+  
+  # (Not documented)
+  # 
+  # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:compile_type).</em>
+  # 
+  # === Options:
+  # :asm ::
+  #   
+  # :object ::
+  #   
+  # 
+  # @method _enum_compile_type_
+  # @return [Symbol]
+  # @scope class
+  enum :compile_type, [
+    :asm, 0,
+    :object, 1
+  ]
+  
+  # (Not documented)
+  class OpaqueTarget < FFI::Struct
+    layout :dummy, :char
+  end
+  
+  # (Not documented)
+  class OpaqueTargetMachine < FFI::Struct
+    layout :dummy, :char
+  end
+  
+  # (Not documented)
+  class OpaqueTriple < FFI::Struct
+    layout :dummy, :char
+  end
+  
+  # // Utility
+  # 
+  # @method build_features_string(attrs, num_attrs)
+  # @param [FFI::Pointer(**CharS)] attrs 
+  # @param [Integer] num_attrs 
+  # @return [String] 
+  # @scope class
+  attach_function :build_features_string, :LLVMBuildFeaturesString, [:pointer, :int], :string
+  
+  # (Not documented)
+  # 
+  # @method compile_module_to_file(mod, machine, pm, file_name, ctype, opt_level, no_verify)
+  # @param [FFI::Pointer(ModuleRef)] mod 
+  # @param [OpaqueTargetMachine] machine 
+  # @param [FFI::Pointer(PassManagerRef)] pm 
+  # @param [String] file_name 
+  # @param [Symbol from _enum_compile_type_] ctype 
+  # @param [Integer] opt_level 
+  # @param [Integer] no_verify 
+  # @return [nil] 
+  # @scope class
+  attach_function :compile_module_to_file, :LLVMCompileModuleToFile, [:pointer, OpaqueTargetMachine, :pointer, :string, :compile_type, :uint, :uint], :void
+  
+  # (Not documented)
+  # 
+  # @method ecb_initialize_all_targets()
+  # @return [nil] 
+  # @scope class
+  attach_function :ecb_initialize_all_targets, :LLVMECBInitializeAllTargets, [], :void
+  
+  # (Not documented)
+  # 
+  # @method ecb_initialize_native_target()
+  # @return [nil] 
+  # @scope class
+  attach_function :ecb_initialize_native_target, :LLVMECBInitializeNativeTarget, [], :void
+  
+  # // Target
+  # 
+  # @method get_target_from_name(name)
+  # @param [String] name 
+  # @return [OpaqueTarget] 
+  # @scope class
+  attach_function :get_target_from_name, :LLVMGetTargetFromName, [:string], OpaqueTarget
+  
+  # (Not documented)
+  # 
+  # @method get_target_from_triple(triple)
+  # @param [OpaqueTriple] triple 
+  # @return [OpaqueTarget] 
+  # @scope class
+  attach_function :get_target_from_triple, :LLVMGetTargetFromTriple, [OpaqueTriple], OpaqueTarget
+  
+  # // Target Machine
+  # 
+  # @method create_target_machine(target, triple, mcpu, features, rmodel, cmodel)
+  # @param [OpaqueTarget] target 
+  # @param [String] triple 
+  # @param [String] mcpu 
+  # @param [String] features 
+  # @param [Symbol from _enum_reloc_model_] rmodel 
+  # @param [Symbol from _enum_code_model_] cmodel 
+  # @return [OpaqueTargetMachine] 
+  # @scope class
+  attach_function :create_target_machine, :LLVMCreateTargetMachine, [OpaqueTarget, :string, :string, :string, :reloc_model, :code_model], OpaqueTargetMachine
+  
+  # (Not documented)
+  # 
+  # @method set_target_machine_asm_verbosity(machine, boolean)
+  # @param [OpaqueTargetMachine] machine 
+  # @param [Integer] boolean 
+  # @return [nil] 
+  # @scope class
+  attach_function :set_target_machine_asm_verbosity, :LLVMSetTargetMachineASMVerbosity, [OpaqueTargetMachine, :int], :void
+  
+  # // Triple
+  # 
+  # @method get_host_triple()
+  # @return [OpaqueTriple] 
+  # @scope class
+  attach_function :get_host_triple, :LLVMGetHostTriple, [], OpaqueTriple
+  
+  # (Not documented)
+  # 
+  # @method get_host_triple_string()
+  # @return [String] 
+  # @scope class
+  attach_function :get_host_triple_string, :LLVMGetHostTripleString, [], :string
+  
+  # (Not documented)
+  # 
+  # @method get_triple_string(triple)
+  # @param [OpaqueTriple] triple 
+  # @return [String] 
+  # @scope class
+  attach_function :get_triple_string, :LLVMGetTripleString, [OpaqueTriple], :string
+  
+  # (Not documented)
+  # 
+  # @method triple_create(string)
+  # @param [String] string 
+  # @return [OpaqueTriple] 
+  # @scope class
+  attach_function :triple_create, :LLVMTripleCreate, [:string], OpaqueTriple
+  
 end

data/lib/rltk/cg/llvm.rb

@@ -19,27 +19,85 @@ module RLTK::CG # :nodoc:
 	
 	# This module contains global operations on the LLVM compiler infrastructure.
 	module LLVM
-		# Initialize LLVM to generate code for a given architecture.
+		# Initialize LLVM to generate code for a given architecture.  You may
+		# also specify :all to initialize all targets or :native to
+		# initialize the host target.
 		#
 		# @see Bindings::ARCHS
 		#
 		# @param [Symbol] arch Architecture to initialize LLVM for.
 		#
-		# @raise [RuntimeError] An error is raised if an unsupported architecture is specified.
+		# @raise [ArgumentError] An error is raised if an unsupported architecture is specified.
 		#
-		# @return [true]
+		# @return [void]
 		def self.init(arch)
-			if Bindings::ARCHS.include?(arch) or Bindings::ARCHS.map { |sym| sym.to_s.downcase.to_sym }.include?(arch)
+			if arch == :all
+				Bindings.ecb_initialize_all_targets
+			
+			elsif arch == :native
+				Bindings.ecb_initialize_native_target
+			
+			elsif Bindings::ARCHS.include?(arch) or Bindings::ARCHS.map { |sym| sym.to_s.downcase.to_sym }.include?(arch)
 				arch = Bindings.get_bname(arch)
 				
 				Bindings.send("initialize_#{arch}_target".to_sym)
 				Bindings.send("initialize_#{arch}_target_info".to_sym)
 				Bindings.send("initialize_#{arch}_target_mc".to_sym)
 			
-				true
+			else
+				raise ArgumentError, "Unsupported architecture specified: #{arch}."
+			end
+		end
+		
+		# Initialize a given ASM parser inside LLVM.  You may also specify
+		# :all to initialize all ASM parsers.
+		#
+		# @see Bindings::ASM_PARSERS
+		#
+		# @param [Symbol] asm Assembly language type to initialize parser for.
+		#
+		# @raise [ArgumentError] An error is raised if an unsupported assembler parser is specified.
+		#
+		# @return [void]
+		def self.init_asm_parser(asm)
+			if asm == :all
+				Bindings.initialize_all_asm_parsers
+			
+			elsif Bindings::ASM_PARSERS.include?(asm) or Bindings::ASM_PARSERS.map { |sym| sym.to_s.downcase.to_sym }.include?(asm)
+				asm = Bindings.get_bname(asm)
+				
+				Bindings.send("initialize_#{asm}_asm_parser".to_sym)
+			
+			else
+				raise ArgumentError, "Unsupported assembler type specified: #{asm}"
+			end
+		end
+		
+		# Initialize a given ASM printer inside LLVM.  You may also specify
+		# :all to initialize all ASM printers or :native to initialize the
+		# printer for the host machine's assembly language.
+		#
+		# @see Bindings::ASM_PRINTERS
+		#
+		# @param [Symbol] asm Assembly language type to initialize printer for.
+		#
+		# @raise [ArgumentError] An error is raised if an unsupported assembler printer is specified.
+		#
+		# @return [void]
+		def self.init_asm_printer(asm)
+			if asm == :all
+				Bindings.initialize_all_asm_printers
+			
+			elsif asm == :native
+				Bindings.initialize_native_asm_printer
+			
+			elsif Bindings::ASM_PRINTERS.include?(asm) or Bindings::ASM_PRINTERS.map { |sym| sym.to_s.downcase.to_sym }.include?(asm)
+				asm = Bindings.get_bname(asm)
+				
+				Bindings.send("initialize_#{asm}_asm_printer".to_sym)
 			
 			else
-				raise "Unsupported architecture specified: #{arch}"
+				raise ArgumentError, "Unsupported assembler type specified: #{asm}"
 			end
 		end
 		

data/lib/rltk/cg/module.rb

@@ -22,11 +22,15 @@ module RLTK::CG # :nodoc:
 	class Module
 		include BindingClass
 		
+		# @!attribute [rw] engine
+		#   @return [ExecutionEngine, nil] Execution engine associated with this module.
+		attr_accessor :engine
+		
 		# Load a module from LLVM bitcode.
 		#
 		# @see MemoryBuffer#initialize
 		#
-		# @param [MemoryBuffer, FFI::Pointer, String, nil] overloaded Where to read the bytecode from.
+		# @param [MemoryBuffer, FFI::Pointer, String, nil] overloaded Where to read the bitecode from.
 		#
 		# @return [Module]
 		def self.read_bitcode(overloaded)
@@ -44,6 +48,15 @@ module RLTK::CG # :nodoc:
 			end
 		end
 		
+		# Load a Module form an LLVM IR file.
+		#
+		# @param [String] file_name Name of file containing LLVM IR module.
+		#
+		# @return [Module]
+		def self.read_ir_file(file_name, context = Context.global)
+			self.new(Bindings.load_module_from_ir_file(file_name, context))
+		end
+		
 		# Create a new LLVM module.
 		#
 		# @param [FFI::Pointer, String]	overloaded	Pointer to existing module or name of new module. 
@@ -66,6 +79,19 @@ module RLTK::CG # :nodoc:
 			self.instance_exec(&block) if block
 		end
 		
+		# Compile this module to an assembly or object file.
+		#
+		# @param [String]		file_name	Name of output file.
+		# @param [:asm, :object]	mode		Generate assembly or object file?
+		# @param [TargetMachine]	machine	Machine type to target.
+		# @param [0, 1, 2, 3]	opt_level	Optimization level to use during compilation.
+		# @param [Boolean]		verify	Verify the module before compilation or not.
+		#
+		# @return [void]
+		def compile(file_name, mode = :object, machine = TargetMachine.host, opt_level = 2, verify = true)
+			Bindings.compile_module_to_file(@ptr, machine, self.pm, file_name, mode, opt_level, (!verify).to_i)
+		end
+		
 		# @return [Context] Context in which this module exists.
 		def context
 			Context.new(Bindings.get_module_context(@ptr))
@@ -82,13 +108,49 @@ module RLTK::CG # :nodoc:
 			end
 		end
 		
-		# Print the IR of this module to standard out.
+		# Print the LLVM IR representation of this value to standard error.
+		# This function is the debugging version of the more general purpose
+		# {#print} method.
+		#
+		# @see #print
 		#
 		# @return [void]
 		def dump
 			Bindings.dump_module(@ptr)
 		end
 		
+		# @return [FunctionPassManager] Function pass manager for this module.
+		def function_pass_manager
+			@function_pass_manager ||= FunctionPassManager.new(self)
+		end
+		alias :fpm :function_pass_manager
+		
+		# @return [PassManager] Pass manager for this module.
+		def pass_manager
+			@pass_manager ||= PassManager.new(self)
+		end
+		alias :pm :pass_manager
+		
+		# Print the LLVM IR representation of this module to a file.  The
+		# file may be specified via a file name (which will be created or
+		# truncated) or an object that responds to #fileno.
+		#
+		# @LLVMECB
+		#
+		# @param [String, #fileno] io File name or object with a file descriptor to print to.
+		#
+		# @return [void]
+		def print(io = $stdout)
+			case io
+			when String
+				File.open(io, 'w') do |f|
+					Bindings.print_module(@ptr, f.fileno)
+				end
+			else
+				Bindings.print_module(@ptr, io.fileno)
+			end
+		end
+		
 		# @return [FunctionCollection] Proxy object for inspecting this module's functions.
 		def functions
 			@functions ||= FunctionCollection.new(self)
@@ -100,6 +162,22 @@ module RLTK::CG # :nodoc:
 			@globals ||= GlobalCollection.new(self)
 		end
 		
+		# Set the module's target triple.
+		#
+		# @param [String] triple Triple value to set.
+		#
+		# @return [void]
+		def target=(triple)
+			Bindings.set_target(@ptr, triple)
+		end
+		
+		# Get the module's target triple.
+		#
+		# @return [String]
+		def target
+			Bindings.get_target(@ptr)
+		end
+		
 		# Write the module as LLVM bitcode to a file.
 		#
 		# @param [#path, #fileno, Integer, String] overloaded Where to write the bitcode.

data/lib/rltk/cg/pass_manager.rb

@@ -68,18 +68,20 @@ module RLTK::CG # :nodoc:
 			:Verifier			=> :verifier
 		}
 		
-		# Creat a new pass manager.  You should never have to do this as
-		# {ExecutionEngine ExecutionEngines} creates a PassManager whenever
-		# one is requested.
+		# Create a new pass manager.  You should never have to do this as
+		# {Module Modules} should create PassManagers for you whenever they
+		# are requested.
 		#
-		# @param [ExecutionEngine]	engine	ExecutionEngine this pass manager belongs to.
-		# @param [Module]			mod		Module this pass manager belongs to.
-		def initialize(engine, mod)
+		# @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
 			
-			Bindings.add_target_data(Bindings.get_execution_engine_target_data(engine), @ptr)
+			# 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
@@ -152,6 +154,15 @@ module RLTK::CG # :nodoc:
 			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
@@ -161,19 +172,21 @@ module RLTK::CG # :nodoc:
 	# 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.
+		# 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 [ExecutionEngine]	engine	ExecutionEngine this pass manager belongs to.
-		# @param [Module]			mod		Module this pass manager belongs to.
-		def initialize(engine, mod)
+		# @param [Module] mod Module this pass manager belongs to.
+		def initialize(mod)
 			# LLVM Initialization
 			@ptr = Bindings.create_function_pass_manager_for_module(mod)
 			
-			Bindings.add_target_data(Bindings.get_execution_engine_target_data(engine), @ptr)
+			# 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).to_bool
+			Bindings.initialize_function_pass_manager(@ptr)
 			
 			# RLTK Initialization
 			@enabled = Array.new

data/lib/rltk/cg/support.rb

@@ -21,6 +21,8 @@ module RLTK::CG # :nodoc:
 		# 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.
 		def self.load_library(lib)
 			Bindings.load_library_permanently(lib).to_bool

data/lib/rltk/cg/target.rb

@@ -0,0 +1,100 @@
+# 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 # :nodoc:
+
+	# Class binding for the LLVM Triple class.
+	class Target
+		include BindingClass
+		
+		# @return [Triple] Triple object for this target.
+		attr_reader :triple
+		
+		# @return [Target] Target object for the host architecture.
+		def self.host
+			@host ||= self.new(Triple.host)
+		end
+		
+		# 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	then [Bindings.get_target_from_string(overloaded), Triple.new(overloaded)]
+			when Triple	then [Bindings.get_target_from_triple(overloaded), overloaded]
+			end
+		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
+	end
+	
+	# This class represents a specific architecture that wil be targeted by
+	# LLVM's compilation process.
+	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
+		
+		# @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]				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
+			
+			# 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)
+		end
+	end
+end