Class: RCGTK::Module

Inherits:
Object
  • Object
show all
Includes:
BindingClass
Defined in:
lib/rcgtk/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.



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

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:



31
32
33
 
# File 'lib/rcgtk/module.rb', line 31

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:



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

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:



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

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



118
119
120
 
# File 'lib/rcgtk/module.rb', line 118

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.



123
124
125
 
# File 'lib/rcgtk/module.rb', line 123

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:



134
135
136
 
# File 'lib/rcgtk/module.rb', line 134

def dump
  Bindings.dump_module(@ptr)
end

#function_pass_manager ⇒ FunctionPassManager Also known as: fpm

Returns Function pass manager for this module.

Returns:



139
140
141
 
# File 'lib/rcgtk/module.rb', line 139

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:



194
195
196
 
# File 'lib/rcgtk/module.rb', line 194

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.



200
201
202
 
# File 'lib/rcgtk/module.rb', line 200

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



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

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:



167
168
169
 
# File 'lib/rcgtk/module.rb', line 167

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



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

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) 


216
217
218
 
# File 'lib/rcgtk/module.rb', line 216

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.



209
210
211
 
# File 'lib/rcgtk/module.rb', line 209

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) 


223
224
225
 
# File 'lib/rcgtk/module.rb', line 223

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.



251
252
253
 
# File 'lib/rcgtk/module.rb', line 251

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) 


258
259
260
 
# File 'lib/rcgtk/module.rb', line 258

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.



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

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