rltk 2.2.1 → 3.0.0

data/lib/rltk/cg/generic_value.rb

@@ -15,7 +15,7 @@ require 'rltk/cg/type'
 # Classes and Modules #
 #######################
 
-module RLTK::CG # :nodoc:
+module RLTK::CG
 	
 	# GenericValue objects are used to pass parameters into
 	# {ExecutionEngine ExecutionEngines} as well as retreive an evaluated
@@ -83,7 +83,7 @@ module RLTK::CG # :nodoc:
 		end
 		
 		# @return [Boolean]
-		def to_b
+		def to_bool
 			self.to_i(false).to_bool
 		end
 		

data/lib/rltk/cg/instruction.rb

@@ -15,7 +15,7 @@ require 'rltk/cg/value'
 # Classes and Modules #
 #######################
 
-module RLTK::CG # :nodoc:
+module RLTK::CG
 	
 	# This class represents LLVM IR instructions.
 	class Instruction < User
@@ -25,6 +25,7 @@ module RLTK::CG # :nodoc:
 		# sub-types can be tested for.  This is a list of those sub-types and
 		# the names of their tests.
 		TESTABLE = [
+			:AddrSpaceCast,
 			:Alloca,
 			:BitCast,
 			:Call,
@@ -141,7 +142,21 @@ module RLTK::CG # :nodoc:
 			Bindings.set_instruction_call_conv(@ptr, Bindings.enum_type(:call_conv)[conv])
 			
 			conv
-		end	
+		end
+		
+		# @return [Boolean]
+		def tail_call?
+			Bindings.is_tail_call(@ptr).to_bool
+		end
+		
+		# Sets the *tail call* property for this call instruction.
+		#
+		# @param [Boolean]  bool  If this is a tail call or not
+		#
+		# @return [void]
+		def tail_call=(bool)
+			Bindings.set_tail_call(@ptr, bool.to_i)
+		end
 	end
 	
 	# An Instruction representing a Phi node.
@@ -179,10 +194,10 @@ module RLTK::CG # :nodoc:
 			# Add incoming {BasicBlock}/{Value} pairs to a Phi node.
 			#
 			# @example Adding a single block/value pair:
-			#	phi.incoming.add(bb, val)
+			#    phi.incoming.add(bb, val)
 			#
 			# @example Adding several block/value pairs:
-			#	phi.incoming.add({bb0 => val0, bb1 => val1})
+			#    phi.incoming.add({bb0 => val0, bb1 => val1})
 			#
 			# @param [BasicBlock, Hash{BasicBlock => Value}]	overloaded
 			# @param [Value, nil]						value
@@ -206,7 +221,7 @@ module RLTK::CG # :nodoc:
 				blks_ptr = FFI::MemoryPointer.new(:pointer, blks.size)
 				blks_ptr.write_array_of_pointer(blks)
 			
-				returning(nil) { Bindings.add_incoming(@phi, vals_ptr, blks_ptr, vals.length) }
+				nil.tap { Bindings.add_incoming(@phi, vals_ptr, blks_ptr, vals.length) }
 			end
 			alias :<< :add
 			
@@ -272,227 +287,233 @@ module RLTK::CG # :nodoc:
 	#############################
 	
 	# @LLVMInst add
-	class AddInst				< Instruction; end
+	class AddInst                 < Instruction; end
+	
+	# @LLVMInst addr_space_cast
+	class AddrSpaceCastInst       < Instruction; end
 	
 	# @LLVMInst alloca
-	class AllocaInst			< Instruction; end
+	class AllocaInst              < Instruction; end
 	
 	# @LLVMInst and
-	class AndInst				< Instruction; end
+	class AndInst                 < Instruction; end
 	
 	# @LLVMInst ashr
-	class ARightShiftInst		< Instruction; end
+	class ARightShiftInst         < Instruction; end
 	
 	# @LLVMInst alloca
-	class ArrayAllocaInst		< Instruction; end
+	class ArrayAllocaInst         < Instruction; end
+	
+	class ArrayMallocInst         < Instruction; end
 	
-	class ArrayMallocInst		< Instruction; end
+	# @LLVMInst atomicrmw
+	class AtomicRMWInst           < Instruction; end
 	
 	# @LLVMInst bitcast
-	class BitCastInst			< Instruction; end
+	class BitCastInst             < Instruction; end
 	
 	# @LLVMInst br
-	class BranchInst			< Instruction; end
+	class BranchInst              < Instruction; end
 	
 	# @LLVMInst br
-	class CondBranchInst		< Instruction; end
+	class CondBranchInst          < Instruction; end
 	
 	# @LLVMInst sdiv
-	class ExactSDivInst			< Instruction; end
+	class ExactSDivInst           < Instruction; end
 	
 	# @LLVMInst extractelement
-	class ExtractElementInst		< Instruction; end
+	class ExtractElementInst      < Instruction; end
 	
 	# @LLVMInst extractvalue
-	class ExtractValueInst		< Instruction; end
+	class ExtractValueInst        < Instruction; end
 	
 	# @LLVMInst fadd
-	class FAddInst				< Instruction; end
+	class FAddInst                < Instruction; end
 	
 	# @LLVMInst fcmp
-	class FCmpInst				< Instruction; end
+	class FCmpInst                < Instruction; end
 	
 	# @LLVMInst fdiv
-	class FDivInst				< Instruction; end
+	class FDivInst                < Instruction; end
 	
 	# @LLVMInst fmul
-	class FMulInst				< Instruction; end
+	class FMulInst                < Instruction; end
 	
 	# @LLVMInst fsub
-	class FNegInst				< Instruction; end
+	class FNegInst                < Instruction; end
 	
 	# @LLVMInst fptosi
-	class FPToSIInst			< Instruction; end
+	class FPToSIInst              < Instruction; end
 	
 	# @LLVMInst fptoui
-	class FPToUIInst			< Instruction; end
+	class FPToUIInst              < Instruction; end
 	
-	class FPCastInst			< Instruction; end
+	class FPCastInst              < Instruction; end
 	
 	# @LLVMInst fpext
-	class FPExtendInst			< Instruction; end
+	class FPExtendInst            < Instruction; end
 	
 	# @LLVMInst fptrunc
-	class FPTruncInst			< Instruction; end
+	class FPTruncInst             < Instruction; end
 	
-	class FreeInst				< Instruction; end
+	class FreeInst                < Instruction; end
 	
 	# @LLVMInst frem
-	class FRemInst				< Instruction; end
+	class FRemInst                < Instruction; end
 	
 	# @LLVMInst fsub
-	class FSubInst				< Instruction; end
+	class FSubInst                < Instruction; end
 	
 	# @LLVMInst gep
 	# @see http://llvm.org/docs/GetElementPtr.html
-	class GetElementPtrInst		< Instruction; end
+	class GetElementPtrInst       < Instruction; end
 	
-	class GlobalStringInst		< Instruction; end
-	class GlobalStringPtrInst	< Instruction; end
+	class GlobalStringInst        < Instruction; end
+	class GlobalStringPtrInst     < Instruction; end
 	
 	# @LLVMInst gep
 	# @see http://llvm.org/docs/GetElementPtr.html
-	class InBoundsGEPInst		< Instruction; end
+	class InBoundsGEPInst         < Instruction; end
 	
 	# @LLVMInst insertelement
-	class InsertElementInst		< Instruction; end
+	class InsertElementInst       < Instruction; end
 	
 	# @LLVMInst insertvalue
-	class InsertValueInst		< Instruction; end
+	class InsertValueInst         < Instruction; end
 	
 	# @LLVMInst inttoptr
-	class IntToPtrInst			< Instruction; end
+	class IntToPtrInst            < Instruction; end
 	
-	class IntCastInst			< Instruction; end
+	class IntCastInst             < Instruction; end
 	
 	# @LLVMInst icmp
-	class IntCmpInst			< Instruction; end
+	class IntCmpInst              < Instruction; end
 	
 	# @LLVMInst invoke
-	class InvokeInst			< Instruction; end
+	class InvokeInst              < Instruction; end
 	
-	class IsNotNullInst			< Instruction; end
-	class IsNullInstInst		< Instruction; end
+	class IsNotNullInst           < Instruction; end
+	class IsNullInstInst          < Instruction; end
 	
 	# @LLVMInst shl
-	class LeftShiftInst			< Instruction; end
+	class LeftShiftInst           < Instruction; end
 	
 	# @LLVMInst load
-	class LoadInst				< Instruction; end
+	class LoadInst                < Instruction; end
 	
 	# @LLVMInst lshr
-	class LRightShiftInst		< Instruction; end
+	class LRightShiftInst         < Instruction; end
 	
-	class MallocInst			< Instruction; end
+	class MallocInst              < Instruction; end
 	
 	# @LLVMInst mul
-	class MulInst				< Instruction; end
+	class MulInst                 < Instruction; end
 	
 	# @LLVMInst sub
-	class NegInst				< Instruction; end
+	class NegInst                 < Instruction; end
 	
-	class NotInst				< Instruction; end
+	class NotInst                 < Instruction; end
 	
 	# @LLVMInst add
-	class NSWAddInst			< Instruction; end
+	class NSWAddInst              < Instruction; end
 	
 	# @LLVMInst mul
-	class NSWMulInst			< Instruction; end
+	class NSWMulInst              < Instruction; end
 	
 	# @LLVMInst sub
-	class NSWNegInst			< Instruction; end
+	class NSWNegInst              < Instruction; end
 	
 	# @LLVMInst sub
-	class NSWSubInst			< Instruction; end
+	class NSWSubInst              < Instruction; end
 	
 	# @LLVMInst add
-	class NUWAddInst			< Instruction; end
+	class NUWAddInst              < Instruction; end
 	
 	# @LLVMInst mul
-	class NUWMulInst			< Instruction; end
+	class NUWMulInst              < Instruction; end
 	
 	# @LLVMInst sub
-	class NUWNegInst			< Instruction; end
+	class NUWNegInst              < Instruction; end
 	
 	# @LLVMInst sub
-	class NUWSubInst			< Instruction; end
+	class NUWSubInst              < Instruction; end
 	
 	# @LLVMInst or
-	class OrInst				< Instruction; end
+	class OrInst                  < Instruction; end
 	
 	# @LLVMInst ptrtoint
-	class PtrToIntInst			< Instruction; end
+	class PtrToIntInst            < Instruction; end
 	
-	class PtrCastInst			< Instruction; end
-	class PtrDiffInst			< Instruction; end
+	class PtrCastInst             < Instruction; end
+	class PtrDiffInst             < Instruction; end
 	
 	# @LLVMInst ret
-	class ReturnInst			< Instruction; end
+	class ReturnInst              < Instruction; end
 	
 	# @LLVMInst ret
-	class ReturnAggregateInst	< Instruction; end
+	class ReturnAggregateInst     < Instruction; end
 	
 	# @LLVMInst ret
-	class ReturnVoidInst		< Instruction; end
+	class ReturnVoidInst          < Instruction; end
 	
 	# @LLVMInst sdiv
-	class SDivInst				< Instruction; end
+	class SDivInst                < Instruction; end
 	
 	# @LLVMInst select
-	class SelectInst			< Instruction; end
+	class SelectInst              < Instruction; end
 	
 	# @LLVMInst shufflevector
-	class ShuffleVectorInst		< Instruction; end
+	class ShuffleVectorInst       < Instruction; end
 	
 	# @LLVMInst sext
-	class SignExtendInst		< Instruction; end
+	class SignExtendInst          < Instruction; end
 	
 	# @LLVMInst sext
 	# @LLVMInst bitcast
-	class SignExtendOrBitCastInst	< Instruction; end
+	class SignExtendOrBitCastInst < Instruction; end
 	
 	# @LLVMInst sitofp
-	class SIToFPInst			< Instruction; end
+	class SIToFPInst              < Instruction; end
 	
 	# @LLVMInst srem
-	class SRemInst				< Instruction; end
+	class SRemInst                < Instruction; end
 	
 	# @LLVMInst store
-	class StoreInst			< Instruction; end
+	class StoreInst               < Instruction; end
 	
 	# @LLVMInst gep
 	# @see http://llvm.org/docs/GetElementPtr.html
-	class StructGEPInst			< Instruction; end
+	class StructGEPInst           < Instruction; end
 	
 	# @LLVMInst sub
-	class SubInst				< Instruction; end
+	class SubInst                 < Instruction; end
 	
 	# @LLVMInst trunc
-	class TruncateInst			< Instruction; end
+	class TruncateInst            < Instruction; end
 	
 	# @LLVMInst trunc
 	# @LLVMInst bitcast
-	class TruncateOrBitCastInst	< Instruction; end
+	class TruncateOrBitCastInst   < Instruction; end
 	
 	# @LLVMInst udiv
-	class UDivInst				< Instruction; end
+	class UDivInst                < Instruction; end
 	
 	# @LLVMInst uitofp
-	class UIToFPInst			< Instruction; end
+	class UIToFPInst              < Instruction; end
 	
 	# @LLVMInst unreachable
-	class UnreachableInst		< Instruction; end
+	class UnreachableInst         < Instruction; end
 	
 	# @LLVMInst urem
-	class URemInst				< Instruction; end
+	class URemInst                < Instruction; end
 	
 	# @LLVMInst xor
-	class XOrInst				< Instruction; end
+	class XOrInst                 < Instruction; end
 	
 	# @LLVMInst zext
-	class ZeroExtendInst		< Instruction; end
+	class ZeroExtendInst          < Instruction; end
 	
 	# @LLVMInst zext
 	# @LLVMInst bitcast
-	class ZeroExtendOrBitCastInst	< Instruction; end
+	class ZeroExtendOrBitCastInst < Instruction; end
 end

data/lib/rltk/cg/llvm.rb

@@ -15,10 +15,20 @@ require 'rltk/cg/bindings'
 # Classes and Modules #
 #######################
 
-module RLTK::CG # :nodoc:
+module RLTK::CG
 	
 	# This module contains global operations on the LLVM compiler infrastructure.
 	module LLVM
+		
+		# Enable LLVM's built-in stack trace code. This intercepts the OS's
+		# crash signals and prints which component of LLVM you were in at the
+		# time if the crash.
+		#
+		# @return [void]
+		def self.enable_pretty_stack_trace
+			Bindings.enable_pretty_stack_trace
+		end
+		
 		# 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.
@@ -32,10 +42,10 @@ module RLTK::CG # :nodoc:
 		# @return [void]
 		def self.init(arch)
 			if arch == :all
-				Bindings.ecb_initialize_all_targets
+				Bindings.initialize_all_targets
 			
 			elsif arch == :native
-				Bindings.ecb_initialize_native_target
+				Bindings.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)
@@ -49,6 +59,14 @@ module RLTK::CG # :nodoc:
 			end
 		end
 		
