Class: RLTK::CG::Module

Inherits:
Object show all
Includes:
BindingClass
Defined in:
lib/rltk/cg/module.rb

Overview

This class represents a collection of functions, constants, and global variables.

Defined Under Namespace

Classes: FunctionCollection, GlobalCollection

Constant Summary collapse

CLASS_FINALIZER =

The Proc object called by the garbage collector to free resources used by LLVM.

Proc.new { |id| Bindings.dispose_module(ptr) if ptr = ObjectSpace._id2ref(id).ptr }

Instance Attribute Summary collapse

Attributes included from BindingClass

#ptr

Class Method Summary collapse

Instance Method Summary collapse

Methods included from BindingClass

#==

Constructor Details

#initialize(overloaded, context = nil, &block) ⇒ Module

Create a new LLVM module.

Parameters:

  • overloaded (FFI::Pointer, String) —

    Pointer to existing module or name of new module.

  • context (Context, nil) (defaults to: nil) —

    Optional context in which to create the module.

  • block (Proc) —

    Block to be executed inside the context of the module.



68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
# File 'lib/rltk/cg/module.rb', line 68

def initialize(overloaded, context = nil, &block)
	@ptr =
	case overloaded
	when FFI::Pointer
		overloaded
		
	when String
		if context
			Bindings.module_create_with_name_in_context(overloaded, check_type(context, Context, 'context'))
		else
			Bindings.module_create_with_name(overloaded)
		end
	end
	
	# Define a finalizer to free the memory used by LLVM for this
	# module.
	ObjectSpace.define_finalizer(self, CLASS_FINALIZER)
	
	self.instance_exec(&block) if block
end

Instance Attribute Details

#engine ⇒ ExecutionEngine?

Returns Execution engine associated with this module.

Returns:



30
31
32
 
# File 'lib/rltk/cg/module.rb', line 30

def engine
  @engine
end

Class Method Details

.read_bitcode(overloaded) ⇒ Module

Load a module from LLVM bitcode.

Parameters:

  • overloaded (MemoryBuffer, FFI::Pointer, String, nil) —

    Where to read the bitecode from.

Returns:

See Also:



39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
# File 'lib/rltk/cg/module.rb', line 39

def self.read_bitcode(overloaded)
	buffer = if overloaded.is_a?(MemoryBuffer) then overloaded else MemoryBuffer.new(overloaded) end
	
	mod_ptr = FFI::MemoryPointer.new(:pointer)
	msg_ptr = FFI::MemoryPointer.new(:pointer)
	
	status = Bindings.parse_bitcode(buffer, mod_ptr, msg_ptr)
	
	if status != 0
		raise msg_ptr.get_pointer(0).get_string(0)
	else
		Module.new(mod_ptr.get_pointer(0))
	end
end

.read_ir_file(file_name, context = Context.global) ⇒ Module

Load a Module form an LLVM IR file.

Parameters:

  • file_name (String) —

    Name of file containing LLVM IR module.

Returns:



59
60
61
 
# File 'lib/rltk/cg/module.rb', line 59

def self.read_ir_file(file_name, context = Context.global)
	self.new(Bindings.load_module_from_ir_file(file_name, context))
end

Instance Method Details

#compile(file_name, mode = :object, machine = TargetMachine.host, opt_level = 2, verify = true) ⇒ void

This method returns an undefined value.

Compile this module to an assembly or object file.

Parameters:

  • file_name (String) —

    Name of output file.

  • mode (:asm, :object) (defaults to: :object) —

    Generate assembly or object file?

  • machine (TargetMachine) (defaults to: TargetMachine.host) —

    Machine type to target.

  • opt_level (0, 1, 2, 3) (defaults to: 2) —

    Optimization level to use during compilation.

  • verify (Boolean) (defaults to: true) —

    Verify the module before compilation or not.



98
99
100
 
# File 'lib/rltk/cg/module.rb', line 98

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

#context ⇒ Context

