Enum binaryen_sys::passes::OptimizationPass

pub enum OptimizationPass {
    Dae,
    DaeOptimizing,
    CoalesceLocals,
    CoalesceLocalsLearning,
    CodePushing,
    CodeFolding,
    ConstHoisting,
    Dce,
    Dfo,
    DuplicateFunctionElimination,
    ExtractFunction,
    Flatten,
    FpcastEmu,
    FuncMetrics,
    GenerateStackIr,
    Inlining,
    InliningOptimizing,
    LegalizeJsInterface,
    LocalCse,
    LogExecution,
    I64ToI32Lowering,
    InstrumentLocals,
    InstrumentMemory,
    Licm,
    MemoryPacking,
    MergeBlocks,
    MergeLocals,
    Metrics,
    Nm,
    OptimizeInstructions,
    OptimizeStackIr,
    PickLoadSigns,
    PostEmscripten,
    Precompute,
    PrecomputePropagate,
    Print,
    PrintMinified,
    PrintFull,
    PrintCallGraph,
    PrintStackIr,
    RelooperJumpThreading,
    RemoveNonJsOps,
    RemoveImports,
    RemoveMemory,
    RemoveUnusedBrs,
    RemoveUnusedModuleElements,
    RemoveUnusedNonfunctionModuleElements,
    RemoveUnusedNames,
    ReorderFunctions,
    ReorderLocals,
    Rereloop,
    Rse,
    SafeHeap,
    SimplifyLocals,
    SimplifyLocalsNonesting,
    SimplifyLocalsNotee,
    SimplifyLocalsNostructure,
    SimplifyLocalsNoteeNostructure,
    Souperify,
    SouperifySingleUse,
    SpillPointers,
    Ssa,
    TrapModeClamp,
    TrapModeJs,
    Untee,
    Vacuum,
    LowerI64,
}

Variants

Dae

removes arguments to calls in an lto-like manner

DaeOptimizing

removes arguments to calls in an lto-like manner, and optimizes where we removed

CoalesceLocals

reduce # of locals by coalescing

CoalesceLocalsLearning

reduce # of locals by coalescing and learning

CodePushing

push code forward, potentially making it not always execute

CodeFolding

fold code, merging duplicates

ConstHoisting

hoist repeated constants to a local

Dce

removes unreachable code

Dfo

optimizes using the DataFlow SSA IR

DuplicateFunctionElimination

removes duplicate functions

ExtractFunction

leaves just one function (useful for debugging)

Flatten

flattens out code, removing nesting

FpcastEmu

emulates function pointer casts, allowing incorrect indirect calls to (sometimes) work

FuncMetrics

reports function metrics

GenerateStackIr

generate Stack IR

Inlining

inline functions (you probably want inlining-optimizing)

InliningOptimizing

inline functions and optimizes where we inlined

LegalizeJsInterface

legalizes i64 types on the import/export boundary

LocalCse

common subexpression elimination inside basic blocks

LogExecution

instrument the build with logging of where execution goes

I64ToI32Lowering

lower all uses of i64s to use i32s instead

InstrumentLocals

instrument the build with code to intercept all loads and stores

InstrumentMemory

instrument the build with code to intercept all loads and stores

Licm

loop invariant code motion

MemoryPacking

packs memory into separate segments, skipping zeros

MergeBlocks

merges blocks to their parents

MergeLocals

merges locals when beneficial

Metrics

reports metrics

Nm

name list

OptimizeInstructions

optimizes instruction combinations

OptimizeStackIr

optimize Stack IR

PickLoadSigns

pick load signs based on their uses

PostEmscripten

miscellaneous optimizations for Emscripten-generated code

Precompute

computes compile-time evaluatable expressions

PrecomputePropagate

computes compile-time evaluatable expressions and propagates them through locals

Print

print in s-expression format

PrintMinified

print in minified s-expression format

PrintFull

print in full s-expression format

PrintCallGraph

print call graph

PrintStackIr

print out Stack IR (useful for internal debugging)

RelooperJumpThreading

thread relooper jumps (fastcomp output only)

RemoveNonJsOps

removes operations incompatible with js

RemoveImports

removes imports and replaces them with nops

RemoveMemory

removes memory segments

RemoveUnusedBrs

removes breaks from locations that are not needed

RemoveUnusedModuleElements

removes unused module elements

RemoveUnusedNonfunctionModuleElements

removes unused module elements that are not functions

RemoveUnusedNames

removes names from locations that are never branched to

ReorderFunctions

sorts functions by access frequency

ReorderLocals

sorts locals by access frequency

Rereloop

re-optimize control flow using the relooper algorithm

Rse

remove redundant set_locals

SafeHeap

instrument loads and stores to check for invalid behavior

SimplifyLocals

miscellaneous locals-related optimizations

SimplifyLocalsNonesting

miscellaneous locals-related optimizations (no nesting at all; preserves flatness)

SimplifyLocalsNotee

miscellaneous locals-related optimizations (no tees)

SimplifyLocalsNostructure

miscellaneous locals-related optimizations (no structure)

SimplifyLocalsNoteeNostructure

miscellaneous locals-related optimizations (no tees or structure)

Souperify

emit Souper IR in text form

SouperifySingleUse

emit Souper IR in text form (single-use nodes only)

SpillPointers

spill pointers to the C stack (useful for Boehm-style GC)

Ssa

ssa-ify variables so that they have a single assignment

TrapModeClamp

replace trapping operations with clamping semantics

TrapModeJs

replace trapping operations with js semantics

Untee

removes tee_locals, replacing them with sets and gets

Vacuum

removes obviously unneeded code

LowerI64

lowers i64 into pairs of i32s

Trait Implementations

impl PartialEq<OptimizationPass> for OptimizationPass

fn eq(&self, other: &OptimizationPass) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Eq for OptimizationPass

impl Debug for OptimizationPass

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

Formats the value using the given formatter.

impl FromStr for OptimizationPass

type Err = ()

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.