+		# Initialize access to all available target MC that LLVM is
+		# configured to support.
+		#
+		# @return [void]
+		def self.initialize_all_target_mcs
+			Bindings.initialize_all_target_mcs
+		end
+		
 		# Initialize a given ASM parser inside LLVM.  You may also specify
 		# :all to initialize all ASM parsers.
 		#
@@ -101,6 +119,29 @@ module RLTK::CG # :nodoc:
 			end
 		end
 		
+		def self.multithreaded?
+			Bindings.is_multithreaded.to_bool
+		end
+		
+		# Deallocate and destroy all ManagedStatic variables.
+		#
+		# @return [void]
+		def self.shutdown
+			Bindings.shutdown
+		end
+		
+		# Initialize LLVM's multithreaded infrestructure.
+		#
+		# @return [void]
+		def self.start_multithreaded
+			Bindings.start_multithreaded
+		end
+		
+		# Shutdown and cleanup LLVM's multithreaded infrastructure.
+		def self.stop_multithreaded
+			Bindings.stop_multithreaded
+		end
+		
 		# @return [String] String representing the version of LLVM targeted by these bindings.
 		def self.version
 			RLTK::LLVM_TARGET_VERSION

data/lib/rltk/cg/memory_buffer.rb

@@ -14,7 +14,7 @@ require 'rltk/cg/bindings'
 # Classes and Modules #
 #######################
 
