Class: RLTK::CG::Module

Inherits:
Object
  • 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.



84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
# File 'lib/rltk/cg/module.rb', line 84

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
		
	else
		raise 'Argument `overloaded` must be a FFI::Pointer of String.'
	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, context = nil) ⇒ Module

Load a module from LLVM bitcode.

Parameters:

  • overloaded (MemoryBuffer, String) —

    Where to read the bitecode from

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

    Context in which to parse bitcode

Returns:



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

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

.read_ir(overloaded, context = Context.global) ⇒ Module

Load a Module form an LLVM IR.

Parameters:

  • overloaded (MemoryBuffer, String) —

    Where to read the IR from

  • context (Context) (defaults to: Context.global) —

    Context in which to parse IR

Returns:



64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/rltk/cg/module.rb', line 64

def self.read_ir(overloaded, context = Context.global)
	buffer = overloaded.is_a?(MemoryBuffer) ? overloaded : MemoryBuffer.new(overloaded)
	
	mod_ptr = FFI::MemoryPointer.new(:pointer)
	msg_ptr = FFI::MemoryPointer.new(:pointer)
	
	status = Bindings.parse_ir_in_context(context, buffer, mod_ptr, msg_ptr)
	
	if status.zero?
		Module.new(mod_ptr.get_pointer(0))
	else
		raise msg_ptr.get_pointer(0).get_string(0)
	end
end

Instance Method Details

#compile(file_name, emit_type = :object, machine = TargetMachine.host) ⇒ void

This method returns an undefined value.

Compile this module to an assembly or object file.

Parameters:

  • file_name (String) —

    File to emit code to

  • emit_type (:assembly, :object) (defaults to: :object) —

    Type of code to emit

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

    TargetMachine used to generate code

Raises:

  • LLVM error message if unable to emit code for module



117
118
119
 
# File 'lib/rltk/cg/module.rb', line 117

def compile(file_name, emit_type = :object, machine = TargetMachine.host)
	machine.emite_module(self, file_name, emit_type)
end

#context ⇒ Context

Returns Context in which this module exists.

Returns:

  • (Context) —

    Context in which this module exists.



122
123
124
 
# File 'lib/rltk/cg/module.rb', line 122

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:



133
134
135
 
# File 'lib/rltk/cg/module.rb', line 133

def dump
	Bindings.dump_module(@ptr)
end

#function_pass_manager ⇒ FunctionPassManager Also known as: fpm

Returns Function pass manager for this module.

Returns:



138
139
140
 
# File 'lib/rltk/cg/module.rb', line 138

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:



193
194
195
 
# File 'lib/rltk/cg/module.rb', line 193

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.



199
200
201
 
# File 'lib/rltk/cg/module.rb', line 199

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

#link(other) ⇒ Object

Link another module into this one, taking ownership of it. You may not access the other module again once linking it.

Parameters:

  • other (Module) —

    Module to be linked

Raises:

  • Errors encountered during linking



149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
 
# File 'lib/rltk/cg/module.rb', line 149

def link(other)
	error  = FFI::MemoryPointer.new(:pointer)
	status = Bindings.link_modules(@ptr, other, :linker_destroy_source, 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 linking modules: #{message}"
	end
end

#pass_manager ⇒ PassManager Also known as: pm

Returns Pass manager for this module.

Returns:



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

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

#print(file_name) ⇒ void

This method returns an undefined value.

Print the LLVM IR representation of this module to a file.

Parameters:

  • file_name (String) —

    Name of file to print to



176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
 
# File 'lib/rltk/cg/module.rb', line 176

def print(file_name)
	error  = FFI::MemoryPointer.new(:pointer)
	status = Bindings.print_module_to_file(@ptr, file_name, 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 printing module: #{message}"
	end
end

#target ⇒ String

Get the module’s target triple.

Returns:

  • (String) 


215
216
217
 
# File 'lib/rltk/cg/module.rb', line 215

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.



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

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

#to_s ⇒ String

Return a LLVM IR representation of this file as a string.

Returns:

  • (String) 


222
223
224
 
# File 'lib/rltk/cg/module.rb', line 222

def to_s
	Bindings.print_module_to_string(@ptr)
end

#verify ⇒ nil, String

Verify that the module is valid LLVM IR.

Returns:

  • (nil, String) —

    Human-readable description of any invalid constructs if invalid.



250
251
252
 
# File 'lib/rltk/cg/module.rb', line 250

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) 


257
258
259
 
# File 'lib/rltk/cg/module.rb', line 257

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.



231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
 
# File 'lib/rltk/cg/module.rb', line 231

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