LLVM中三类Pass管理器的区别及FunctionPassManager适用范围问询

1. Differences between ModulePassManager, FunctionPassManager, and BasicBlockPassManager #

These three managers are core to LLVM's pass infrastructure, but they operate at distinct granularities and serve unique optimization/analysis needs:

• ModulePassManager

  • Scope: Operates on an entire LLVM IR Module—this covers all functions, global variables, metadata, and other top-level entities in the module.
  • Use cases: Ideal for passes that require cross-function or global context, like global dead code elimination, interprocedural optimization (IPO), or link-time optimizations that need visibility into the entire program.
  • Key trait: Since it handles the full module, passes here can't be parallelized across individual functions (though some module passes may internally dispatch function-level work). It has unrestricted access to every part of the module's IR.

• FunctionPassManager

  • Scope: Targets individual Function objects in isolation. Each function is processed independently of others.
  • Use cases: Perfect for function-local optimizations, such as loop unrolling, function-internal dead code elimination, register allocation prep, or constant propagation within a single function.
  • Key trait: Functions can be processed in parallel (LLVM's pass manager supports this natively) since there's no dependency between them. Passes here can't access or modify entities outside the current function.

• BasicBlockPassManager

  • Scope: Works on individual BasicBlock instances—the smallest contiguous code chunks with a single entry/exit point within a function.
  • Use cases: For low-level, block-specific optimizations like merging adjacent basic blocks, simplifying conditional branches, or peephole optimizations that only examine a single block's instructions.
  • Key trait: Each basic block is handled independently (even within the same function), making these passes highly parallelizable. They can't access or modify code outside the current basic block.

2. Is FunctionPassManager only applicable to LLVM-IR function types? #

Great question—while the name leans heavily toward Function objects, the reality has a bit of flexibility, though Function remains its primary target:

• Primary use: The vast majority of the time, FunctionPassManager runs passes on standard LLVM Function IR nodes. This is its intended design.
• Edge cases: In LLVM's modern pass manager framework, the FunctionPassManager can also work with entities that behave like functions (i.e., implement the required interfaces for function-level analysis and transformation). For example, some specialized IR constructs like coroutine frames or certain runtime helper stubs (with function-like structure) can be processed with it, though this is far less common.
• Hard limits: It cannot directly handle Module or BasicBlock objects—those require their respective dedicated pass managers. Any pass run through FunctionPassManager is constrained to the boundaries of a single function-like entity.

内容的提问来源于stack exchange，提问作者Jason Yu