Struct inkwell::passes::PassManager

pub struct PassManager<T> { /* private fields */ }

A manager for running optimization and simplification passes. Much of the documentation for specific passes is directly from the LLVM documentation.

Implementations

impl PassManager<FunctionValue<'_>>

pub fn as_mut_ptr(&self) -> LLVMPassManagerRef

Acquires the underlying raw pointer belonging to this PassManager<T> type.

pub fn initialize(&self) -> bool

pub fn finalize(&self) -> bool

impl<T: PassManagerSubType> PassManager<T>

pub unsafe fn new(pass_manager: LLVMPassManagerRef) -> Self

pub fn create<I: Borrow<T::Input>>(input: I) -> PassManager<T>

pub fn run_on(&self, input: &T) -> bool

This method returns true if any of the passes modified the function or module and false otherwise.

pub fn add_constant_merge_pass(&self)

Merges duplicate global constants together into a single constant that is shared. This is useful because some passes (i.e., TraceValues) insert a lot of string constants into the program, regardless of whether or not an existing string is available.

pub fn add_merge_functions_pass(&self)

Discovers identical functions and collapses them.

pub fn add_dead_arg_elimination_pass(&self)

This pass deletes dead arguments from internal functions. Dead argument elimination removes arguments which are directly dead, as well as arguments only passed into function calls as dead arguments of other functions. This pass also deletes dead arguments in a similar way.

This pass is often useful as a cleanup pass to run after aggressive interprocedural passes, which add possibly-dead arguments.

pub fn add_function_attrs_pass(&self)

A simple interprocedural pass which walks the call-graph, looking for functions which do not access or only read non-local memory, and marking them readnone/readonly. In addition, it marks function arguments (of pointer type) “nocapture” if a call to the function does not create any copies of the pointer value that outlive the call. This more or less means that the pointer is only dereferenced, and not returned from the function or stored in a global. This pass is implemented as a bottom-up traversal of the call-graph.

pub fn add_function_inlining_pass(&self)

Bottom-up inlining of functions into callees.

pub fn add_always_inliner_pass(&self)

A custom inliner that handles only functions that are marked as “always inline”.

pub fn add_global_dce_pass(&self)

This transform is designed to eliminate unreachable internal globals from the program. It uses an aggressive algorithm, searching out globals that are known to be alive. After it finds all of the globals which are needed, it deletes whatever is left over. This allows it to delete recursive chunks of the program which are unreachable.

pub fn add_global_optimizer_pass(&self)

This pass transforms simple global variables that never have their address taken. If obviously true, it marks read/write globals as constant, deletes variables only stored to, etc.

pub fn add_ipsccp_pass(&self)

An interprocedural variant of Sparse Conditional Constant Propagation.

pub fn add_internalize_pass(&self, all_but_main: bool)

This pass loops over all of the functions in the input module, looking for a main function. If a main function is found, all other functions and all global variables with initializers are marked as internal.

pub fn add_strip_dead_prototypes_pass(&self)

This pass loops over all of the functions in the input module, looking for dead declarations and removes them. Dead declarations are declarations of functions for which no implementation is available (i.e., declarations for unused library functions).

pub fn add_strip_symbol_pass(&self)

Performs code stripping. This transformation can delete:

• Names for virtual registers
• Symbols for internal globals and functions
• Debug information

Note that this transformation makes code much less readable, so it should only be used in situations where the strip utility would be used, such as reducing code size or making it harder to reverse engineer code.

pub fn add_loop_vectorize_pass(&self)

No LLVM documentation is available at this time.

pub fn add_slp_vectorize_pass(&self)

No LLVM documentation is available at this time.

pub fn add_aggressive_dce_pass(&self)

ADCE aggressively tries to eliminate code. This pass is similar to DCE but it assumes that values are dead until proven otherwise. This is similar to SCCP, except applied to the liveness of values.

pub fn add_bit_tracking_dce_pass(&self)

No LLVM documentation is available at this time.

pub fn add_alignment_from_assumptions_pass(&self)