Returns Context in which this module exists.

Returns:

  • (Context) —

    Context in which this module exists.



103
104
105
 
# File 'lib/rltk/cg/module.rb', line 103

def context
	Context.new(Bindings.get_module_context(@ptr))
end

#dump ⇒ void

This method returns an undefined value.

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 Also:



114
115
116
 
# File 'lib/rltk/cg/module.rb', line 114

def dump
	Bindings.dump_module(@ptr)
end

#function_pass_manager ⇒ FunctionPassManager Also known as: fpm

Returns Function pass manager for this module.

Returns:



119
120
121
 
# File 'lib/rltk/cg/module.rb', line 119

def function_pass_manager
	@function_pass_manager ||= FunctionPassManager.new(self)
end

#functions ⇒ FunctionCollection Also known as: funs

Returns Proxy object for inspecting this module’s functions.

Returns:



151
152
153
 
# File 'lib/rltk/cg/module.rb', line 151

def functions
	@functions ||= FunctionCollection.new(self)
end

#globals ⇒ GlobalCollection

Returns Proxy object for inspecting this module’s global values and variables.

Returns:

  • (GlobalCollection) —

    Proxy object for inspecting this module’s global values and variables.



157
158
159
 
# File 'lib/rltk/cg/module.rb', line 157

def globals
	@globals ||= GlobalCollection.new(self)
end

#pass_manager ⇒ PassManager Also known as: pm

Returns Pass manager for this module.

Returns:



125
126
127
 
# File 'lib/rltk/cg/module.rb', line 125

def pass_manager
	@pass_manager ||= PassManager.new(self)
end

#print(io = $stdout) ⇒ void

This method returns an undefined value.

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.

Parameters:

  • io (String, #fileno) (defaults to: $stdout) —

    File name or object with a file descriptor to print to.



139
140
141
142
143
144
145
146
147
148
 
# File 'lib/rltk/cg/module.rb', line 139

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

#target ⇒ String

Get the module’s target triple.

Returns:

  • (String) 


173
174
175
 
# File 'lib/rltk/cg/module.rb', line 173

def target
	Bindings.get_target(@ptr)
end

#target=(triple) ⇒ void

This method returns an undefined value.

Set the module’s target triple.

Parameters:

  • triple (String) —

    Triple value to set.



166
167
168
 
# File 'lib/rltk/cg/module.rb', line 166

def target=(triple)
	Bindings.set_target(@ptr, triple)
end

#verify ⇒ nil, String

Verify that the module is valid LLVM IR.

Returns:

  • (nil, String) —

    Human-readable description of any invalid constructs if invalid.



201
202
203
 
# File 'lib/rltk/cg/module.rb', line 201

def verify
	do_verification(:return_status)
end

#verify! ⇒ nil

Verify that a module is valid LLVM IR and abort the process if it isn’t.

Returns:

  • (nil) 


208
209
210
 
# File 'lib/rltk/cg/module.rb', line 208

def verify!
	do_verification(:abort_process)
end

#write_bitcode(overloaded) ⇒ Boolean

Write the module as LLVM bitcode to a file.

Parameters:

  • overloaded (#path, #fileno, Integer, String) —

    Where to write the bitcode.

Returns:

  • (Boolean) —

    If the write was successful.



182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
 
# File 'lib/rltk/cg/module.rb', line 182

def write_bitcode(overloaded)
	0 ==
	if overloaded.respond_to?(:path)
		Bindings.write_bitcode_to_file(@ptr, overloaded.path)
		
	elsif overloaded.respond_to?(:fileno)
		Bindings.write_bitcode_to_fd(@ptr, overloaded.fileno, 0, 1)
		
	elsif overloaded.is_a?(Integer)
		Bindings.write_bitcode_to_fd(@ptr, overloaded, 0, 1)
		
	elsif overloaded.is_a?(String)
		Bindings.write_bitcode_to_file(@ptr, overloaded)
	end
end