Optimization

Sere composes its own optimization pipeline instead of calling LLVM's level defaults. Every switch in the table below selects a real pass, and the same switches drive three layers:

1. Sere IR rewrites over the generated llvm::Module — release-mode lowering, null-check folding, stack promotion, runtime annotations.
2. The LLVM pipeline — composed from the enabled passes, run in rounds.
3. The native toolchain — the flags clang gets when it compiles the emitted .ll and links the executable.

Because the rewrites happen before printing, the switches are visible in --emit-llvm, --emit-serem, and --emit-asm, not only in a linked binary.

Aggregate levels

--opt <level> and the project manifest key opt = "O2" do the same thing. A level sets a whole switch set, so per-pass switches written before a level are replaced by it and switches written after it override it. Order matters:

sere -O3 --no-inline-all app.sere     # O3 without always-inline
sere --cse -O1 app.sere               # the level wins; --cse is redundant

Bundles

--release is the switch to reach for when the program is correct and speed or size matters. --debug restores the checked behavior without needing to name every --no-… counterpart.

Per-pass switches

Every switch has an inverse; the inverse is what to use when a preset enabled something you do not want.

A per-pass switch also means "build the pipeline from switches". That is the only difference from a bare level.

Release-mode lowering

These switches change what the generated IR checks, so they are the ones that change program behavior. Use them on a program that is already correct.

--no-runtime-checks implies all three check switches. The effects are visible immediately: sere --emit-llvm --no-runtime-checks app.sere has no err blocks and no sere_has_error call.

How the pipeline is composed

The composed module pipeline is, in order:

globalopt, ipsccp                     (when const-fold)
always-inline                         (when inline-all)
inline, ipsccp, function-attrs,
deadargelim, globaldce,
strip-dead-prototypes                 (when inlining or dead-code)
function(                             one round, repeated
  sroa, mem2reg,                        for O1+, twice more for O3
  sccp,
  instcombine, dse, memcpyopt, mergeicmps,
  early-cse<memssa>,
  aggressive-instcombine, reassociate,
  div-rem-pairs, constraint-elimination,
  gvn, gvn-hoist,
  simplifycfg, correlated-propagation, tailcallelim,
  float2int,
  loop-simplify, lcssa, loop-rotate, loop-idiom, licm,
  loop-deletion, loop-instsimplify,
  loop-unroll,
  loop-vectorize, slp-vectorizer, vector-combine,
  instcombine, tailcallelim, adce, dce)
cgscc(jump-threading, simplifycfg,
      instcombine, adce)              (when branch-opt)
globaldce                             (when dead-code)

The coroutine pipeline (coro-early,coro-split,coro-cleanup) always runs before this, because an unsplit coroutine cannot be inlined or cloned.

--passes=<pipeline> replaces the composed pipeline with a PassBuilder string. --lto replaces it with LLVM's prelink pipeline, which is what -flto expects.

Runtime annotations

annotateRuntimeDeclarations runs on every compile, whatever the level, because the promises are true of the runtime itself:

• Every sere_* declaration is nounwind — the runtime is C and cannot unwind through a Sere frame.
• Pure readers (sere_list_len, sere_dict_len, sere_str_eq, sere_str_cmp, …) are readonly and willreturn, so repeated calls collapse into one.
• Fresh allocations are allocsize(0), which lets LLVM fold two allocation sizes into one and know how large the block is. With --no-null-checks (or --no-runtime-checks) they additionally return nonnull, noalias, and noundef memory, which is what lets the null-check folding fire.
• Accessors whose range check can fire (sere_list_item, sere_str_index, …) are not promised anything while --bounds-checks is on.

Native toolchain flags

The IR pipeline optimizes the module; clang still has to turn it into machine code. Sere passes the level through and adds:

-march=native means a binary is tuned for the machine that built it. That is the right default for sere build on a developer machine and the wrong one for a binary you intend to ship, where -O2 -Oz style settings are safer.

Seeing what happened

SERE_OPT_REPORT=1 sere --emit-llvm -O3 --release app.sere -o app.ll
sere --dump-llvm-ir-raw --emit-llvm app.sere -o app.ll

Serem-side passes

--emit-serem and --backend=serem run the Serem pipeline described in serem.md. The switches that apply there are the same ones: --cse adds Serem common-subexpression elimination, --peephole and --strength-reduce add identity folding and shift/mask rewriting, and --no-runtime-checks strips the error.* machinery. --release enables all three.

Adding a switch

1. Add the field to OptimizationOptions in include/sere/codegen/OptPipeline.h, with a doc comment.
2. Set it in optimizationPreset if a level should turn it on.
3. Handle the flag in parseOptimizationFlag, including its --no- inverse.
4. Use it in buildFlagPipeline (the LLVM pipeline) or in SeremTransform.cpp::transformPasses (the Serem pipeline), or in OptPasses.cpp if it is a rewrite over the generated module.
5. Add it to clangCodegenFlags if the backend needs to know.
6. Cover it in tests/opt_options.cpp and add a CLI test in tests/CMakeLists.txt.