No LLVM documentation is available at this time.

pub fn add_cfg_simplification_pass(&self)

Performs dead code elimination and basic block merging. Specifically:

• Removes basic blocks with no predecessors.
• Merges a basic block into its predecessor if there is only one and the predecessor only has one successor.
• Eliminates PHI nodes for basic blocks with a single predecessor.
• Eliminates a basic block that only contains an unconditional branch.

pub fn add_dead_store_elimination_pass(&self)

A trivial dead store elimination that only considers basic-block local redundant stores.

pub fn add_scalarizer_pass(&self)

No LLVM documentation is available at this time.

pub fn add_merged_load_store_motion_pass(&self)

No LLVM documentation is available at this time.

pub fn add_gvn_pass(&self)

This pass performs global value numbering to eliminate fully and partially redundant instructions. It also performs redundant load elimination.

pub fn add_new_gvn_pass(&self)

This pass performs global value numbering to eliminate fully and partially redundant instructions. It also performs redundant load elimination.

pub fn add_ind_var_simplify_pass(&self)

This transformation analyzes and transforms the induction variables (and computations derived from them) into simpler forms suitable for subsequent analysis and transformation.

This transformation makes the following changes to each loop with an identifiable induction variable:

• All loops are transformed to have a single canonical induction variable which starts at zero and steps by one.

• The canonical induction variable is guaranteed to be the first PHI node in the loop header block.

• Any pointer arithmetic recurrences are raised to use array subscripts.

If the trip count of a loop is computable, this pass also makes the following changes:

• The exit condition for the loop is canonicalized to compare the induction value against the exit value. This turns loops like:

for (i = 7; i*i < 1000; ++i)

into

for (i = 0; i != 25; ++i)

• Any use outside of the loop of an expression derived from the indvar is changed to compute the derived value outside of the loop, eliminating the dependence on the exit value of the induction variable. If the only purpose of the loop is to compute the exit value of some derived expression, this transformation will make the loop dead.

This transformation should be followed by strength reduction after all of the desired loop transformations have been performed. Additionally, on targets where it is profitable, the loop could be transformed to count down to zero (the “do loop” optimization).

pub fn add_instruction_combining_pass(&self)

Combine instructions to form fewer, simple instructions. This pass does not modify the CFG. This pass is where algebraic simplification happens.

This pass combines things like:

%Y = add i32 %X, 1
%Z = add i32 %Y, 1

into:

%Z = add i32 %X, 2

This is a simple worklist driven algorithm.

This pass guarantees that the following canonicalization are performed on the program:

1. If a binary operator has a constant operand, it is moved to the right-hand side.

2. Bitwise operators with constant operands are always grouped so that shifts are performed first, then ors, then ands, then xors.

3. Compare instructions are converted from <, >, ≤, or ≥ to = or ≠ if possible.

4. All cmp instructions on boolean values are replaced with logical operations.

5. add X, X is represented as mul X, 2 ⇒ shl X, 1

6. Multiplies with a constant power-of-two argument are transformed into shifts.

7. … etc.

This pass can also simplify calls to specific well-known function calls (e.g. runtime library functions). For example, a call exit(3) that occurs within the main() function can be transformed into simply return 3. Whether or not library calls are simplified is controlled by the -functionattrs pass and LLVM’s knowledge of library calls on different targets.

pub fn add_jump_threading_pass(&self)

Jump threading tries to find distinct threads of control flow running through a basic block. This pass looks at blocks that have multiple predecessors and multiple successors. If one or more of the predecessors of the block can be proven to always cause a jump to one of the successors, we forward the edge from the predecessor to the successor by duplicating the contents of this block.

An example of when this can occur is code like this:

