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.



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? 



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.

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.



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.



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 



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 



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 



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

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

#globals ⇒ GlobalCollection 



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 



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.



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.



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.



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.



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.



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.



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