Pass

This pass uses the SSA based Aggressive DCE algorithm. This algorithm assumes instructions are dead until proven otherwise, which makes it more successful are removing non-obviously dead instructions.

This pass uses a bit-tracking DCE algorithm in order to remove computations of dead bits.

Use assume intrinsics to set load/store alignments.

Merge basic blocks, eliminate unreachable blocks, simplify terminator instructions, etc.

This pass deletes stores that are post-dominated by must-aliased stores and are not loaded used between the stores.

Converts vector operations into scalar operations.

This pass merges loads and stores in diamonds. Loads are hoisted into the header, while stores sink into the footer.

This pass performs global value numbering and redundant load elimination cotemporaneously.

Transform induction variables in a program to all use a single canonical induction variable per loop.

Combine instructions to form fewer, simple instructions. This pass does not modify the CFG, and has a tendency to make instructions dead, so a subsequent DCE pass is useful.

This pass combines things like:

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

into:

%Z = add int 2, %X

Working in conjunction with the linker, iterate through all functions and global values in the module and attempt to change their linkage from external to internal.

To preserve the linkage of a global value, return true from the given callback.

Working in conjunction with the linker, iterate through all functions and global values in the module and attempt to change their linkage from external to internal.

When a function with the name “main” is encountered, if the value of preserveMain is true, “main” will not be internalized.

Thread control through mult-pred/multi-succ blocks where some preds always go to some succ. Thresholds other than minus one override the internal BB duplication default threshold.

This pass is a loop invariant code motion and memory promotion pass.

This pass performs DCE of non-infinite loops that it can prove are dead.

This pass recognizes and replaces idioms in loops.

This pass is a simple loop rotating pass.

This pass is a simple loop rerolling pass.

This pass is a simple loop unrolling pass.

This pass is a simple loop unroll-and-jam pass.

This pass is a simple loop unswitching pass.

This pass lowers atomic intrinsics to non-atomic form for use in a known non-preemptible environment.

This pass performs optimizations related to eliminating memcpy calls and/or combining multiple stores into memset’s.

Tries to inline the fast path of library calls such as sqrt.

This pass converts SwitchInst instructions into a sequence of chained binary branch instructions.

This pass is used to promote memory references to be register references. A simple example of the transformation performed by this pass is going from code like this:

%X = alloca i32, i32 1
store i32 42, i32 *%X
%Y = load i32* %X
ret i32 %Y

To code like this:

ret i32 42

Adds DWARF discriminators to the IR. Discriminators are used to decide what CFG path was taken inside sub-graphs whose instructions share the same line and column number information.

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)

Sparse conditional constant propagation.

This pass eliminates call instructions to the current function which occur immediately before return instructions.

A worklist driven constant propagation pass.

This pass is used to demote registers to memory references. It basically undoes the .promoteMemoryToRegister pass to make CFG hacking easier.

Propagate CFG-derived value information

This pass performs a simple and fast CSE pass over the dominator tree.

Removes llvm.expect intrinsics and creates “block_weights” metadata.

Adds metadata to LLVM IR types and performs metadata-based Type-Based Alias Analysis (TBAA).

TBAA requires that two pointers to objects of different types must never alias. Because memory in LLVM is typeless, TBAA is performed using special metadata nodes describing aliasing relationships between types in the source language(s).

To construct this metadata, see MDBuilder.

Adds metadata to LLVM IR types and performs metadata-based scoped no-alias analysis.

LLVM’s primary stateless and local alias analysis.

Given a pointer value, walk the use-def chain to find out how that pointer is used. The traversal terminates at global variables and aliases, stack allocations, and values of non-pointer types - referred to as “underlying objects”. Analysis may reach multiple underlying object values because of branching control flow. If the set of underlying objects for one pointer has a non-empty intersection with another, those two pointers are deemed mayalias. Else, an empty intersection deems those pointers noalias.

Basic Alias Analysis should generally be scheduled ahead of other AA passes. This is because it is more conservative than other passes about declaring two pointers mustalias, and does so fairly efficiently. For example, loads through two members of a union with distinct types are declared by TBAA to be noalias, where BasicAA considers them mustalias.

Performs alias and mod/ref analysis for internal global values that do not have their address taken.

Internal global variables that are only loaded from may be marked as constants.

This pass is used to ensure that functions have at most one return instruction in them. Additionally, it keeps track of which node is the new exit node of the CFG.

Runs the LLVM IR Verifier to sanity check the results of passes.

A pass to inline and remove functions marked as “always_inline”.

This pass promotes “by reference” arguments to be passed by value if the number of elements passed is less than or equal to 3.

This function returns a new pass that merges duplicate global constants together into a single constant that is shared. This is useful because some passes (ie TraceValues) insert a lot of string constants into the program, regardless of whether or not they duplicate an existing string.

This pass removes arguments from functions which are not used by the body of the function.

This pass walks SCCs of the call graph in RPO to deduce and propagate function attributes. Currently it only handles synthesizing norecurse attributes.

Uses a heuristic to inline direct function calls to small functions.

This transform is designed to eliminate unreachable internal globals (functions or global variables)

This function returns a new pass that optimizes non-address taken internal globals.

This pass propagates constants from call sites into the bodies of functions.

This pass propagates constants from call sites into the bodies of functions, and keeps track of whether basic blocks are executable in the process.

Return a new pass object which transforms invoke instructions into calls, if the callee can not unwind the stack.

This transformation attempts to discovery alloca allocations of aggregates that can be broken down into component scalar values.

This pass removes any function declarations (prototypes) that are not used.

These functions removes symbols from functions and modules without touching symbols for debugging information.

Performs a loop vectorization pass to widen instructions in loops to operate on multiple consecutive iterations.

This pass performs a superword-level parallelism pass to combine similar independent instructions into vector instructions.

An invalid pass that crashes when added to the pass manager.