if () { ...
  X = 4;
}
if (X < 3) {

In this case, the unconditional branch at the end of the first if can be revectored to the false side of the second if.

pub fn add_licm_pass(&self)

This pass performs loop invariant code motion, attempting to remove as much code from the body of a loop as possible. It does this by either hoisting code into the preheader block, or by sinking code to the exit blocks if it is safe. This pass also promotes must-aliased memory locations in the loop to live in registers, thus hoisting and sinking “invariant” loads and stores.

This pass uses alias analysis for two purposes:

1. Moving loop invariant loads and calls out of loops. If we can determine that a load or call inside of a loop never aliases anything stored to, we can hoist it or sink it like any other instruction.

2. Scalar Promotion of Memory. If there is a store instruction inside of the loop, we try to move the store to happen AFTER the loop instead of inside of the loop. This can only happen if a few conditions are true:

   1. The pointer stored through is loop invariant.

   2. There are no stores or loads in the loop which may alias the pointer. There are no calls in the loop which mod/ref the pointer.

If these conditions are true, we can promote the loads and stores in the loop of the pointer to use a temporary alloca’d variable. We then use the mem2reg functionality to construct the appropriate SSA form for the variable.

pub fn add_loop_deletion_pass(&self)

This file implements the Dead Loop Deletion Pass. This pass is responsible for eliminating loops with non-infinite computable trip counts that have no side effects or volatile instructions, and do not contribute to the computation of the function’s return value.

pub fn add_loop_idiom_pass(&self)

No LLVM documentation is available at this time.

pub fn add_loop_rotate_pass(&self)

A simple loop rotation transformation.

pub fn add_loop_reroll_pass(&self)

No LLVM documentation is available at this time.

pub fn add_loop_unroll_pass(&self)

This pass implements a simple loop unroller. It works best when loops have been canonicalized by the indvars pass, allowing it to determine the trip counts of loops easily.

pub fn add_memcpy_optimize_pass(&self)

This pass performs various transformations related to eliminating memcpy calls, or transforming sets of stores into memsets.

pub fn add_partially_inline_lib_calls_pass(&self)

This pass performs partial inlining, typically by inlining an if statement that surrounds the body of the function.

pub fn add_lower_switch_pass(&self)

Rewrites switch instructions with a sequence of branches, which allows targets to get away with not implementing the switch instruction until it is convenient.

pub fn add_promote_memory_to_register_pass(&self)

This file promotes memory references to be register references. It promotes alloca instructions which only have loads and stores as uses. An alloca is transformed by using dominator frontiers to place phi nodes, then traversing the function in depth-first order to rewrite loads and stores as appropriate. This is just the standard SSA construction algorithm to construct “pruned” SSA form.

pub fn add_reassociate_pass(&self)

This pass reassociates commutative expressions in an order that is designed to promote better constant propagation, GCSE, LICM, PRE, etc.

For example: 4 + (x + 5) ⇒ x + (4 + 5)

In the implementation of this algorithm, constants are assigned rank = 0, function arguments are rank = 1, and other values are assigned ranks corresponding to the reverse post order traversal of current function (starting at 2), which effectively gives values in deep loops higher rank than values not in loops.

pub fn add_sccp_pass(&self)

Sparse conditional constant propagation and merging, which can be summarized as:

• Assumes values are constant unless proven otherwise
• Assumes BasicBlocks are dead unless proven otherwise
• Proves values to be constant, and replaces them with constants
• Proves conditional branches to be unconditional

Note that this pass has a habit of making definitions be dead. It is a good idea to run a DCE pass sometime after running this pass.

pub fn add_scalar_repl_aggregates_pass(&self)

No LLVM documentation is available at this time.

pub fn add_scalar_repl_aggregates_pass_ssa(&self)

The well-known scalar replacement of aggregates transformation. This transform breaks up alloca instructions of aggregate type (structure or array) into individual alloca instructions for each member if possible. Then, if possible, it transforms the individual alloca instructions into nice clean scalar SSA form.

pub fn add_scalar_repl_aggregates_pass_with_threshold(&self, threshold: i32)

No LLVM documentation is available at this time.

pub fn add_simplify_lib_calls_pass(&self)

No LLVM documentation is available at this time.

pub fn add_tail_call_elimination_pass(&self)

This file transforms calls of the current function (self recursion) followed by a return instruction with a branch to the entry of the function, creating a loop. This pass also implements the following extensions to the basic algorithm:

1. Trivial instructions between the call and return do not prevent the transformation from taking place, though currently the analysis cannot support moving any really useful instructions (only dead ones).

2. This pass transforms functions that are prevented from being tail recursive by an associative expression to use an accumulator variable, thus compiling the typical naive factorial or fib implementation into efficient code.

3. TRE is performed if the function returns void, if the return returns the result returned by the call, or if the function returns a run-time constant on all exits from the function. It is possible, though unlikely, that the return returns something else (like constant 0), and can still be TRE’d. It can be TRE’d if all other return instructions in the function return the exact same value.

4. If it can prove that callees do not access theier caller stack frame, they are marked as eligible for tail call elimination (by the code generator).

pub fn add_instruction_simplify_pass(&self)

This pass implements constant propagation and merging. It looks for instructions involving only constant operands and replaces them with a constant value instead of an instruction. For example:

add i32 1, 2

becomes

i32 3

NOTE: this pass has a habit of making definitions be dead. It is a good idea to run a Dead Instruction Elimination pass sometime after running this pass.

pub fn add_demote_memory_to_register_pass(&self)

This file promotes memory references to be register references. It promotes alloca instructions which only have loads and stores as uses. An alloca is transformed by using dominator frontiers to place phi nodes, then traversing the function in depth-first order to rewrite loads and stores as appropriate. This is just the standard SSA construction algorithm to construct “pruned” SSA form.

pub fn add_verifier_pass(&self)

Verifies an LLVM IR code. This is useful to run after an optimization which is undergoing testing. Note that llvm-as verifies its input before emitting bitcode, and also that malformed bitcode is likely to make LLVM crash. All language front-ends are therefore encouraged to verify their output before performing optimizing transformations.

1. Both of a binary operator’s parameters are of the same type.

2. Verify that the indices of mem access instructions match other operands.

3. Verify that arithmetic and other things are only performed on first-class types. Verify that shifts and logicals only happen on integrals f.e.

4. All of the constants in a switch statement are of the correct type.

5. The code is in valid SSA form.

6. It is illegal to put a label into any other type (like a structure) or to return one.

7. Only phi nodes can be self referential: %x = add i32 %x, %x is invalid.

8. PHI nodes must have an entry for each predecessor, with no extras.

9. PHI nodes must be the first thing in a basic block, all grouped together.

10. PHI nodes must have at least one entry.

11. All basic blocks should only end with terminator insts, not contain them.

12. The entry node to a function must not have predecessors.

13. All Instructions must be embedded into a basic block.

14. Functions cannot take a void-typed parameter.

15. Verify that a function’s argument list agrees with its declared type.

16. It is illegal to specify a name for a void value.

17. It is illegal to have an internal global value with no initializer.

18. It is illegal to have a ret instruction that returns a value that does not agree with the function return value type.

19. Function call argument types match the function prototype.

20. All other things that are tested by asserts spread about the code.

Note that this does not provide full security verification (like Java), but instead just tries to ensure that code is well-formed.

pub fn add_correlated_value_propagation_pass(&self)

No LLVM documentation is available at this time.

pub fn add_early_cse_pass(&self)

No LLVM documentation is available at this time.

pub fn add_early_cse_mem_ssa_pass(&self)

No LLVM documentation is available at this time.

pub fn add_lower_expect_intrinsic_pass(&self)

No LLVM documentation is available at this time.

pub fn add_type_based_alias_analysis_pass(&self)

No LLVM documentation is available at this time.

pub fn add_scoped_no_alias_aa_pass(&self)

No LLVM documentation is available at this time.

pub fn add_basic_alias_analysis_pass(&self)

A basic alias analysis pass that implements identities (two different globals cannot alias, etc), but does no stateful analysis.

pub fn add_loop_unroll_and_jam_pass(&self)

Trait Implementations

impl<T: Debug> Debug for PassManager<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Drop for PassManager<T>

fn drop(&mut self)

Executes the destructor for this type.