rltk3 3.0.2

data/lib/rltk/cg/basic_block.rb

@@ -0,0 +1,157 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Ruby Language Toolkit
+# Date:		2012/04/07
+# Description:	This file defines the BasicBlock class.
+
+############
+# Requires #
+############
+
+# Ruby Language Toolkit
+require 'rltk/cg/bindings'
+require 'rltk/cg/context'
+require 'rltk/cg/value'
+
+#######################
+# Classes and Modules #
+#######################
+
+module RLTK::CG
+
+	# A BasicBlock is what instructions are inserted into and what functions
+	# are made of.  BasicBlock objects may be created either using
+	# BasicBlock.new or using the {Function::BasicBlockCollection#append}
+	# method.
+	class BasicBlock < Value
+
+		# Create a new BasicBlock object.  The way the block is created is
+		# determined by the *overloaded* parameter.  If it is a Function
+		# object then the new block is appended to the end of the function.
+		# If *overloaded* is another BasicBlock object the new block will
+		# be inserted before that block.
+		#
+		# A block may be given to this function to be invoked by {#build}.
+		#
+		# @param [FFI::Pointer, Function, BasicBlock] overloaded Overloaded paramater that determines creation behaviour.
+		#
+		# @param [String]		name			Name of this BasicBlock.
+		# @param [Builder, nil]	builder		Builder to be used by {#build}.
+		# @param [Context, nil]	context		Context in which to create the block.
+		# @param [Array<Object>]	block_args	Arguments to be passed when block is invoked.
+		# @param [Proc]		block		Block to be invoked by {#build}.
+		def initialize(overloaded, name = '', builder = nil, context = nil, *block_args, &block)
+			check_type(context, Context, 'context') if context
+
+			@ptr =
+			case overloaded
+			when FFI::Pointer
+				overloaded
+
+			when Function
+				if context
+					Bindings.append_basic_block_in_context(context, overloaded, name)
+				else
+					Bindings.append_basic_block(overloaded, name)
+				end
+
+			when BasicBlock
+				if context
+					Bindings.insert_basic_block_in_context(context, overloaded, name)
+				else
+					Bindings.insert_basic_block(overloaded, name)
+				end
+			end
+
+			self.build(builder, *block_args, &block) if block
+		end
+
+		# Used to add instructions to a BasicBlock.  The block given to this
+		# method is executed inside the context of a {Builder} object, either
+		# the one passed in the *builder* parameter or one created for this
+		# call.  Arguments may be passed into this block via the *block_args*
+		# parameter.
+		#
+		# @example
+		#     fun = Function.new(...)
+		#     block.build do
+		#          ret add(fun.params[0], fun.params[1])
+		#     end
+		#
+		# @param [Builder, nil]	builder		Builder in which to execute this block.
+		# @param [Array<Object>]	block_args	Arguments to pass into block.
+		# @param [Proc]		block		Block to execute inside builder.
+		#
+		# @return [Object] Value the block evaluates to.  Usually an {Instruction}
+		def build(builder = nil, *block_args, &block)
+			if builder then builder else Builder.new end.build(self, *block_args, &block)
+		end
+
+		# Creates a new BasicBlock inserted immediately before this block.
+		#
+		# @param [String]	name		Name of this BasicBlock.
+		# @param [Context]	context	Context in which to create this BasicBlock.
+		#
+		# @return [BasicBlock]
+		def insert_before(name = '', context = nil)
+			BasicBlock.new(self, name, context)
+		end
+
+		# @return [InstructionCollect] Collection of all instructions inside this BasicBlock.
+		def instructions
+			@instructions ||= InstructionCollection.new(self)
+		end
+
+		# @return [BasicBlock, nil] BasicBlock that occures immediately after this block or nil.
+		def next
+			if (ptr = Bindings.get_next_basic_block(@ptr)).null? then nil else BasicBlock.new(ptr) end
+		end
+
+		# @return [Function] Function object that this BasicBlock belongs to.
+		def parent
+			if (ptr = Bindings.get_basic_block_parent(@ptr)).null? then nil else Function.new(ptr) end
+		end
+
+		# @return [BasicBlock, nil] BasicBlock that occures immediately before this block or nil.
+		def previous
+			if (ptr = Bindings.get_previous_basic_block(@ptr)).null? then nil else BasicBlock.new(ptr) end
+		end
+
+		# This class is used to access all of the {Instruction Instructions} that have been added to a {BasicBlock}.
+		class InstructionCollection
+			include Enumerable
+
+			# @param [BasicBlock] bb BasicBlock this collection belongs to.
+			def initialize(bb)
+				@bb = bb
+			end
+
+			# Iterate over each {Instruction} in this collection.
+			#
+			# @yieldparam inst [Instruction]
+			#
+			# @return [Enumerator] An Enumerator is returned if no block is given.
+			def each
+				return to_enum(:each) unless block_given?
+
+				inst = self.first
+
+				while inst
+					yield inst
+					inst = inst.next
+				end
+
+				self
+			end
+
+			# @return [Instruction] First instruction in this collection.
+			def first
+				if (ptr = Bindings.get_first_instruction(@bb)).null? then nil else Instruction.from_ptr(ptr) end
+			end
+
+			# @return [Instruction] Last instruction in this collection.
+			def last
+				if (ptr = Bindings.get_last_instruction(@bb)).null? then nil else Instruction.from_ptr(ptr) end
+			end
+		end
+	end
+end

