Class: RLTK::CG::PassManager

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

Overview

A PassManager is responsible for scheduling and running optimization passes on modules.

Direct Known Subclasses

FunctionPassManager

Constant Summary collapse

CLASS_FINALIZER =

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

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

A list of passes that are available to be added to the pass manager via the #add method.

{
  :ADCE               => :aggressive_dce,
  :AlwaysInline       => :always_inliner,
  :ArgPromote         => :argument_promotion,
  :BasicAliasAnalysis => :basic_alias_analysis,
  :BBVectorize        => :bb_vectorize,
  :CFGSimplify        => :cfg_simplification,
  :ConstMerge         => :constant_merge,
  :ConstProp          => :constant_propagation,
  :CorValProp         => :correlated_value_propagation,
  :DAE                => :dead_arg_elimination,
  :DSE                => :dead_store_elimination,
  :DemoteMemToReg     => :demote_memory_to_register,
  :EarlyCSE           => :early_cse,
  :FunctionAttrs      => :function_attrs,
  :FunctionInline     => :function_inlining,
  :GDCE               => :global_dce,
  :GlobalOpt          => :global_optimizer,
  :GVN                => :gvn,
  :Internalize        => :internalize,
  :IndVarSimplify     => :ind_var_simplify,
  :InstCombine        => :instruction_combining,
  :IPConstProp        => :ip_constant_propagation,
  :IPSCCP             => :ipsccp,
  :JumpThreading      => :jump_threading,
  :LICM               => :licm,
  :LoopDeletion       => :loop_deletion,
  :LoopIdiom          => :loop_idiom,
  :LoopReroll         => :loop_reroll,
  :LoopRotate         => :loop_rotate,
  :LoopUnroll         => :loop_unroll,
  :LoopUnswitch       => :loop_unswitch,
  :LoopVectorize      => :loop_vectorize,
  :LEI                => :lower_expect_intrinsics,
  :MemCopyOpt         => :mem_cpy_opt,
  :PILC               => :partially_inline_lib_calls,
  :PromoteMemToReg    => :promote_memory_to_register,
  :PruneEH            => :prune_eh,
  :Reassociate        => :reassociate,
  :SCCP               => :sccp,
  :ScalarRepl         => :scalar_repl_aggregates,
  :SimplifyLibCalls   => :simplify_lib_calls,
  :SLPVectorize       => :slp_vectorize,
  :StripDeadProtos    => :strip_dead_prototypes,
  :StripSymbols       => :strip_symbols,
  :TailCallElim       => :tail_call_elimination,
  :TBAA               => :type_based_alias_analysis,
  :Verifier           => :verifier
}

Instance Attribute Summary

Attributes included from BindingClass

#ptr

Instance Method Summary collapse

Methods included from BindingClass

#==

Constructor Details

#initialize(mod) ⇒ PassManager

Create a new pass manager. You should never have to do this as Modules should create PassManagers for you whenever they are requested.

Parameters:

  • mod (Module) —

    Module this pass manager belongs to.

See Also:



86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/rltk/cg/pass_manager.rb', line 86

def initialize(mod)
  # LLVM Initialization
  @ptr = Bindings.create_pass_manager
  @mod = mod

  # Set the target data if the module is associated with a execution engine.
  self.target_data = mod.engine.target_data if mod.engine

  # RLTK Initialization
  @enabled = Array.new

  # Define a finalizer to free the memory used by LLVM for this
  # pass manager.
  ObjectSpace.define_finalizer(self, CLASS_FINALIZER)
end

Instance Method Details

#add(*names) ⇒ PassManager Also known as: <<

Add a pass or passes to this pass manager. Passes may either be specified via the keys for the PASSES hash or any string that will be turned into a string (via the Bindings.get_bname method) appearing as a value of the PASSES hash.

Parameters:

  • names (Array<Symbol>) —

    Passes to add to the pass manager.

Returns:

See Also:



112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/rltk/cg/pass_manager.rb', line 112

def add(*names)
  names.each do |name|
    name = name.to_sym

    if PASSES.has_key?(name)
      next if @enabled.include?(name)

      Bindings.send("add_#{PASSES[name]}_pass", @ptr)

      @enabled << name

    elsif PASSES.has_value?(bname = Bindings.get_bname(name))
      next if @enabled.include?(PASSES.key(bname))

      Bindings.send("add_#{bname}_pass", @ptr)

      @enabled << PASSES.key(bname)

    else
      raise "Unknown pass: #{name}"
    end
  end

  self
end

#enabled ⇒ Array<Symbol>

Returns List of passes that have been enabled.

Returns:

  • (Array<Symbol>) —

    List of passes that have been enabled.



140
141
142
 
# File 'lib/rltk/cg/pass_manager.rb', line 140

def enabled
  @enabled.clone
end

#enabled?(name) ⇒ Boolean

Returns Weather the pass has been enabled or not.

Returns:

  • (Boolean) —

    Weather the pass has been enabled or not.



145
146
147
 
# File 'lib/rltk/cg/pass_manager.rb', line 145

def enabled?(name)
  @enabled.include?(name) or @enabled.include?(PASSES.key(Bindings.get_bname(name)))
end

#run ⇒ void

This method returns an undefined value.

Run the enabled passes on the execution engine's module.



152
153
154
 
# File 'lib/rltk/cg/pass_manager.rb', line 152

def run
  Bindings.run_pass_manager(@ptr, @mod).to_bool
end

#target_data=(data) ⇒ void

This method returns an undefined value.

Set the target data for this pass manager.

Parameters:



161
162
163
 
# File 'lib/rltk/cg/pass_manager.rb', line 161

def target_data=(data)
  Bindings.add_target_data(check_type(data, TargetData, 'data'), @ptr)
end