-module RLTK::CG # :nodoc:
+module RLTK::CG
 
 	# This class is used by the {Module} class to dump and load LLVM bitcode.
 	class MemoryBuffer
@@ -26,7 +26,7 @@ module RLTK::CG # :nodoc:
 		# 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
+		#   buffer, the name of a file containing LLVM bitcode or IR, or nil.  If it is nil the memory buffer will read
 		#   from standard in.
 		def initialize(overloaded = nil)
 			@ptr =
@@ -45,14 +45,31 @@ module RLTK::CG # :nodoc:
 					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)
+				if status.zero?
+					buf_ptr.get_pointer(0)
+				else
+					raise msg_ptr.get_pointer(0).get_string(0)
+				end
 			end
 			
 			# Define a finalizer to free the memory used by LLVM for this
 			# memory buffer.
 			ObjectSpace.define_finalizer(self, CLASS_FINALIZER)
 		end
+		
+		# Get the size of the memory buffer.
+		#
+		# @return [Integer]  Size of memory buffer
+		def size
+			Bindings.get_buffer_size(@ptr)
+		end
+		
+		# Get a copy of the memory buffer, from the beginning, as a sequence
+		# of characters.
+		#
+		# @return [String]
+		def start
+			Bindings.get_buffer_start(@ptr)
+		end
 	end
 end