data/lib/rltk/cg/bindings.rb

@@ -0,0 +1,151 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Ruby Language Toolkit
+# Date:		2012/03/08
+# Description:	This file holds bindings to LLVM.
+
+#########
+# Notes #
+#########
+
+# 1) initialize_all_target_m_cs -> initialize_all_target_mcs
+# 2) initialize_obj_carc_opts   -> initialize_objc_arc_opts
+
+############
+# Requires #
+############
+
+# Gems
+require 'ffi'
+require 'filigree/boolean'
+
+# Ruby Language Toolkit
+require 'rltk/version'
+require 'rltk/cg'
+
+#######################
+# Classes and Modules #
+#######################
+
+module RLTK::CG
+
+	# This module provides access to stored FFI::Pointer objects and allows a
+	# class to be passed directly into FFI methods.  It also provides a
+	# pointer comparison method.
+	module BindingClass
+		# @return [FFI::Pointer]
+		attr_accessor :ptr
+		alias :to_ptr :ptr
+
+		# Compares one BindingClass object to another.
+		#
+		# @param [BindingClass] other Another BindingClass object to compare to.
+		#
+		# @return [Boolean]
+		def ==(other)
+			self.class == other.class and @ptr == other.ptr
+		end
+	end
+
+	# This module contains FFI bindings to LLVM.
+	module Bindings
+		extend FFI::Library
+		ffi_lib("LLVM-#{RLTK::LLVM_TARGET_VERSION}")
+
+		# Exception that is thrown when the LLVM target version does not
+		# match the version of LLVM present on the system.
+		class LibraryMismatch < Exception; end
+
+		# Require the generated bindings files while handling errors.
+		require 'rltk/cg/generated_bindings'
+
+		#############
+		# Constants #
+		#############
+
+		# List of architectures supported by LLVM.
+		ARCHS = [
+			:Alpha,
+			:ARM,
+			:Blackfin,
+			:CBackend,
+			:CellSPU,
+			:CppBackend,
+			:MBlaze,
+			:Mips,
+			:MSP430,
+			:PowerPC,
+			:PTX,
+			:Sparc,
+			:SystemZ,
+			:X86,
+			:XCore
+		]
+
+		# List of assembly parsers.
+		ASM_PARSERS = [
+			:ARM,
+			:MBLaze,
+			:X86
+		]
+
+		# List of assembly printers.
+		ASM_PRINTERS = [
+			:Alpha,
+			:ARM,
+			:Blackfin,
+			:CellSPU,
+			:MBLaze,
+			:Mips,
+			:MSP430,
+			:PowerPC,
+			:PTX,
+			:Sparc,
+			:SystemZ,
+			:X86,
+			:XCore
+		]
+
+		###########
+		# Methods #
+		###########
+
+		# Converts a CamelCase string into an underscored string.
+		#
+		# @param [#to_s] name CamelCase string.
+		#
+		# @return [Symbol] Underscored string.
+		def self.get_bname(name)
+			name.to_s.
+				gsub(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2').
+				gsub(/([a-z\d])([A-Z])/,'\1_\2').
+				downcase.to_sym
+		end
+
+		# A wrapper class for FFI::Library.attach_function
+		#
+		# @param [Symbol]		func		Function name.
+		# @param [Array<Object>] args		Argument types for FFI::Library.attach_function.
+		# @param [Object]		returns	Return type for FFI::Library.attach_function.
+		def self.add_binding(func, args, returns)
+			attach_function(get_bname(func.to_s[4..-1]), func, args, returns)
+		end
+
+		####################
+		# Missing Bindings #
+		####################
+
+		ARCHS.each do |arch|
+			add_binding("LLVMInitialize#{arch}Target", [], :void)
+			add_binding("LLVMInitialize#{arch}TargetInfo", [], :void)
+			add_binding("LLVMInitialize#{arch}TargetMC", [], :void)
+		end
+
+		ASM_PARSERS.each do |asm|
+			add_binding("LLVMInitialize#{asm}AsmParser", [], :void)
+		end
+
+		ASM_PRINTERS.each do |asm|
+			add_binding("LLVMInitialize#{asm}AsmPrinter", [], :void)
+		end
+	end
+end