lower unaligned loads and stores to smaller aligned ones

async/await style transform, allowing pausing and resuming

Tries to avoid reinterpret operations via more loads

removes arguments to calls in an lto-like manner

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

refine and merge abstract (never-created) types

reduce # of locals by coalescing

reduce # of locals by coalescing and learning

push code forward, potentially making it not always execute

fold code, merging duplicates

hoist repeated constants to a local

propagate constant struct field values

removes unreachable code

forces all loads and stores to have alignment 1

instrument the wasm to convert NaNs into 0 at runtime

turns indirect calls into direct ones

discards global effect info

optimizes using the DataFlow SSA IR

dump DWARF debug info sections from the read binary

removes duplicate imports

removes duplicate functions

emit the target features section in the output

leaves just one function (useful for debugging)

leaves just one function selected by index

flattens out code, removing nesting

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

reports function metrics

generate dynCall fuctions used by emscripten ABI

generate dynCall functions used by emscripten ABI, but only for functions with i64 in their signature (which cannot be invoked via the wasm table without JavaScript BigInt support).

generate global effect info (helps later passes)

generate Stack IR

refine the types of globals

globally optimize struct values

globally optimize GC types

Grand Unified Flow Analysis: optimize the entire program using information about what content can actually appear in each location

GUFA plus local optimizations in functions we modified

apply more specific subtypes to type fields where possible

replace GC allocations with locals

inline __original_main into main

inline functions (you probably want inlining-optimizing)

inline functions and optimizes where we inlined

lower away binaryen intrinsics

wrap imports and exports for JavaScript promise integration

legalizes i64 types on the import/export boundary

legalizes i64 types on the import/export boundary in a minimal manner, only on things only JS will call

common subexpression elimination inside basic blocks

apply more specific subtypes to locals where possible

instrument the build with logging of where execution goes

lower all uses of i64s to use i32s instead

instrument the build with code to intercept all loads and stores

instrument the build with code to intercept all loads and stores

loop invariant code motion

attempt to merge segments to fit within web limits

lower loads and stores to a 64-bit memory to instead use a 32-bit one

packs memory into separate segments, skipping zeros

merges blocks to their parents

merges similar functions when benefical

merges locals when beneficial

reports metrics

minifies import names (only those, and not export names), and emits a mapping to the minified ones

minifies both import and export names, and emits a mapping to the minified ones

minifies both import and export names, and emits a mapping to the minified ones, and minifies the modules as well

apply the assumption that asyncify imports always unwind, and we never rewind

apply the assumption that asyncify never unwinds

creates specialized versions of functions

creates specialized versions of functions (even if unhelpful)

combines multiple memories into a single memory

combines multiple memories into a single memory, trapping if the read or write is larger than the length of the memory's data

name list

(re)name all heap types

reduces calls to code that only runs once

optimizes added constants into load/store offsets

optimizes added constants into load/store offsets, propagating them across locals too

eliminate and reuse casts

optimizes instruction combinations

optimize Stack IR

pick load signs based on their uses

Tranform Binaryen IR into Poppy IR

miscellaneous optimizations for Emscripten-generated code

early optimize of the instruction combinations for js

computes compile-time evaluatable expressions

computes compile-time evaluatable expressions and propagates them through locals

print in s-expression format

print in minified s-expression format

print options for enabled features

print in full s-expression format

print call graph

print a map of function indexes to names

alias for print_function_map

print out Stack IR (useful for internal debugging)

removes operations incompatible with js

removes imports and replaces them with nops

removes memory segments

removes breaks from locations that are not needed

removes unused module elements

removes unused module elements that are not functions

removes names from locations that are never branched to

remove unused private GC types

sorts functions by access frequency

sorts globals by access frequency

sorts globals by access frequency (even if there are few)

sorts locals by access frequency

re-optimize control flow using the relooper algorithm

remove redundant local.sets

write the module to binary, then read it

instrument loads and stores to check for invalid behavior

sets specified globals to specified values

remove params from function signature types where possible

apply more specific subtypes to signature types where possible

lower sign-ext operations to wasm mvp

miscellaneous globals-related optimizations

miscellaneous globals-related optimizations, and optimizes where we replaced global.gets with constants

miscellaneous locals-related optimizations

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

miscellaneous locals-related optimizations (no tees)

miscellaneous locals-related optimizations (no structure)

miscellaneous locals-related optimizations (no tees or structure)

emit Souper IR in text form

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

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

stub out unsupported JS operations

ssa-ify variables so that they have a single assignment

ssa-ify variables so that they have a single assignment, ignoring merges

deprecated; same as strip-debug

enforce limits on llvm's __stack_pointer global

strip debug info (including the names section)

strip dwarf debug info

strip the wasm producers section

strip EH instructions

strip the wasm target features section

replace trapping operations with clamping semantics

replace trapping operations with js semantics

merge types to their supertypes where possible

create new nominal types to help other optimizations

removes local.tees, replacing them with sets and gets

removes obviously unneeded code