技术导读——☆☆☆LLVM中端Pass分类汇总

LLVM 中端（Middle-End） 主要负责 IR 级优化和分析，核心组件包括 优化变换（Transforms）、分析框架（Analysis）、Pass 管理器（Pass Manager） 等。它以 LLVM IR（Static Single Assignment 形式）为基础，通过 标量优化、循环优化、向量化、跨过程优化 等技术提升代码质量。中端优化主要位于 lib/Transforms/ 和 lib/Analysis/ 目录，包含诸如 常量传播、死代码删除、循环展开、别名分析、控制流优化 等 Pass。LLVM 采用 Pass 管理器 组织和调度优化流水线，实现模块化和可扩展性，使其适用于不同架构的编译优化需求。
首先我会从最常用也是我自己最先接触的 Pass 开始。

Transforms

Scalar

LLVM lib/Transforms/Scalar/ 目录包含 标量优化（Scalar Transformations） 相关的 Pass，这些优化主要作用于单个基本块或函数级别的 IR，提高执行效率并减少冗余代码。

死代码与冗余消除

• ADCE.cpp（Aggressive Dead Code Elimination）
• BDCE.cpp（Bit-Tracking Dead Code Elimination）
• DCE.cpp（Dead Code Elimination）
• DeadStoreElimination.cpp（删除未使用的存储）
• EarlyCSE.cpp（早期公共子表达式消除）
• GVN.cpp（全局值编号优化以优化冗余计算）
• GVNHoist.cpp（GVN 提升优化）
• GVNSink.cpp（GVN 下沉优化）
• MemCpyOptimizer.cpp（优化 memcpy/memmove）
• SCCP.cpp（稀疏条件常量传播）（Sparse Conditional Constant Propagation）
• NewGVN.cpp（新的 GVN 算法）

循环优化

这些 Pass 主要用于 循环优化，包括 循环展开、分裂、消除不必要计算：

• LICM.cpp（循环不变代码外提）
• IndVarSimplify.cpp（循环归纳变量优化）
• LoopAccessAnalysisPrinter.cpp（循环访问分析打印）
• LoopBoundSplit.cpp（循环边界拆分）
• LoopDataPrefetch.cpp（循环数据预取）
• LoopDeletion.cpp（删除无用循环）
• LoopDistribute.cpp（循环分解）
• LoopFlatten.cpp（循环扁平化）
• LoopFuse.cpp（循环合并）
• LoopIdiomRecognize.cpp（循环惯用优化识别）
• LoopInstSimplify.cpp（循环指令简化）
• LoopInterchange.cpp（循环置换优化）
• LoopLoadElimination.cpp（消除不必要的循环加载）
• `LoopPassManager.cpp`（循环 Pass 管理器）
• LoopPredication.cpp（循环谓词优化）
• LoopRotation.cpp（循环旋转优化）
• LoopSimplifyCFG.cpp（循环 CFG 简化）
• LoopSink.cpp（循环代码下沉）
• LoopStrengthReduce.cpp（循环强度削弱）
• LoopTermFold.cpp（循环终止折叠）
• LoopUnrollPass.cpp（循环展开）
• LoopUnrollAndJamPass.cpp（循环展开并融合）
• LoopVersioningLICM.cpp（循环版本化 + LICM）

控制流优化

这些 Pass 主要用于 优化控制流（CFG），减少不必要的跳转：

• FlattenCFGPass.cpp（扁平化控制流图）
• JumpTableToSwitch.cpp（将跳转表转换为 switch 语句）
• JumpThreading.cpp（跳转优化，减少不必要分支）
• SimplifyCFGPass.cpp（简化控制流图）
• StructurizeCFG.cpp（控制流结构化优化）
• TailRecursionElimination.cpp（尾递归消除）

代码转换 & 标量替换

这些 Pass 主要用于 变量提升、指令替换、标量化：

• Mem2Reg.cpp（内存变量提升到寄存器）
• Reg2Mem.cpp（寄存器变量转换回内存）
• SROA.cpp（结构化对象分析）（Scalar Replacement of Aggregates）
  • 将结构体、数组等“聚合类型”的栈内分配变量，拆成多个独立的标量变量，以便进一步优化。
• Scalarizer.cpp（标量化）
• ScalarizeMaskedMemIntrin.cpp（标量化 Masked 内存指令）

代码猜测 & 推测执行

这些 Pass 主要用于 预测分支、推测执行、消除不必要的检查：

• ConstraintElimination.cpp（约束消除）
• CorrelatedValuePropagation.cpp（相关值传播）
• DivRemPairs.cpp（优化除法/取余对）
• Float2Int.cpp（浮点转整数优化）
• InferAddressSpaces.cpp（推测地址空间）
• InferAlignment.cpp（推测对齐方式）
• InstSimplifyPass.cpp（指令简化）
• MakeGuardsExplicit.cpp（显式化 Guard 语句）
• NaryReassociate.cpp（N 元重关联优化）
• Reassociate.cpp（表达式重关联）
• SpeculativeExecution.cpp（推测执行优化）

安全性 & 运行时优化

这些 Pass 主要用于 运行时安全 & GC 相关优化：

• LowerGuardIntrinsic.cpp（降低 Guard 指令）
• LowerExpectIntrinsic.cpp（降低 __builtin_expect 指令）
• LowerConstantIntrinsics.cpp（降低常量内置函数）
• LowerAtomicPass.cpp（降低原子操作）
• LowerMatrixIntrinsics.cpp（降低矩阵指令）
• LowerWidenableCondition.cpp（降低可扩展条件）
• PlaceSafepoints.cpp（安全点插入）
• RewriteStatepointsForGC.cpp（GC 相关优化）
• SeparateConstOffsetFromGEP.cpp（GEP 指针偏移优化）

代码移动 & 其他优化

• MergedLoadStoreMotion.cpp（合并 Load/Store 语句）
• MergeICmps.cpp（合并整数比较指令）
• Sink.cpp（代码下沉）
• StraightLineStrengthReduce.cpp（直线代码强度削弱）
• WarnMissedTransforms.cpp（提示未进行的优化）

IPO

LLVM lib/Transforms/IPO/ 目录包含 跨过程优化（Interprocedural Optimizations, IPO） 相关的 Pass，主要用于 跨函数、跨模块优化，提升整个程序的优化效果。可以将这些 Pass 归类如下：

内联优化

这些 Pass 主要用于 函数内联，减少函数调用开销：

• AlwaysInliner.cpp（强制内联特定函数，如 always_inline 标记的函数）
• Inliner.cpp（标准内联优化）
• ModuleInliner.cpp（模块级内联）
• FunctionImport.cpp（跨模块函数导入，用于 ThinLTO）
• PartialInlining.cpp（部分内联优化）

全程序优化

这些 Pass 主要用于 全程序范围的优化，如 去除无用代码：

• GlobalDCE.cpp（全局死代码消除）
• GlobalOpt.cpp（全局变量优化）
• GlobalSplit.cpp（全局变量拆分优化）
• ElimAvailExtern.cpp（去除无用的 extern 声明）
• WholeProgramDevirt.cpp（全程序虚函数去虚拟化）
• IPO.cpp（IPO 入口 Pass）

函数级优化

这些 Pass 主要用于 优化函数的调用方式、属性和结构：

• FunctionAttrs.cpp（函数属性推导）
• ForceFunctionAttrs.cpp（强制应用函数属性）
• InferFunctionAttrs.cpp（推导缺失的函数属性）
• FunctionSpecialization.cpp（函数特化）
• ArgumentPromotion.cpp（函数参数提升）
• DeadArgumentElimination.cpp（死参数消除）
• CalledValuePropagation.cpp（调用值传播优化）
• SCCP.cpp（稀疏条件常量传播，用于跨函数优化）

代码裁剪 & 符号优化（Code Stripping & Symbol Optimization）

这些 Pass 主要用于 减少无用的符号、元数据、原型：

• StripSymbols.cpp（移除符号）
• StripDeadPrototypes.cpp（移除未使用的函数原型）
• Annotation2Metadata.cpp（将注解转换为元数据）

代码合并 & 结构优化（Code Merging & Structure Optimization）

这些 Pass 主要用于 合并相似代码，减少冗余：

• MergeFunctions.cpp（合并相同或相似函数）
• IROutliner.cpp（IR 代码模式提取优化）

并行 & 线程优化（Parallel & Thread Optimizations）

这些 Pass 主要用于 优化 OpenMP 及并行代码：

• OpenMPOpt.cpp（OpenMP 代码优化）
• BarrierNoopPass.cpp（OpenMP 屏障优化）

控制流优化（Control Flow Optimizations）

这些 Pass 主要用于 控制流的简化和改进：

• HotColdSplitting.cpp（冷热代码拆分）
• BlockExtractor.cpp（提取基本块）
• LoopExtractor.cpp（提取循环到独立函数）

类型、检查与安全性优化（Type, Check & Security Optimizations）

这些 Pass 主要用于 类型测试、内存安全及跨模块安全优化：

• LowerTypeTests.cpp（优化类型检查）
• MemProfContextDisambiguation.cpp（基于内存分析的优化）
• CrossDSOCFI.cpp（跨动态库的控制流完整性优化）

采样分析 & 反馈优化（Profile-Guided & Sample-Based Optimizations）

这些 Pass 主要用于 基于采样分析的优化：

• SampleProfile.cpp（采样分析）
• SampleProfileMatcher.cpp（采样匹配优化）
• SampleProfileProbe.cpp（插入采样探针）
• SampleContextTracker.cpp（采样上下文追踪）

代码嵌入 & Bitcode 相关（Bitcode Embedding & LTO）

这些 Pass 主要用于 代码嵌入和 LTO（Link-Time Optimization）：

• EmbedBitcodePass.cpp（嵌入 Bitcode）
• ThinLTOBitcodeWriter.cpp（ThinLTO Bitcode 写入）

Vectorize

LLVM lib/Transforms/Vectorize/ 目录主要包含 矢量化（Vectorization）优化 Pass，用于将 标量代码转换为 SIMD 矢量代码，以提高指令级并行性。可以将这些 Pass 归类如下：

循环矢量化（Loop Vectorization）

这些 Pass 主要用于 对循环进行矢量化，使其能够利用 SIMD 指令：

• LoopVectorize.cpp（循环矢量化核心 Pass）
• LoopIdiomVectorize.cpp（循环惯用优化矢量化）
• LoopVectorizationLegality.cpp（循环矢量化合法性检查）
• LoopVectorizationPlanner.h（循环矢量化规划）

语句级矢量化（SLP Vectorization）

这些 Pass 主要用于 合并独立语句，形成 SIMD 操作：

• SLPVectorizer.cpp（Superword Level Parallelism 矢量化）
• VectorCombine.cpp（矢量化合并优化）
• Vectorize.cpp（矢量化 Pass 入口）

VPlan 矢量化框架（VPlan - Vectorization Planning）

LLVM 使用 VPlan 框架来管理矢量化策略，以下文件负责 VPlan 构建、分析、优化：

• VPlan.cpp（VPlan 主要逻辑）
• VPlan.h（VPlan 头文件）
• VPlanAnalysis.cpp（VPlan 分析）
• VPlanDominatorTree.h（VPlan 支配树）
• VPlanHCFGBuilder.cpp（VPlan 层次控制流图构建）
• VPlanRecipes.cpp（VPlan 矢量化转换规则）
• VPlanSLP.cpp（VPlan 结合 SLP 矢量化）
• VPlanTransforms.cpp（VPlan 变换优化）
• VPlanVerifier.cpp（VPlan 验证）
• VPlanUnroll.cpp（VPlan 循环展开）
• VPlanUtils.cpp（VPlan 辅助工具）

Sandbox 矢量化器

SandboxVectorizer/ 目录包含一个实验性矢量化器，尝试更高级的矢量化技术：

• SandboxVectorizer.cpp（Sandbox 矢量化核心逻辑）
• SandboxVectorizerPassBuilder.cpp（Pass 生成器）
• Legality.cpp（矢量化合法性分析）
• Scheduler.cpp（矢量化调度）
• DependencyGraph.cpp（依赖图构建）
• Interval.cpp（区间分析）
• SeedCollector.cpp（种子收集器）
• Passes/（存放其他辅助 Pass）

Analyze Passes

见附录：[附录 A PassRegistry 全解]( #附录-A PassRegistry 全解)

优化示例

下面将给出重要 LLVM 中端优化例子的具体变化

ADCE

; ===== 优化前 =====
define i32 @example(i1 %cond) {
entry:
  %a = add i32 1, 2             ; ← 未使用的计算
  %b = mul i32 3, 4             ; ← 未使用的计算
  br i1 %cond, label %iftrue, label %iffalse

iftrue:
  ret i32 42

iffalse:
  ret i32 0
}

; ===== 优化后 =====
define i32 @example(i1 %cond) {
entry:
  br i1 %cond, label %iftrue, label %iffalse  ; ← 已删除 %a 和 %b

iftrue:
  ret i32 42

iffalse:
  ret i32 0
}

BDCE

; ===== 优化前 =====
define void @example(i1 %cond) {
entry:
  br i1 %cond, label %dead, label %live

dead:                                        ; ← 死分支
  %a = add i32 1, 2                          ; ← 无副作用指令
  br label %exit

live:
  br label %exit

exit:
  ret void
}

; ===== 优化后 =====
define void @example(i1 %cond) {
entry:
  br i1 %cond, label %live, label %live      ; ← 跳过死分支

live:
  br label %exit

exit:
  ret void
}

EarlyCSE

; ===== 优化前 =====
define i32 @example(i32 %x) {
entry:
  %a = add i32 %x, 1         ; ← 计算1
  %b = add i32 %x, 1         ; ← 计算重复
  %c = mul i32 %b, 2
  ret i32 %c
}

; ===== 优化后 =====
define i32 @example(i32 %x) {
entry:
  %a = add i32 %x, 1         ; ← 计算1
  ; %b 被消除，以下使用 %a 替代
  %c = mul i32 %a, 2
  ret i32 %c
}

GVN

; ===== 优化前 =====
define i32 @example(i32 %x, i32 %y) {
entry:
  %a = add i32 %x, %y           ; ← 计算1
  br label %next

next:
  %b = add i32 %x, %y           ; ← 冗余计算
  %c = mul i32 %b, 2
  ret i32 %c
}

; ===== 优化后 =====
define i32 @example(i32 %x, i32 %y) {
entry:
  %a = add i32 %x, %y           ; ← 计算1
  br label %next

next:
  ; %b 被替换为 %a
  %c = mul i32 %a, 2
  ret i32 %c
}

GVNHoist

; ===== 优化前 =====
define i32 @example(i32 %x, i1 %cond) {
entry:
  br i1 %cond, label %iftrue, label %iffalse

iftrue:
  %a = mul i32 %x, 2           ; ← 相同指令1
  br label %merge

iffalse:
  %b = mul i32 %x, 2           ; ← 相同指令2
  br label %merge

merge:
  %phi = phi i32 [%a, %iftrue], [%b, %iffalse]
  ret i32 %phi
}

; ===== 优化后 =====
define i32 @example(i32 %x, i1 %cond) {
entry:
  %hoist = mul i32 %x, 2       ; ← 上提到共同前驱
  br i1 %cond, label %iftrue, label %iffalse

iftrue:
  br label %merge

iffalse:
  br label %merge

merge:
  ; 删除 phi，直接使用 hoist
  ret i32 %hoist
}

SCCP

; ===== 优化前 =====
define i32 @example() {
entry:
  %a = add i32 2, 3               ; ← 常量计算
  %cond = icmp eq i32 %a, 5       ; ← 恒为真
  br i1 %cond, label %then, label %else

then:
  ret i32 42

else:
  ret i32 0
}

; ===== 优化后 =====
define i32 @example() {
entry:
  ; %a 和 %cond 被常量传播消除
  ret i32 42                     ; ← 已知cond恒为真，直接跳转
}

LICM

; ===== 优化前 =====
define i32 @example(i32* %A, i32 %n) {
entry:
  br label %loop

loop:
  %i = phi i32 [0, %entry], [%inc, %loop]
  %c = mul i32 %n, 2           ; ← 循环不变，可外提
  %v = load i32, i32* %A
  %x = add i32 %c, %v
  %inc = add i32 %i, 1
  %cond = icmp slt i32 %inc, 10
  br i1 %cond, label %loop, label %exit

exit:
  ret i32 %x
}

; ===== 优化后 =====
define i32 @example(i32* %A, i32 %n) {
entry:
  %c = mul i32 %n, 2           ; ← 已外提至循环前
  br label %loop

loop:
  %i = phi i32 [0, %entry], [%inc, %loop]
  %v = load i32, i32* %A
  %x = add i32 %c, %v
  %inc = add i32 %i, 1
  %cond = icmp slt i32 %inc, 10
  br i1 %cond, label %loop, label %exit

exit:
  ret i32 %x
}

IndVarSimplify

; ===== 优化前 =====
define void @example() {
entry:
  br label %loop

loop:
  %i = phi i32 [0, %entry], [%inc, %loop]
  %val = mul i32 %i, 2              ; ← 冗余的乘法
  %inc = add i32 %i, 1
  %cond = icmp slt i32 %inc, 10
  br i1 %cond, label %loop, label %exit

exit:
  ret void
}

; ===== 优化后 =====
define void @example() {
entry:
  br label %loop

loop:
  %i = phi i32 [0, %entry], [%inc, %loop]
  ; %val 被删除，改为使用简化后的表达式
  %inc = add i32 %i, 1
  %cond = icmp slt i32 %inc, 10
  br i1 %cond, label %loop, label %exit

exit:
  ret void
}

LoopBoundSplit

; ===== 优化前 =====
define void @loop(i32 %n) {
entry:
  br label %loop

loop:
  %i = phi i32 [ 0, %entry ], [ %inc, %loop ]
  call void @sideeffect(i32 %i)
  %inc = add i32 %i, 1
  %cmp = icmp slt i32 %inc, %n
  br i1 %cmp, label %loop, label %exit

exit:
  ret void
}

; ===== 优化后 =====
define void @loop(i32 %n) {
entry:
  %cmp.bound = icmp slt i32 %n, 10              ; ← 添加边界判断
  br i1 %cmp.bound, label %loop.fast, label %loop.slow

loop.fast:                                      ; ← 快路径（已知边界）
  %i.fast = phi i32 [ 0, %entry ], [ %inc.fast, %loop.fast ]
  call void @sideeffect(i32 %i.fast)
  %inc.fast = add i32 %i.fast, 1
  %cmp.fast = icmp slt i32 %inc.fast, %n
  br i1 %cmp.fast, label %loop.fast, label %exit

loop.slow:                                      ; ← 慢路径（未知边界）
  %i.slow = phi i32 [ 0, %entry ], [ %inc.slow, %loop.slow ]
  call void @sideeffect(i32 %i.slow)
  %inc.slow = add i32 %i.slow, 1
  %cmp.slow = icmp slt i32 %inc.slow, %n
  br i1 %cmp.slow, label %loop.slow, label %exit

exit:
  ret void
}

LoopDistribute

; ===== 优化前 =====
define void @example(ptr %a, ptr %b) {
entry:
  br label %loop

loop:
  %i = phi i32 [ 0, %entry ], [ %inc, %loop ]
  %ld = load i32, ptr %a       ; ← 可能依赖较多
  store i32 %ld, ptr %b        ; ← 存储操作
  call void @sideeffect()      ; ← 有副作用，影响并行
  %inc = add i32 %i, 1
  %cmp = icmp slt i32 %inc, 100
  br i1 %cmp, label %loop, label %exit

exit:
  ret void
}

; ===== 优化后 =====
define void @example(ptr %a, ptr %b) {
entry:
  br label %loop.1

loop.1:
  %i1 = phi i32 [ 0, %entry ], [ %inc1, %loop.1 ]
  %ld = load i32, ptr %a       ; ← 已分离
  store i32 %ld, ptr %b
  %inc1 = add i32 %i1, 1
  %cmp1 = icmp slt i32 %inc1, 100
  br i1 %cmp1, label %loop.1, label %loop.2

loop.2:
  %i2 = phi i32 [ 0, %loop.1 ], [ %inc2, %loop.2 ]
  call void @sideeffect()      ; ← 分配到独立循环
  %inc2 = add i32 %i2, 1
  %cmp2 = icmp slt i32 %inc2, 100
  br i1 %cmp2, label %loop.2, label %exit

exit:
  ret void
}

LoopFlatten

; ===== 优化前 =====
define void @nested_loops() {
entry:
  br label %outer

outer:
  %i = phi i32 [ 0, %entry ], [ %i_next, %outer_inc ]
  br label %inner

inner:
  %j = phi i32 [ 0, %outer ], [ %j_next, %inner_inc ]
  ; body
  %j_next = add i32 %j, 1
  %j_cond = icmp slt i32 %j_next, 10
  br i1 %j_cond, label %inner_inc, label %outer_inc

inner_inc:
  br label %inner

outer_inc:
  %i_next = add i32 %i, 1
  %i_cond = icmp slt i32 %i_next, 10
  br i1 %i_cond, label %outer, label %exit

exit:
  ret void
}

; ===== 优化后 =====
define void @nested_loops() {
entry:
  br label %flat

flat:
  %idx = phi i32 [ 0, %entry ], [ %idx_next, %flat ]
  ; body using %i = udiv idx, 10 and %j = urem idx, 10  ← 展开索引
  %idx_next = add i32 %idx, 1
  %cond = icmp slt i32 %idx_next, 100                ; ← 合并循环条件
  br i1 %cond, label %flat, label %exit

exit:
  ret void
}

LoopFuse

; ===== 优化前 =====
define void @example(ptr %A, ptr %B) {
entry:
  br label %loop1

loop1:
  %i1 = phi i32 [0, %entry], [%inc1, %loop1]
  %a = getelementptr i32, ptr %A, i32 %i1
  store i32 1, ptr %a                    ; ← 第一个循环体
  %inc1 = add i32 %i1, 1
  %cond1 = icmp slt i32 %inc1, 100
  br i1 %cond1, label %loop1, label %between

between:
  br label %loop2

loop2:
  %i2 = phi i32 [0, %between], [%inc2, %loop2]
  %b = getelementptr i32, ptr %B, i32 %i2
  store i32 2, ptr %b                    ; ← 第二个循环体
  %inc2 = add i32 %i2, 1
  %cond2 = icmp slt i32 %inc2, 100
  br i1 %cond2, label %loop2, label %exit

exit:
  ret void
}

; ===== 优化后 =====
define void @example(ptr %A, ptr %B) {
entry:
  br label %loop

loop:
  %i = phi i32 [0, %entry], [%inc, %loop]
  %a = getelementptr i32, ptr %A, i32 %i
  store i32 1, ptr %a                    ; ← 合并后的循环体：原loop1
  %b = getelementptr i32, ptr %B, i32 %i
  store i32 2, ptr %b                    ; ← 合并后的循环体：原loop2
  %inc = add i32 %i, 1
  %cond = icmp slt i32 %inc, 100
  br i1 %cond, label %loop, label %exit

exit:
  ret void
}

附录-A PassRegistry 全解

MODULE_ANALYSIS("callgraph", CallGraphAnalysis())             // 构建和查询程序的调用图
MODULE_ANALYSIS("collector-metadata", CollectorMetadataAnalysis())   // 收集并管理自定义元数据
MODULE_ANALYSIS("ctx-prof-analysis", CtxProfAnalysis())       // 上下文敏感的 PG O（Profile-Guided Optimization）分析
MODULE_ANALYSIS("dxil-metadata", DXILMetadataAnalysis())      // 解析和存储 DXIL（DirectX Intermediate Language）元数据
MODULE_ANALYSIS("dxil-resources", DXILResourceAnalysis())     // 分析 DXIL 中的资源（纹理、缓冲区等）使用情况
MODULE_ANALYSIS("dxil-resource-type", DXILResourceTypeAnalysis()) // 推断和标记 DXIL 资源的类型信息
MODULE_ANALYSIS("inline-advisor", InlineAdvisorAnalysis())    // 建议内联优化点，辅助 inliner 做决策
MODULE_ANALYSIS("ir-similarity", IRSimilarityAnalysis())      // 检测和聚类相似的 IR 代码片段
MODULE_ANALYSIS("last-run-tracking", LastRunTrackingAnalysis()) // 跟踪上次运行时的变更和执行情况
MODULE_ANALYSIS("lcg", LazyCallGraphAnalysis())              // 延迟构建调用图，仅在需要时才生成节点/边
MODULE_ANALYSIS("module-summary", ModuleSummaryIndexAnalysis()) // 为跨模块优化生成模块摘要索引
MODULE_ANALYSIS("no-op-module", NoOpModuleAnalysis())         // 空操作分析，占位用，不做任何变换
MODULE_ANALYSIS("pass-instrumentation", PassInstrumentationAnalysis(PIC)) // 为 Pass 插装探针，收集运行时统计
MODULE_ANALYSIS("profile-summary", ProfileSummaryAnalysis()) // 汇总 PG O 分析结果，生成整体概要
MODULE_ANALYSIS("reg-usage", PhysicalRegisterUsageAnalysis()) // 分析物理寄存器的实际使用情况
MODULE_ANALYSIS("stack-safety", StackSafetyGlobalAnalysis()) // 全局栈安全分析，检测栈溢出风险
MODULE_ANALYSIS("verify", VerifierAnalysis())                // 验证 IR 的合法性和一致性
MODULE_ALIAS_ANALYSIS("globals-aa", GlobalsAA())             // 全局变量别名分析，识别不同全局变量间的别名关系
MODULE_PASS("always-inline", AlwaysInlinerPass())            // 强制将所有调用点内联被标记的函数
MODULE_PASS("annotation2metadata", Annotation2MetadataPass()) // 将自定义注解转换成 IR 元数据
MODULE_PASS("assign-guid", AssignGUIDPass())                 // 为 IR 指令分配全局唯一 ID（GUID）
MODULE_PASS("attributor", AttributorPass())                  // 属性推导框架，用于发现和传播函数/调用约束
MODULE_PASS("attributor-light", AttributorLightPass())       // 轻量级属性推导，仅执行快速检查
MODULE_PASS("called-value-propagation", CalledValuePropagationPass()) // 传播已调用函数的返回值常量
MODULE_PASS("canonicalize-aliases", CanonicalizeAliasesPass()) // 规范化别名，简化 `bitcast`/`getelementptr` 链
MODULE_PASS("check-debugify", NewPMCheckDebugifyPass())      // 检查并加入调试化信息，确保调试符号完整
MODULE_PASS("constmerge", ConstantMergePass())               // 合并相同常量的全局变量或常量表达式
MODULE_PASS("coro-cleanup", CoroCleanupPass())              // 清理协程生成的中间状态和标记
MODULE_PASS("coro-early", CoroEarlyPass())                   // 提前识别协程开始/结束点，为后续优化做准备
MODULE_PASS("cross-dso-cfi", CrossDSOCFIPass())              // 启用跨动态链接库的控制流完整性检查
MODULE_PASS("ctx-instr-gen", PGOInstrumentationGen(PGOInstrumentationType::CTXPROF)) // 生成上下文敏感的 PG O 插装指令
MODULE_PASS("ctx-prof-flatten", PGOCtxProfFlatteningPass(/*IsPreThinlink=*/false)) // 对上下文敏感的 PG O 插装数据执行展平，合并相同调用上下文的配置
MODULE_PASS("ctx-prof-flatten-prethinlink",         PGOCtxProfFlatteningPass(/*IsPreThinlink=*/true)) // 在 ThinLTO 链接前执行上下文敏感展平，以便后续跨模块 LTO 使用
MODULE_PASS("noinline-nonprevailing", NoinlineNonPrevailing()) // 避免对非主导（non-prevailing）函数进行内联，以减少代码爆炸
MODULE_PASS("deadargelim", DeadArgumentEliminationPass()) // 消除函数中未使用的参数，删除多余的入参
MODULE_PASS("debugify", NewPMDebugifyPass()) // 向 IR 中注入完整的调试信息，便于后续验证和调试
MODULE_PASS("dfsan", DataFlowSanitizerPass()) // 插装 DataFlowSanitizer 检测指针和数据流的安全性
MODULE_PASS("dot-callgraph", CallGraphDOTPrinterPass()) // 将调用图导出为 DOT 格式，便于用 Graphviz 可视化
MODULE_PASS("dxil-upgrade", DXILUpgradePass()) // 升级 DXIL IR 到最新规范，更新过时指令和元数据
MODULE_PASS("elim-avail-extern", EliminateAvailableExternallyPass()) // 删除标记为 available_externally 的函数/全局变量，减小模块大小
MODULE_PASS("extract-blocks", BlockExtractorPass({}, false)) // 抽取指定基本块到新函数，支持代码分离和分析
MODULE_PASS("expand-variadics", ExpandVariadicsPass(ExpandVariadicsMode::Disable)) // 将可变参数函数展开为固定参数形式（此处禁用，仅分析用途）
MODULE_PASS("forceattrs", ForceFunctionAttrsPass()) // 强制根据函数实现添加或修改属性（如NoUnwind、ReadNone等）
MODULE_PASS("function-import", FunctionImportPass()) // 在跨模块优化中导入函数定义，实现内联和优化传递
MODULE_PASS("global-merge-func", GlobalMergeFuncPass()) // 合并功能相同的全局函数，消除重复实现
MODULE_PASS("globalopt", GlobalOptPass()) // 全局范围优化，包括常量传播、死代码删除、CFG 简化
MODULE_PASS("globalsplit", GlobalSplitPass()) // 将全局变量拆分为热/冷区域，提高缓存局部性
MODULE_PASS("hipstdpar-interpose-alloc", HipStdParAllocationInterpositionPass()) // 对 HIP 标准并行分配调用插装拦截，用于分析或模拟
MODULE_PASS("hipstdpar-select-accelerator-code",         HipStdParAcceleratorCodeSelectionPass()) // 根据目标加速器选择最优代码路径（比如 GPU vs CPU）
MODULE_PASS("hotcoldsplit", HotColdSplittingPass()) // 将函数或基本块按热度拆分成热/冷部分，优化指令缓存
MODULE_PASS("inferattrs", InferFunctionAttrsPass()) // 基于函数体分析推断可用属性（如纯函数、无副作用等）
MODULE_PASS("inliner-ml-advisor-release",         ModuleInlinerWrapperPass(getInlineParams(), true, {}, InliningAdvisorMode::Release, 0)) // 使用机器学习模型建议内联，针对 Release 构建收集统计并执行内联
MODULE_PASS("inliner-wrapper", ModuleInlinerWrapperPass()) // 通用模块内联包装器，根据参数动态决定内联行为
MODULE_PASS("inliner-wrapper-no-mandatory-first",         ModuleInlinerWrapperPass(getInlineParams(), false)) // 模块内联包装器（不优先处理强制内联），优化裁剪内联顺序
MODULE_PASS("insert-gcov-profiling", GCOVProfilerPass()) // 插装 GCOV 覆盖率分析点，生成运行时覆盖率数据
MODULE_PASS("instrprof", InstrProfilingLoweringPass()) // 将 InstrumentationProfiler 插装调用下沉到 IR 中，生成测量钩子
MODULE_PASS("ctx-instr-lower", PGOCtxProfLoweringPass()) // 将上下文敏感 PG O 插装高层接口下沉为低级钩子
MODULE_PASS("print\<ctx-prof-analysis>", CtxProfAnalysisPrinterPass(errs())) // 打印上下文敏感 PG O 分析结果到标准错误流
MODULE_PASS("invalidate<all>", InvalidateAllAnalysesPass()) // 在模块变更后使所有分析结果失效，确保数据一致性
MODULE_PASS("iroutliner", IROutlinerPass()) // 将重复 IR 模式抽取为函数，提高代码重用性和紧凑性
MODULE_PASS("jmc-instrumenter", JMCInstrumenterPass()) // 插装 Just-My-Code 跟踪点，仅记录用户代码执行
MODULE_PASS("lower-emutls", LowerEmuTLSPass()) // 将仿真 TLS 操作转换为显式内存访问，支持无本地 TLS 的目标
MODULE_PASS("lower-global-dtors", LowerGlobalDtorsPass()) // 将全局析构函数列表转换为显式函数调用
MODULE_PASS("lower-ifunc", LowerIFuncPass()) // 将基于 GNU IFUNC 的可重定位函数解析转为直接调用
MODULE_PASS("lowertypetests", LowerTypeTestsPass()) // 将类型测试（type tests）内建指令降级为显式检查
MODULE_PASS("fatlto-cleanup", FatLtoCleanup())  // 清理 FatLTO 中间产生的数据和标记，恢复模块基本状态
MODULE_PASS("pgo-force-function-attrs", PGOForceFunctionAttrsPass(PGOOpt ? PGOOpt->ColdOptType : PGOOptions::ColdFuncOpt::Default)) // 基于 PGO 冷调用分析，强制为函数添加冷/热属性
MODULE_PASS("memprof-context-disambiguation", MemProfContextDisambiguation()) // 在 MemProf 中为不同调用上下文分离内存访问，消除歧义
MODULE_PASS("memprof-module", ModuleMemProfilerPass()) // 为模块插装内存访问探针，生成运行时追踪
MODULE_PASS("mergefunc", MergeFunctionsPass()) // 合并相似或等价函数，减少代码重复
MODULE_PASS("metarenamer", MetaRenamerPass()) // 对 IR 元素（函数、变量）进行可读性重命名
MODULE_PASS("module-inline", ModuleInlinerPass()) // 模块级函数内联，执行常规内联转换
MODULE_PASS("name-anon-globals", NameAnonGlobalPass()) // 为匿名全局符号生成唯一名称，便于调试和分析
MODULE_PASS("no-op-module", NoOpModulePass()) // 空操作 Pass，占位测试
MODULE_PASS("nsan", NumericalStabilitySanitizerPass()) // 插装检测数值计算稳定性问题
MODULE_PASS("objc-arc-apelim", ObjCARCAPElimPass()) // Objective-C ARC 模式下消除不必要的自动引用计数调用
MODULE_PASS("openmp-opt", OpenMPOptPass()) // 针对 OpenMP 并行指令进行优化
MODULE_PASS("openmp-opt-postlink", OpenMPOptPass(ThinOrFullLTOPhase::FullLTOPostLink)) // 全链接后对 OpenMP 代码进行二次优化
MODULE_PASS("partial-inliner", PartialInlinerPass()) // 部分内联，仅内联小函数或满足阈值的函数
MODULE_PASS("pgo-icall-prom", PGOIndirectCallPromotion()) // PGO 基于探测数据将间接调用提升为直接调用
MODULE_PASS("pgo-instr-gen", PGOInstrumentationGen()) // 生成 PGO 探针插装
MODULE_PASS("pgo-instr-use", PGOInstrumentationUse()) // 使用先前插装的 PGO 数据进行优化
MODULE_PASS("pre-isel-intrinsic-lowering", PreISelIntrinsicLoweringPass(TM)) // 在选择指令前将内建函数降级为标准 IR
MODULE_PASS("print", PrintModulePass(errs())) // 打印模块 IR 到 stderr
MODULE_PASS("print-callgraph", CallGraphPrinterPass(errs())) // 打印调用图文本到 stderr
MODULE_PASS("print-callgraph-sccs", CallGraphSCCsPrinterPass(errs())) // 打印调用图强连通分量到 stderr
MODULE_PASS("print-ir-similarity", IRSimilarityAnalysisPrinterPass(errs())) // 打印 IR 相似度分组结果到 stderr
MODULE_PASS("print-lcg", LazyCallGraphPrinterPass(errs())) // 打印延迟调用图到 stderr
MODULE_PASS("print-lcg-dot", LazyCallGraphDOTPrinterPass(errs())) // 以 DOT 格式打印延迟调用图
MODULE_PASS("print-must-be-executed-contexts", MustBeExecutedContextPrinterPass(errs())) // 打印必定执行上下文分析结果到 stderr
MODULE_PASS("print-profile-summary", ProfileSummaryPrinterPass(errs())) // 打印 PGO 概要报告到 stderr
MODULE_PASS("print-stack-safety", StackSafetyGlobalPrinterPass(errs())) // 打印栈安全分析结果到 stderr
MODULE_PASS("print\<dxil-metadata>", DXILMetadataAnalysisPrinterPass(errs())) // 打印 DXIL 元数据分析结果到 stderr
MODULE_PASS("print\<dxil-resources>", DXILResourcePrinterPass(errs())) // 打印 DXIL 资源分析结果到 stderr
MODULE_PASS("print\<inline-advisor>", InlineAdvisorAnalysisPrinterPass(errs())) // 打印内联建议分析结果到 stderr
MODULE_PASS("print\<module-debuginfo>", ModuleDebugInfoPrinterPass(errs())) // 打印模块调试信息到 stderr
MODULE_PASS("print\<reg-usage>", PhysicalRegisterUsageInfoPrinterPass(errs())) // 打印物理寄存器使用信息到 stderr
MODULE_PASS("pseudo-probe", SampleProfileProbePass(TM)) // 插装伪探针以支持低开销性能分析
MODULE_PASS("pseudo-probe-update", PseudoProbeUpdatePass()) // 更新和合并伪探针信息
MODULE_PASS("recompute-globalsaa", RecomputeGlobalsAAPass()) // 重新计算全局别名分析以反映最新 IR 改动
MODULE_PASS("rel-lookup-table-converter", RelLookupTableConverterPass()) // 转换相对查找表以优化运行时查找性能
MODULE_PASS("rewrite-statepoints-for-gc", RewriteStatepointsForGC()) // 重写 GC 状态点以支持精确垃圾回收
MODULE_PASS("rewrite-symbols", RewriteSymbolPass()) // 重写符号名称或链接属性，支持虚拟化或混淆
MODULE_PASS("rpo-function-attrs", ReversePostOrderFunctionAttrsPass()) // 按反后序遍历顺序推断函数属性以提升分析精度
MODULE_PASS("rtsan", RealtimeSanitizerPass()) // 插装实时 Sanitizer 以检测运行时错误
MODULE_PASS("sample-profile", SampleProfileLoaderPass()) // 加载采样分析配置并插装采样探针
MODULE_PASS("sancov-module", SanitizerCoveragePass()) // 插装 Sanitizer 覆盖率探针以收集执行路径覆盖信息
MODULE_PASS("sanmd-module", SanitizerBinaryMetadataPass()) // 生成二进制级别 Sanitizer 元数据
MODULE_PASS("scc-oz-module-inliner", buildInlinerPipeline(OptimizationLevel::Oz, ThinOrFullLTOPhase::None)) // 构建针对 Oz 优化级别的 SCC 内联流水线
MODULE_PASS("shadow-stack-gc-lowering", ShadowStackGCLoweringPass()) // 将 Shadow Stack GC 转换为显式指令序列
MODULE_PASS("strip", StripSymbolsPass()) // 删除所有符号表信息以减小二进制大小
MODULE_PASS("strip-dead-debug-info", StripDeadDebugInfoPass()) // 删除未引用的调试信息以加快加载速度
MODULE_PASS("strip-dead-prototypes", StripDeadPrototypesPass()) // 删除无用的函数原型声明
MODULE_PASS("strip-debug-declare", StripDebugDeclarePass()) // 删除 llvm.dbg.declare 调试声明
MODULE_PASS("strip-nondebug", StripNonDebugSymbolsPass()) // 删除非调试符号，仅保留调试相关符号
MODULE_PASS("strip-nonlinetable-debuginfo", StripNonLineTableDebugInfoPass()) // 删除行号表以外的调试信息
MODULE_PASS("strip-dead-cg-profile", StripDeadCGProfilePass()) // 删除无用的调用图配置文件数据
MODULE_PASS("trigger-crash-module", TriggerCrashModulePass()) // 强制引发崩溃以测试 Pass 管道的鲁棒性
MODULE_PASS("trigger-verifier-error", TriggerVerifierErrorPass()) // 强制触发验证器错误以测试验证流程
MODULE_PASS("tsan-module", ModuleThreadSanitizerPass()) // 插装线程 Sanitizer 以检测数据竞争
MODULE_PASS("tysan", TypeSanitizerPass()) // 插装类型 Sanitizer 以检测内存越界和类型混用
MODULE_PASS("verify", VerifierPass()) // 验证所有 IR 变换后的合法性以确保无错误
MODULE_PASS("view-callgraph", CallGraphViewerPass()) // 以图形化方式展示调用图（依赖 GUI）
MODULE_PASS("wholeprogramdevirt", WholeProgramDevirtPass()) // 全程序级虚函数去虚化，转为直接调用
MODULE_PASS_WITH_PARAMS("asan", "AddressSanitizerPass", [](AddressSanitizerOptions Opts){return AddressSanitizerPass(Opts);}, parseASanPassOptions, "kernel") // 插装 AddressSanitizer 以检测内存越界和使用后释放
MODULE_PASS_WITH_PARAMS("cg-profile", "CGProfilePass", [](bool InLTOPostLink){return CGProfilePass(InLTOPostLink);}, parseCGProfilePassOptions, "in-lto-post-link") // 基于调用图数据插装或使用调用图分析
MODULE_PASS_WITH_PARAMS("global-merge", "GlobalMergePass", [TM=TM](GlobalMergeOptions Opts){return GlobalMergePass(TM, Opts);}, parseGlobalMergeOptions, "group-by-use;ignore-single-use;…") // 按多种策略合并全局变量以减少冗余
MODULE_PASS_WITH_PARAMS("embed-bitcode", "EmbedBitcodePass", [](EmbedBitcodeOptions Opts){return EmbedBitcodePass(Opts);}, parseEmbedBitcodePassOptions, "thinlto;emit-summary") // 将 Bitcode 嵌入到目标文件，支持 LTO 和摘要导出
MODULE_PASS_WITH_PARAMS("globaldce", "GlobalDCEPass", [](bool InLTOPostLink){return GlobalDCEPass(InLTOPostLink);}, parseGlobalDCEPassOptions, "in-lto-post-link") // 删除全局范围内不可达的函数和变量
MODULE_PASS_WITH_PARAMS("hwasan", "HWAddressSanitizerPass", [](HWAddressSanitizerOptions Opts){return HWAddressSanitizerPass(Opts);}, parseHWASanPassOptions, "kernel;recover") // 插装硬件辅助 ASan 检测，并可选择恢复模式
MODULE_PASS_WITH_PARAMS("internalize", "InternalizePass", [](SmallVector<std::string,0> PreservedGVs){…return InternalizePass(MustPreserveGV);}, parseInternalizeGVs, "preserve-gv=GV") // 将非保留全局符号标记为内部可见，优化符号导出
MODULE_PASS_WITH_PARAMS("ipsccp", "IPSCCPPass", [](IPSCCPOptions Opts){return IPSCCPPass(Opts);}, parseIPSCCPOptions, "no-func-spec;func-spec") // 在跨函数常量传播中应用间过程 SCCP 分析
MODULE_PASS_WITH_PARAMS("loop-extract", "LoopExtractorPass", [](bool Single){return Single? LoopExtractorPass(1): LoopExtractorPass();}, parseLoopExtractorPassOptions, "single") // 从循环体中提取基本块用于独立分析或优化
MODULE_PASS_WITH_PARAMS("memprof-use", "MemProfUsePass", [](std::string Opts){return MemProfUsePass(Opts);}, parseMemProfUsePassOptions, "profile-filename=S") // 指定采样文件并插装内存使用采样分析
MODULE_PASS_WITH_PARAMS("msan", "MemorySanitizerPass", [](MemorySanitizerOptions Opts){return MemorySanitizerPass(Opts);}, parseMSanPassOptions, "recover;kernel;eager-checks;track-origins=N") // 插装 MemorySanitizer 检测未初始化内存读取
MODULE_PASS_WITH_PARAMS("print\<structural-hash>", "StructuralHashPrinterPass", [](StructuralHashOptions Options){return StructuralHashPrinterPass(errs(), Options);}, parseStructuralHashPrinterPassOptions, "detailed;call-target-ignored") // 打印结构哈希分析结果，支持详细和忽略调用目标选项
CGSCC_ANALYSIS("no-op-cgscc", NoOpCGSCCAnalysis()) // CGSCC 级别空操作分析，占位用
CGSCC_ANALYSIS("fam-proxy", FunctionAnalysisManagerCGSCCProxy()) // 在 CGSCC 管道中代理 FAM 分析结果
CGSCC_ANALYSIS("pass-instrumentation", PassInstrumentationAnalysis(PIC)) // 插装 CGSCC 级别的 Pass 运行时数据采集
CGSCC_PASS("argpromotion", ArgumentPromotionPass()) // 将函数内部可替换参数提升到寄存器以减少内存访问
CGSCC_PASS("attributor-cgscc", AttributorCGSCCPass()) // 在 CGSCC 级别运行属性推导
CGSCC_PASS("attributor-light-cgscc", AttributorLightCGSCCPass()) // 轻量级 CGSCC 属性推导
CGSCC_PASS("invalidate<all>", InvalidateAllAnalysesPass()) // 使 CGSCC 级别所有分析结果失效
CGSCC_PASS("no-op-cgscc", NoOpCGSCCPass()) // CGSCC 级别空操作 Pass
CGSCC_PASS("openmp-opt-cgscc", OpenMPOptCGSCCPass()) // 在 CGSCC 管道中优化 OpenMP 代码
CGSCC_PASS("coro-annotation-elide", CoroAnnotationElidePass()) // 消除协程注释以简化 CoroSplit 分析
CGSCC_PASS_WITH_PARAMS("coro-split", "CoroSplitPass", [](bool OptimizeFrame){return CoroSplitPass(OptimizeFrame);}, parseCoroSplitPassOptions, "reuse-storage") // 分裂协程帧，可重用存储选项
CGSCC_PASS_WITH_PARAMS("function-attrs", "PostOrderFunctionAttrsPass", [](bool SkipNonRecursive){return PostOrderFunctionAttrsPass(SkipNonRecursive);}, parsePostOrderFunctionAttrsPassOptions, "skip-non-recursive-function-attrs") // CGSCC 级别后序推断函数属性，可跳过非递归函数
CGSCC_PASS_WITH_PARAMS("inline", "InlinerPass", [](bool OnlyMandatory){return InlinerPass(OnlyMandatory);}, parseInlinerPassOptions, "only-mandatory") // CGSCC 级别仅内联强制标记的调用
FUNCTION_ANALYSIS("aa", AAManager()) // 构建和管理别名分析，检测指针可能指向的内存区域
FUNCTION_ANALYSIS("access-info", LoopAccessAnalysis()) // 分析循环中内存访问模式，支持安全优化
FUNCTION_ANALYSIS("assumptions", AssumptionAnalysis()) // 收集并利用假设条件以驱动优化决策
FUNCTION_ANALYSIS("bb-sections-profile-reader", BasicBlockSectionsProfileReaderAnalysis(TM)) // 从分段配置文件读取基本块执行频率信息
FUNCTION_ANALYSIS("block-freq", BlockFrequencyAnalysis()) // 基于配置或分析推断基本块执行频率
FUNCTION_ANALYSIS("branch-prob", BranchProbabilityAnalysis()) // 估算分支概率以辅助代码布局优化
FUNCTION_ANALYSIS("cycles", CycleAnalysis()) // 分析依赖图中的循环，以识别并行化机会
FUNCTION_ANALYSIS("da", DependenceAnalysis()) // 检测内存访问依赖关系，支持循环并行化和向量化
FUNCTION_ANALYSIS("debug-ata", DebugAssignmentTrackingAnalysis()) // 跟踪变量赋值以调试和分析数据流
FUNCTION_ANALYSIS("demanded-bits", DemandedBitsAnalysis()) // 识别实际使用的值位，支持位级别优化
FUNCTION_ANALYSIS("domfrontier", DominanceFrontierAnalysis()) // 构建支配边界，用于 SSA 重构和优化
FUNCTION_ANALYSIS("domtree", DominatorTreeAnalysis()) // 构建支配树，以便快速查询支配关系
FUNCTION_ANALYSIS("ephemerals", EphemeralValuesAnalysis()) // 分析短生命周期值，用于消除不必要的存储
FUNCTION_ANALYSIS("func-properties", FunctionPropertiesAnalysis()) // 推断函数属性（如无副作用、纯函数等）
FUNCTION_ANALYSIS("machine-function-info", MachineFunctionAnalysis(TM)) // 收集机器级函数信息，用于后端优化
FUNCTION_ANALYSIS("gc-function", GCFunctionAnalysis()) // 分析垃圾回收相关函数调用模式
FUNCTION_ANALYSIS("inliner-size-estimator", InlineSizeEstimatorAnalysis()) // 估算内联后代码规模，辅助内联决策
FUNCTION_ANALYSIS("last-run-tracking", LastRunTrackingAnalysis()) // 跟踪上次 Pass 运行状态以支持增量优化
FUNCTION_ANALYSIS("lazy-value-info", LazyValueAnalysis()) // 延迟评估值，以减少不必要的计算
FUNCTION_ANALYSIS("loops", LoopAnalysis()) // 检测并分类循环，支持后续循环优化
FUNCTION_ANALYSIS("memdep", MemoryDependenceAnalysis()) // 分析内存依赖，支持调度和并行优化
FUNCTION_ANALYSIS("memoryssa", MemorySSAAnalysis()) // 构建 MemorySSA，以便精确跟踪内存定义与使用
FUNCTION_ANALYSIS("no-op-function", NoOpFunctionAnalysis()) // 空操作分析，占位用
FUNCTION_ANALYSIS("opt-remark-emit", OptimizationRemarkEmitterAnalysis()) // 在优化过程中生成诊断报告
FUNCTION_ANALYSIS("pass-instrumentation", PassInstrumentationAnalysis(PIC)) // 插装函数级 Pass 运行统计采集
FUNCTION_ANALYSIS("phi-values", PhiValuesAnalysis()) // 分析 φ 节点的值域，用于常量传播
FUNCTION_ANALYSIS("postdomtree", PostDominatorTreeAnalysis()) // 构建后支配树，用于控制依赖分析
FUNCTION_ANALYSIS("regions", RegionInfoAnalysis()) // 分析代码区域结构，支持大范围代码布局优化
FUNCTION_ANALYSIS("scalar-evolution", ScalarEvolutionAnalysis()) // 对循环中的算术和指针进程建模
FUNCTION_ANALYSIS("should-not-run-function-passes", ShouldNotRunFunctionPassesAnalysis()) // 判断哪些函数 Pass 应跳过
FUNCTION_ANALYSIS("should-run-extra-vector-passes", ShouldRunExtraVectorPasses()) // 决定哪些函数需要额外向量化 Pass
FUNCTION_ANALYSIS("ssp-layout", SSPLayoutAnalysis()) // 分析堆栈保护布局以插装安全检查
FUNCTION_ANALYSIS("stack-safety-local", StackSafetyAnalysis()) // 本地函数级栈安全分析，检测潜在溢出
FUNCTION_ANALYSIS("target-ir", TM ? TM->getTargetIRAnalysis() : TargetIRAnalysis()) // 获取目标架构的 IR 分析接口
FUNCTION_ANALYSIS("target-lib-info", TargetLibraryAnalysis()) // 提供标准库函数的信息以支持内联和优化
FUNCTION_ANALYSIS("uniformity", UniformityInfoAnalysis()) // 分析值在不同线程或向量元素间的一致性
FUNCTION_ANALYSIS("verify", VerifierAnalysis()) // 验证函数级 IR 的合法性和一致性
FUNCTION_ALIAS_ANALYSIS("basic-aa", BasicAA()) // 基础别名分析，快速检测简单指针别名情况
FUNCTION_ALIAS_ANALYSIS("objc-arc-aa", objcarc::ObjCARCAA()) // 针对 Objective-C ARC 的别名分析
FUNCTION_ALIAS_ANALYSIS("scev-aa", SCEVAA()) // 基于标量演化（SCEV）的别名分析
FUNCTION_ALIAS_ANALYSIS("scoped-noalias-aa", ScopedNoAliasAA()) // 在特定作用域内进行无别名假设分析
FUNCTION_ALIAS_ANALYSIS("tbaa", TypeBasedAA()) // 基于类型信息的别名分析，利用类型不变性消除别名
FUNCTION_PASS("aa-eval", AAEvaluator()) // 评估别名分析结果，用于后续优化决策
FUNCTION_PASS("adce", ADCEPass()) // 先进死代码删除（Aggressive DCE），移除尽可能多的无用代码
FUNCTION_PASS("add-discriminators", AddDiscriminatorsPass()) // 在指令中添加调试鉴别器，改进混淆和剖析映射
FUNCTION_PASS("aggressive-instcombine", AggressiveInstCombinePass()) // 更积极地合并和简化指令
FUNCTION_PASS("alignment-from-assumptions", AlignmentFromAssumptionsPass()) // 根据假设推断并应用更严格的对齐
FUNCTION_PASS("annotation-remarks", AnnotationRemarksPass()) // 发出关于注解使用的诊断备注
FUNCTION_PASS("assume-builder", AssumeBuilderPass()) // 构建假设条件表达式，支持条件优化
FUNCTION_PASS("assume-simplify", AssumeSimplifyPass()) // 简化假设条件，减少冗余判断
FUNCTION_PASS("atomic-expand", AtomicExpandPass(TM)) // 展开原子操作为平台指令序列
FUNCTION_PASS("bdce", BDCEPass()) // 基本块死代码删除（Block DCE），移除未执行块
FUNCTION_PASS("break-crit-edges", BreakCriticalEdgesPass()) // 拆分关键控制流边，以便 SSA 转换
FUNCTION_PASS("callbr-prepare", CallBrPreparePass()) // 为调用/分支混合指令准备分析结构
FUNCTION_PASS("callsite-splitting", CallSiteSplittingPass()) // 拆分多调用站点以启用不同优化策略
FUNCTION_PASS("chr", ControlHeightReductionPass()) // 降低控制流高度，简化嵌套分支
FUNCTION_PASS("codegenprepare", CodeGenPreparePass(TM)) // 预处理 IR 以满足后端代码生成要求
FUNCTION_PASS("complex-deinterleaving", ComplexDeinterleavingPass(TM)) // 对复杂交错访问执行反交错处理
FUNCTION_PASS("consthoist", ConstantHoistingPass()) // 将循环或条件内的常量提升到外部
FUNCTION_PASS("constraint-elimination", ConstraintEliminationPass()) // 消除冗余约束条件
FUNCTION_PASS("coro-elide", CoroElidePass()) // 在协程转换中消除无用中间状态
FUNCTION_PASS("correlated-propagation", CorrelatedValuePropagationPass()) // 基于相关性传播常量
FUNCTION_PASS("count-visits", CountVisitsPass()) // 插装基本块访问计数，用于分析或 Profile
FUNCTION_PASS("dce", DCEPass()) // 标准死代码删除
FUNCTION_PASS("declare-to-assign", llvm::AssignmentTrackingPass()) // 跟踪变量赋值，替换声明为赋值链
FUNCTION_PASS("dfa-jump-threading", DFAJumpThreadingPass()) // 数据流驱动的跳转合并，优化分支可达性
FUNCTION_PASS("div-rem-pairs", DivRemPairsPass()) // 合并除法和取余对以减少重复计算
FUNCTION_PASS("dot-cfg", CFGPrinterPass()) // 将控制流图输出为 DOT 格式
FUNCTION_PASS("dot-cfg-only", CFGOnlyPrinterPass()) // 仅输出 CFG，不生成分析
FUNCTION_PASS("dot-dom", DomPrinter()) // 将支配树输出为 DOT 格式
FUNCTION_PASS("dot-dom-only", DomOnlyPrinter()) // 仅输出支配树，不生成分析
FUNCTION_PASS("dot-post-dom", PostDomPrinter()) // 将后支配树输出为 DOT
FUNCTION_PASS("dot-post-dom-only", PostDomOnlyPrinter()) // 仅输出后支配树
FUNCTION_PASS("dse", DSEPass()) // 删除冗余存储和加载（Dead Store Elimination）
FUNCTION_PASS("dwarf-eh-prepare", DwarfEHPreparePass(TM)) // 为 DWARF 异常处理生成辅助结构
FUNCTION_PASS("expand-large-div-rem", ExpandLargeDivRemPass(TM)) // 将大型除法/取余指令展开为循环或调用
FUNCTION_PASS("expand-fp", ExpandFpPass(TM)) // 展开浮点操作以满足目标架构要求
FUNCTION_PASS("expand-memcmp", ExpandMemCmpPass(TM)) // 将 memcmp 调用展开为字节比较循环
FUNCTION_PASS("extra-vector-passes", ExtraFunctionPassManager<ShouldRunExtraVectorPasses>()) // 对标记的函数执行额外向量化 Pass
FUNCTION_PASS("fix-irreducible", FixIrreduciblePass()) // 转换不可约循环结构为可约
FUNCTION_PASS("flatten-cfg", FlattenCFGPass()) // 将多分支结构扁平化以简化分析
FUNCTION_PASS("float2int", Float2IntPass()) // 将浮点 to 整数转换指令标准化
FUNCTION_PASS("gc-lowering", GCLoweringPass()) // 将垃圾回收相关调用转换为显式状态点
FUNCTION_PASS("guard-widening", GuardWideningPass()) // 扩宽守护检查以减少分支
FUNCTION_PASS("gvn-hoist", GVNHoistPass()) // 将公共子表达式提升出循环或分支
FUNCTION_PASS("gvn-sink", GVNSinkPass()) // 将不常用计算下沉到分支内部
FUNCTION_PASS("helloworld", HelloWorldPass()) // 示例 Pass，打印“Hello World”
FUNCTION_PASS("indirectbr-expand", IndirectBrExpandPass(TM)) // 展开 indirectbr 指令为 switch 或跳表
FUNCTION_PASS("infer-address-spaces", InferAddressSpacesPass()) // 推断指针地址空间属性
FUNCTION_PASS("infer-alignment", InferAlignmentPass()) // 推断并应用内存对齐属性
FUNCTION_PASS("inject-tli-mappings", InjectTLIMappings()) // 注入目标特定映射信息，支持目标集成
FUNCTION_PASS("instcount", InstCountPass()) // 统计指令数量和类型分布
FUNCTION_PASS("instnamer", InstructionNamerPass()) // 为指令生成可读名称，辅助调试
FUNCTION_PASS("instsimplify", InstSimplifyPass()) // 简化冰山浮点和整数指令
FUNCTION_PASS("interleaved-access", InterleavedAccessPass(TM)) // 将内存交错访问转换为标准访问
FUNCTION_PASS("interleaved-load-combine", InterleavedLoadCombinePass(TM)) // 合并交错加载为宽加载
FUNCTION_PASS("invalidate<all>", InvalidateAllAnalysesPass()) // 使所有函数级分析失效
FUNCTION_PASS("irce", IRCEPass()) // 交互式冗余计算消除（IR-level CSE）
FUNCTION_PASS("jump-threading", JumpThreadingPass()) // 进行跳转穿线以简化分支
FUNCTION_PASS("jump-table-to-switch", JumpTableToSwitchPass()) // 将跳表转换为 switch 语句
FUNCTION_PASS("kcfi", KCFIPass()) // 插装 KCFI 控制流完整性检查
FUNCTION_PASS("kernel-info", KernelInfoPrinter(TM)) // 打印内核特定信息
FUNCTION_PASS("lcssa", LCSSAPass()) // 将循环退出块上的 PHI 转换为 LCSSA 形式
FUNCTION_PASS("libcalls-shrinkwrap", LibCallsShrinkWrapPass()) // 缩减库调用保护代码路径
FUNCTION_PASS("load-store-vectorizer", LoadStoreVectorizerPass()) // 向量化串行 load/store
FUNCTION_PASS("loop-data-prefetch", LoopDataPrefetchPass()) // 在循环中插装数据预取指令
FUNCTION_PASS("loop-distribute", LoopDistributePass()) // 将循环分布到多个独立循环中
FUNCTION_PASS("loop-fusion", LoopFusePass()) // 合并相邻循环以减少循环开销
FUNCTION_PASS("loop-load-elim", LoopLoadEliminationPass()) // 消除循环内冗余加载
FUNCTION_PASS("loop-simplify", LoopSimplifyPass()) // 将循环标准化为单入口单出口形式
FUNCTION_PASS("loop-sink", LoopSinkPass()) // 将不常用计算下沉
FUNCTION_PASS("loop-versioning", LoopVersioningPass()) // 对循环进行版本化以消除边界检查
FUNCTION_PASS("lower-atomic", LowerAtomicPass()) // 将原子指令降级为库调用或内联序列
FUNCTION_PASS("lower-constant-intrinsics", LowerConstantIntrinsicsPass()) // 将常量内建函数展开为常规 IR
FUNCTION_PASS("lower-expect", LowerExpectIntrinsicPass()) // 将 expect 内建函数转换为分支预测提示
FUNCTION_PASS("lower-guard-intrinsic", LowerGuardIntrinsicPass()) // 将 guard 内建函数转换为条件跳转
FUNCTION_PASS("lower-invoke", LowerInvokePass()) // 将 invoke 指令转换为普通调用+异常处理
FUNCTION_PASS("lower-switch", LowerSwitchPass()) // 将 switch 指令转换为跳表或二分查找
FUNCTION_PASS("lower-widenable-condition", LowerWidenableConditionPass()) // 将可扩展条件转换为动态检查
FUNCTION_PASS("make-guards-explicit", MakeGuardsExplicitPass()) // 将隐式守护条件显式化，便于后续优化
FUNCTION_PASS("mem2reg", PromotePass()) // 将内存分配的局部变量提升到寄存器 (Mem2Reg)
FUNCTION_PASS("memcpyopt", MemCpyOptPass()) // 优化 memcpy 调用，合并或移除冗余内存复制
FUNCTION_PASS("memprof", MemProfilerPass()) // 插装内存探测器，以收集内存访问性能数据
FUNCTION_PASS("mergeicmps", MergeICmpsPass()) // 合并相邻的相同 icmp 比较以减少指令
FUNCTION_PASS("mergereturn", UnifyFunctionExitNodesPass()) // 将多个函数返回点合并为单一出口
FUNCTION_PASS("move-auto-init", MoveAutoInitPass()) // 将自动变量初始化代码移动到更优位置
FUNCTION_PASS("nary-reassociate", NaryReassociatePass()) // 对多元加减运算重新关联以增强常量传播
FUNCTION_PASS("newgvn", NewGVNPass()) // 执行新版全局值编号 (GVN) 优化，消除公共子表达式
FUNCTION_PASS("no-op-function", NoOpFunctionPass()) // 空操作函数级 Pass，占位不做变换
FUNCTION_PASS("objc-arc", ObjCARCOptPass()) // Objective-C ARC 自动引用计数优化
FUNCTION_PASS("objc-arc-contract", ObjCARCContractPass()) // ARC 优化中合并 retain/release 对
FUNCTION_PASS("objc-arc-expand", ObjCARCExpandPass()) // 将 ARC 内建操作展开为显式调用
FUNCTION_PASS("pa-eval", PAEvalPass()) // 对指令进行预测分析，以支持分支预测优化
FUNCTION_PASS("partially-inline-libcalls", PartiallyInlineLibCallsPass()) // 将部分库函数内联以减少调用开销
FUNCTION_PASS("pgo-memop-opt", PGOMemOPSizeOpt()) // 基于 PGO 数据优化内存操作大小
FUNCTION_PASS("place-safepoints", PlaceSafepointsPass()) // 插入垃圾回收安全点
FUNCTION_PASS("print", PrintFunctionPass(errs())) // 打印函数级 IR 到 stderr
FUNCTION_PASS("print-alias-sets", AliasSetsPrinterPass(errs())) // 打印函数别名集信息到 stderr
FUNCTION_PASS("print-cfg-sccs", CFGSCCPrinterPass(errs())) // 打印函数内 SCC CFG 到 stderr
FUNCTION_PASS("print-memderefs", MemDerefPrinterPass(errs())) // 打印可能的内存解引用点
FUNCTION_PASS("print-mustexecute", MustExecutePrinterPass(errs())) // 打印必须执行的指令上下文
FUNCTION_PASS("print-predicateinfo", PredicateInfoPrinterPass(errs())) // 打印谓词分析信息
FUNCTION_PASS("print\<access-info>", LoopAccessInfoPrinterPass(errs())) // 打印循环访问信息
FUNCTION_PASS("print\<assumptions>", AssumptionPrinterPass(errs())) // 打印假设分析结果
FUNCTION_PASS("print\<block-freq>", BlockFrequencyPrinterPass(errs())) // 打印基本块频率
FUNCTION_PASS("print\<branch-prob>", BranchProbabilityPrinterPass(errs())) // 打印分支概率
FUNCTION_PASS("print\<cost-model>", CostModelPrinterPass(errs())) // 打印成本模型估算
FUNCTION_PASS("print\<cycles>", CycleInfoPrinterPass(errs())) // 打印循环依赖分析信息
FUNCTION_PASS("print\<da>", DependenceAnalysisPrinterPass(errs())) // 打印依赖分析结果
FUNCTION_PASS("print\<debug-ata>", DebugAssignmentTrackingPrinterPass(errs())) // 打印赋值跟踪信息
FUNCTION_PASS("print\<delinearization>", DelinearizationPrinterPass(errs())) // 打印指针去线性化信息
FUNCTION_PASS("print\<demanded-bits>", DemandedBitsPrinterPass(errs())) // 打印位需求分析结果
FUNCTION_PASS("print\<domfrontier>", DominanceFrontierPrinterPass(errs())) // 打印支配边界
FUNCTION_PASS("print\<domtree>", DominatorTreePrinterPass(errs())) // 打印支配树
FUNCTION_PASS("print\<func-properties>", FunctionPropertiesPrinterPass(errs())) // 打印函数属性分析结果
FUNCTION_PASS("print\<inline-cost>", InlineCostAnnotationPrinterPass(errs())) // 打印内联成本注解
FUNCTION_PASS("print\<inliner-size-estimator>", InlineSizeEstimatorAnalysisPrinterPass(errs())) // 打印内联大小估算
FUNCTION_PASS("print\<lazy-value-info>", LazyValueInfoPrinterPass(errs())) // 打印延迟值分析信息
FUNCTION_PASS("print\<loops>", LoopPrinterPass(errs())) // 打印循环结构信息
FUNCTION_PASS("print\<memoryssa-walker>", MemorySSAWalkerPrinterPass(errs())) // 打印 MemorySSA 遍历器信息
FUNCTION_PASS("print\<phi-values>", PhiValuesPrinterPass(errs())) // 打印 φ 节点值信息
FUNCTION_PASS("print\<postdomtree>", PostDominatorTreePrinterPass(errs())) // 打印后支配树
FUNCTION_PASS("print\<regions>", RegionInfoPrinterPass(errs())) // 打印区域信息
FUNCTION_PASS("print\<scalar-evolution>", ScalarEvolutionPrinterPass(errs())) // 打印标量演化分析结果
FUNCTION_PASS("print\<stack-safety-local>", StackSafetyPrinterPass(errs())) // 打印栈安全本地分析结果
FUNCTION_PASS("print\<uniformity>", UniformityInfoPrinterPass(errs())) // 打印一致性分析信息
FUNCTION_PASS("reassociate", ReassociatePass()) // 对加减乘除表达式重新关联
FUNCTION_PASS("redundant-dbg-inst-elim", RedundantDbgInstEliminationPass()) // 删除冗余调试指令
FUNCTION_PASS("reg2mem", RegToMemPass()) // 将寄存器变量重新映射回内存
FUNCTION_PASS("safe-stack", SafeStackPass(TM)) // 插装安全栈以防止栈溢出
FUNCTION_PASS("sandbox-vectorizer", SandboxVectorizerPass()) // 在沙箱模式下向量化内存访问
FUNCTION_PASS("scalarize-masked-mem-intrin", ScalarizeMaskedMemIntrinPass(errs())) // 将掩码内存内建展开为标量操作
FUNCTION_PASS("sccp", SCCPPass()) // 稀疏条件常量传播 (SCCP)
FUNCTION_PASS("select-optimize", SelectOptimizePass(TM)) // 优化 select 内建指令
FUNCTION_PASS("separate-const-offset-from-gep", SeparateConstOffsetFromGEPPass()) // 从 GEP 提取常量偏移
FUNCTION_PASS("sink", SinkingPass()) // 将计算下沉到更冷的分支
FUNCTION_PASS("sjlj-eh-prepare", SjLjEHPreparePass(TM)) // 为 setjmp/longjmp 异常处理准备辅助结构
FUNCTION_PASS("slp-vectorizer", SLPVectorizerPass()) // 基于超块的向量化
FUNCTION_PASS("slsr", StraightLineStrengthReducePass()) // 直线代码强度归约
FUNCTION_PASS("stack-protector", StackProtectorPass(TM)) // 插装栈保护以检测溢出
FUNCTION_PASS("strip-gc-relocates", StripGCRelocates()) // 删除垃圾回收重定位指令
FUNCTION_PASS("tailcallelim", TailCallElimPass()) // 消除尾调用并转为跳转
FUNCTION_PASS("transform-warning", WarnMissedTransformationsPass()) // 对未应用的变换发出警告
FUNCTION_PASS("trigger-crash-function", TriggerCrashFunctionPass()) // 强制在函数中引发崩溃以测试管道
FUNCTION_PASS("trigger-verifier-error", TriggerVerifierErrorPass()) // 强制触发验证器错误
FUNCTION_PASS("tsan", ThreadSanitizerPass()) // 插装线程 Sanitizer 以检测数据竞争
FUNCTION_PASS("typepromotion", TypePromotionPass(TM)) // 将小整数类型提升为更大类型以优化指令
FUNCTION_PASS("unify-loop-exits", UnifyLoopExitsPass()) // 合并循环退出点
FUNCTION_PASS("vector-combine", VectorCombinePass()) // 合并向量操作以提高利用率
FUNCTION_PASS("verify", VerifierPass()) // 验证函数级 IR 合法性
FUNCTION_PASS("verify<cycles>", CycleInfoVerifierPass()) // 验证循环依赖分析正确性
FUNCTION_PASS("verify<domtree>", DominatorTreeVerifierPass()) // 验证支配树正确性
FUNCTION_PASS("verify<loops>", LoopVerifierPass()) // 验证循环分析正确性
FUNCTION_PASS("verify<memoryssa>", MemorySSAVerifierPass()) // 验证 MemorySSA 正确性
FUNCTION_PASS("verify<regions>", RegionInfoVerifierPass()) // 验证区域信息正确性
FUNCTION_PASS("verify<safepoint-ir>", SafepointIRVerifierPass()) // 验证安全点 IR 正确性
FUNCTION_PASS("verify<scalar-evolution>", ScalarEvolutionVerifierPass()) // 验证标量演化分析正确性
FUNCTION_PASS("view-cfg", CFGViewerPass()) // 图形化展示函数内控制流图
FUNCTION_PASS("view-cfg-only", CFGOnlyViewerPass()) // 仅图形化展示 CFG
FUNCTION_PASS("view-dom", DomViewer()) // 图形化展示支配树
FUNCTION_PASS("view-dom-only", DomOnlyViewer()) // 仅图形化展示支配树
FUNCTION_PASS("view-post-dom", PostDomViewer()) // 图形化展示后支配树
FUNCTION_PASS("view-post-dom-only", PostDomOnlyViewer()) // 仅图形化展示后支配树
FUNCTION_PASS("wasm-eh-prepare", WasmEHPreparePass()) // 为 WebAssembly 异常处理生成辅助结构
FUNCTION_PASS_WITH_PARAMS("cfguard", "CFGuardPass", [](CFGuardPass::Mechanism M){return CFGuardPass(M);}, parseCFGuardPassOptions, "check;dispatch") // 插装 Control-Flow Guard 检查与跳转保护
FUNCTION_PASS_WITH_PARAMS("early-cse", "EarlyCSEPass", [](bool UseMemorySSA){return EarlyCSEPass(UseMemorySSA);}, parseEarlyCSEPassOptions, "memssa") // 早期公共子表达式消除，可选 MemorySSA 支持
FUNCTION_PASS_WITH_PARAMS("ee-instrument", "EntryExitInstrumenterPass", [](bool PostInlining){return EntryExitInstrumenterPass(PostInlining);}, parseEntryExitInstrumenterPassOptions, "post-inline") // 插装函数入口/出口钩子，可选后内联模式
FUNCTION_PASS_WITH_PARAMS("function-simplification", "", [this](OptimizationLevel OL){return buildFunctionSimplificationPipeline(OL, ThinOrFullLTOPhase::None);}, parseFunctionSimplificationPipelineOptions, "O1;O2;O3;Os;Oz") // 构建函数级简化流水线，支持不同优化级别
FUNCTION_PASS_WITH_PARAMS("gvn", "GVNPass", [](GVNOptions Opts){return GVNPass(Opts);}, parseGVNOptions, "no-pre;pre;no-load-pre;load-pre;…") // 全局值编号消除公共子表达式，选项控制预合并与 MemorySSA
FUNCTION_PASS_WITH_PARAMS("hardware-loops", "HardwareLoopsPass", [](HardwareLoopOptions Opts){return HardwareLoopsPass(Opts);}, parseHardwareLoopOptions, "force-hardware-loops;…") // 将循环转换为硬件循环指令，可强制、嵌套与位宽选项
FUNCTION_PASS_WITH_PARAMS("instcombine", "InstCombinePass", [](InstCombineOptions Opts){return InstCombinePass(Opts);}, parseInstCombineOptions, "no-use-loop-info;…") // 指令合并与常见模式简化，控制循环信息与 fixpoint 验证
FUNCTION_PASS_WITH_PARAMS("lint", "LintPass", [](bool AbortOnError){return LintPass(AbortOnError);}, parseLintOptions, "abort-on-error") // 静态“代码审查”检查，遇错可中止
FUNCTION_PASS_WITH_PARAMS("loop-unroll", "LoopUnrollPass", [](LoopUnrollOptions Opts){return LoopUnrollPass(Opts);}, parseLoopUnrollOptions, "O0;O1;O2;O3;full-unroll-max=N;…") // 循环展开，支持部分/全展开与剥离策略
FUNCTION_PASS_WITH_PARAMS("loop-vectorize", "LoopVectorizePass", [](LoopVectorizeOptions Opts){return LoopVectorizePass(Opts);}, parseLoopVectorizeOptions, "no-interleave-forced-only;…") // 循环向量化，强制/排除交错与向量化策略
FUNCTION_PASS_WITH_PARAMS("lower-allow-check", "LowerAllowCheckPass", [](LowerAllowCheckPass::Options Opts){return LowerAllowCheckPass(Opts);}, parseLowerAllowCheckPassOptions, "") // 将允许检查谓词内建降低为显式条件
FUNCTION_PASS_WITH_PARAMS("lower-matrix-intrinsics", "LowerMatrixIntrinsicsPass", [](bool Minimal){return LowerMatrixIntrinsicsPass(Minimal);}, parseLowerMatrixIntrinsicsPassOptions, "minimal") // 将矩阵内建展开为循环或标量运算，可选最小化策略
FUNCTION_PASS_WITH_PARAMS("normalize", "IRNormalizerPass", [](IRNormalizerOptions Options){return IRNormalizerPass(Options);}, parseIRNormalizerPassOptions, "no-preserve-order;preserve-order;…") // 对 IR 做标准化重排，控制操作顺序与重命名
FUNCTION_PASS_WITH_PARAMS("mldst-motion", "MergedLoadStoreMotionPass", [](MergedLoadStoreMotionOptions Opts){return MergedLoadStoreMotionPass(Opts);}, parseMergedLoadStoreMotionOptions, "no-split-footer-bb;split-footer-bb") // 合并迁移加载/存储，优化访存合并与 BB 尾部分割
FUNCTION_PASS_WITH_PARAMS("print\<da>", "DependenceAnalysisPrinterPass", [](bool NormalizeResults){return DependenceAnalysisPrinterPass(errs(), NormalizeResults);}, parseDependenceAnalysisPrinterOptions, "normalized-results") // 打印依赖分析结果，可选归一化输出
FUNCTION_PASS_WITH_PARAMS("print\<memoryssa>", "MemorySSAPrinterPass", [](bool NoEnsureOptimizedUses){return MemorySSAPrinterPass(errs(), !NoEnsureOptimizedUses);}, parseMemorySSAPrinterPassOptions, "no-ensure-optimized-uses") // 打印 MemorySSA 结构，可选跳过优化检查
FUNCTION_PASS_WITH_PARAMS("print\<stack-lifetime>", "StackLifetimePrinterPass", [](StackLifetime::LivenessType Type){return StackLifetimePrinterPass(errs(), Type);}, parseStackLifetimeOptions, "may;must") // 打印栈生命周期信息，选择 may/must 分析
FUNCTION_PASS_WITH_PARAMS("scalarizer", "ScalarizerPass", [](ScalarizerPassOptions Opts){return ScalarizerPass(Opts);}, parseScalarizerOptions, "load-store;no-load-store;…") // 将矢量/内建内存操作标量化，细化 load/store 与插入/extract
FUNCTION_PASS_WITH_PARAMS("separate-const-offset-from-gep", "SeparateConstOffsetFromGEPPass", [](bool LowerGEP){return SeparateConstOffsetFromGEPPass(LowerGEP);}, parseSeparateConstOffsetFromGEPPassOptions, "lower-gep") // 从 GEP 指令中分离常量偏移，可降低 GEP 复杂度
FUNCTION_PASS_WITH_PARAMS("simplifycfg", "SimplifyCFGPass", [](SimplifyCFGOptions Opts){return SimplifyCFGPass(Opts);}, parseSimplifyCFGOptions, "no-forward-switch-cond;…") // 简化控制流图，支持 switch 优化、循环保留与公共指令提升/下沉
FUNCTION_PASS_WITH_PARAMS("speculative-execution", "SpeculativeExecutionPass", [](bool OnlyIfDivergentTarget){return SpeculativeExecutionPass(OnlyIfDivergentTarget);}, parseSpeculativeExecutionPassOptions, "only-if-divergent-target") // 插装或重写分支以进行投机执行，可选仅针对分歧目标
FUNCTION_PASS_WITH_PARAMS("sroa", "SROAPass", [](SROAOptions PreserveCFG){return SROAPass(PreserveCFG);}, parseSROAOptions, "preserve-cfg;modify-cfg") // 聚合类型标量替换，将 struct/array 拆为标量以支持 Mem2Reg
FUNCTION_PASS_WITH_PARAMS("structurizecfg", "StructurizeCFG", [](bool SkipUniformRegions){return StructurizeCFGPass(SkipUniformRegions);}, parseStructurizeCFGPassOptions, "skip-uniform-regions") // 将 CFG 转换为结构化控制流，以支持 GPU/Shader 后端
FUNCTION_PASS_WITH_PARAMS("win-eh-prepare", "WinEHPreparePass", [](bool DemoteCatchSwitchPHIOnly){return WinEHPreparePass(DemoteCatchSwitchPHIOnly);}, parseWinEHPrepareOptions, "demote-catchswitch-only") // 为 Windows 异常处理生成 PHI 和辅助块，可降级仅捕获 switch PHI
FUNCTION_PASS_WITH_PARAMS("bounds-checking", "BoundsCheckingPass", [](BoundsCheckingPass::Options Options){return BoundsCheckingPass(Options);}, parseBoundsCheckingOptions, "trap") // 插装数组/指针越界检查，可选 trap 中断行为
LOOPNEST_PASS("loop-flatten", LoopFlattenPass()) // 展平嵌套循环，将多层循环转换为单层
LOOPNEST_PASS("loop-interchange", LoopInterchangePass()) // 交换内外循环以改善数据局部性
LOOPNEST_PASS("loop-unroll-and-jam", LoopUnrollAndJamPass()) // 解卷循环并融合循环体以提高并行度
LOOPNEST_PASS("no-op-loopnest", NoOpLoopNestPass()) // 空操作 LoopNest Pass，占位测试
LOOP_ANALYSIS("ddg", DDGAnalysis()) // 构建循环数据依赖图（DDG）以分析依赖关系
LOOP_ANALYSIS("iv-users", IVUsersAnalysis()) // 分析归纳变量的使用情况以辅助变换
LOOP_ANALYSIS("no-op-loop", NoOpLoopAnalysis()) // 空操作 Loop Analysis，占位用
LOOP_ANALYSIS("pass-instrumentation", PassInstrumentationAnalysis(PIC)) // 插装循环级 Pass 运行统计
LOOP_ANALYSIS("should-run-extra-simple-loop-unswitch", ShouldRunExtraSimpleLoopUnswitch()) // 判断是否执行简单循环非交换优化
LOOP_PASS("canon-freeze", CanonicalizeFreezeInLoopsPass()) // 标准化循环中的 freeze 操作以简化优化
LOOP_PASS("dot-ddg", DDGDotPrinterPass()) // 将循环数据依赖图输出为 DOT 格式
LOOP_PASS("guard-widening", GuardWideningPass()) // 扩宽循环守护条件以减少分支
LOOP_PASS("extra-simple-loop-unswitch-passes", ExtraLoopPassManager<ShouldRunExtraSimpleLoopUnswitch>()) // 对可简单非交换的循环执行附加 Pass
LOOP_PASS("indvars", IndVarSimplifyPass()) // 归纳变量简化，标准化 IV 用法
LOOP_PASS("invalidate<all>", InvalidateAllAnalysesPass()) // 使所有循环级分析结果失效
LOOP_PASS("loop-bound-split", LoopBoundSplitPass()) // 按循环边界条件拆分循环以移除检查
LOOP_PASS("loop-deletion", LoopDeletionPass()) // 删除不执行或无效的循环
LOOP_PASS("loop-idiom", LoopIdiomRecognizePass()) // 识别并替换常见循环习语
LOOP_PASS("loop-idiom-vectorize", LoopIdiomVectorizePass()) // 将识别的习语向量化
LOOP_PASS("loop-instsimplify", LoopInstSimplifyPass()) // 在循环内简化指令
LOOP_PASS("loop-predication", LoopPredicationPass()) // 循环谓词化，移出条件分支
LOOP_PASS("loop-reduce", LoopStrengthReducePass()) // 循环强度归约，简化乘除为加法
LOOP_PASS("loop-term-fold", LoopTermFoldPass()) // 折叠循环终止条件表达式
LOOP_PASS("loop-simplifycfg", LoopSimplifyCFGPass()) // 将循环 CFG 标准化为单入口单出口
LOOP_PASS("loop-unroll-full", LoopFullUnrollPass()) // 对循环进行完全展开
LOOP_PASS("loop-versioning-licm", LoopVersioningLICMPass()) // 循环版本化，结合 LICM 消除边界检查
LOOP_PASS("no-op-loop", NoOpLoopPass()) // 空操作 Loop Pass，占位测试
LOOP_PASS("print", PrintLoopPass(errs())) // 打印循环信息到 stderr
LOOP_PASS("print\<ddg>", DDGAnalysisPrinterPass(errs())) // 打印循环数据依赖图分析结果
LOOP_PASS("print\<iv-users>", IVUsersPrinterPass(errs())) // 打印归纳变量使用情况
LOOP_PASS("print\<loop-cache-cost>", LoopCachePrinterPass(errs())) // 打印循环缓存成本估算
LOOP_PASS("print\<loopnest>", LoopNestPrinterPass(errs())) // 打印循环嵌套结构
LOOP_PASS_WITH_PARAMS("licm", "LICMPass", [](LICMOptions Params){return LICMPass(Params);}, parseLICMOptions, "allowspeculation") // 循环内存量化消除（LICM），可选投机执行
LOOP_PASS_WITH_PARAMS("lnicm", "LNICMPass", [](LICMOptions Params){return LNICMPass(Params);}, parseLICMOptions, "allowspeculation") // 延迟 LICM，待条件满足后再提升公共子表达式
LOOP_PASS_WITH_PARAMS("loop-rotate", "LoopRotatePass", [](std::pair<bool,bool> Params){return LoopRotatePass(Params.first, Params.second);}, parseLoopRotateOptions, "no-header-duplication;header-duplication;no-prepare-for-lto;prepare-for-lto") // 循环旋转，重排循环头部以优化分支和并行
LOOP_PASS_WITH_PARAMS("simple-loop-unswitch", "SimpleLoopUnswitchPass", [](std::pair<bool,bool> Params){return SimpleLoopUnswitchPass(Params.first, Params.second);}, parseLoopUnswitchOptions, "nontrivial;no-nontrivial;trivial;no-trivial") // 简单循环非交换，移出循环不变条件

附录 B-汇总表格

宏类型	缩写	Pass/Analysis 名称	注释
MODULE_ANALYSIS	callgraph	CallGraphAnalysis	构建和查询程序的调用图
MODULE_ANALYSIS	collector-metadata	CollectorMetadataAnalysis	收集并管理自定义元数据
MODULE_ANALYSIS	ctx-prof-analysis	CtxProfAnalysis	上下文敏感的 PG O（Profile-Guided Optimization）分析
MODULE_ANALYSIS	dxil-metadata	DXILMetadataAnalysis	解析和存储 DXIL（DirectX Intermediate Language）元数据
MODULE_ANALYSIS	dxil-resources	DXILResourceAnalysis	分析 DXIL 中的资源（纹理、缓冲区等）使用情况
MODULE_ANALYSIS	dxil-resource-type	DXILResourceTypeAnalysis	推断和标记 DXIL 资源的类型信息
MODULE_ANALYSIS	inline-advisor	InlineAdvisorAnalysis	建议内联优化点，辅助 inliner 做决策
MODULE_ANALYSIS	ir-similarity	IRSimilarityAnalysis	检测和聚类相似的 IR 代码片段
MODULE_ANALYSIS	last-run-tracking	LastRunTrackingAnalysis	跟踪上次运行时的变更和执行情况
MODULE_ANALYSIS	lcg	LazyCallGraphAnalysis	延迟构建调用图，仅在需要时才生成节点/边
MODULE_ANALYSIS	module-summary	ModuleSummaryIndexAnalysis	为跨模块优化生成模块摘要索引
MODULE_ANALYSIS	no-op-module	NoOpModuleAnalysis	空操作分析，占位用，不做任何变换
MODULE_ANALYSIS	pass-instrumentation	PassInstrumentationAnalysis	为 Pass 插装探针，收集运行时统计
MODULE_ANALYSIS	profile-summary	ProfileSummaryAnalysis	汇总 PG O 分析结果，生成整体概要
MODULE_ANALYSIS	reg-usage	PhysicalRegisterUsageAnalysis	分析物理寄存器的实际使用情况
MODULE_ANALYSIS	stack-safety	StackSafetyGlobalAnalysis	全局栈安全分析，检测栈溢出风险
MODULE_ANALYSIS	verify	VerifierAnalysis	验证 IR 的合法性和一致性
MODULE_ALIAS_ANALYSIS	globals-aa	GlobalsAA	全局变量别名分析，识别不同全局变量间的别名关系
MODULE_PASS	always-inline	AlwaysInlinerPass	强制将所有调用点内联被标记的函数
MODULE_PASS	annotation2metadata	Annotation2MetadataPass	将自定义注解转换成 IR 元数据
MODULE_PASS	assign-guid	AssignGUIDPass	为 IR 指令分配全局唯一 ID（GUID）
MODULE_PASS	attributor	AttributorPass	属性推导框架，用于发现和传播函数/调用约束
MODULE_PASS	attributor-light	AttributorLightPass	轻量级属性推导，仅执行快速检查
MODULE_PASS	called-value-propagation	CalledValuePropagationPass	传播已调用函数的返回值常量
MODULE_PASS	canonicalize-aliases	CanonicalizeAliasesPass	规范化别名，简化 bitcast/getelementptr 链
MODULE_PASS	check-debugify	NewPMCheckDebugifyPass	检查并加入调试化信息，确保调试符号完整
MODULE_PASS	constmerge	ConstantMergePass	合并相同常量的全局变量或常量表达式
MODULE_PASS	coro-cleanup	CoroCleanupPass	清理协程生成的中间状态和标记
MODULE_PASS	coro-early	CoroEarlyPass	提前识别协程开始/结束点，为后续优化做准备
MODULE_PASS	cross-dso-cfi	CrossDSOCFIPass	启用跨动态链接库的控制流完整性检查
MODULE_PASS	ctx-instr-gen	PGOInstrumentationGen	生成上下文敏感的 PG O 插装指令
MODULE_PASS	ctx-prof-flatten	PGOCtxProfFlatteningPass	对上下文敏感的 PG O 插装数据执行展平，合并相同调用上下文的配置
MODULE_PASS	ctx-prof-flatten-prethinlink	PGOCtxProfFlatteningPass	在 ThinLTO 链接前执行上下文敏感展平，以便后续跨模块 LTO 使用
MODULE_PASS	noinline-nonprevailing	NoinlineNonPrevailing	避免对非主导（non-prevailing）函数进行内联，以减少代码爆炸
MODULE_PASS	deadargelim	DeadArgumentEliminationPass	消除函数中未使用的参数，删除多余的入参
MODULE_PASS	debugify	NewPMDebugifyPass	向 IR 中注入完整的调试信息，便于后续验证和调试
MODULE_PASS	dfsan	DataFlowSanitizerPass	插装 DataFlowSanitizer 检测指针和数据流的安全性
MODULE_PASS	dot-callgraph	CallGraphDOTPrinterPass	将调用图导出为 DOT 格式，便于用 Graphviz 可视化
MODULE_PASS	dxil-upgrade	DXILUpgradePass	升级 DXIL IR 到最新规范，更新过时指令和元数据
MODULE_PASS	elim-avail-extern	EliminateAvailableExternallyPass	删除标记为 available_externally 的函数/全局变量，减小模块大小
MODULE_PASS	extract-blocks	BlockExtractorPass	抽取指定基本块到新函数，支持代码分离和分析
MODULE_PASS	expand-variadics	ExpandVariadicsPass	将可变参数函数展开为固定参数形式（此处禁用，仅分析用途）
MODULE_PASS	forceattrs	ForceFunctionAttrsPass	强制根据函数实现添加或修改属性（如NoUnwind、ReadNone等）
MODULE_PASS	function-import	FunctionImportPass	在跨模块优化中导入函数定义，实现内联和优化传递
MODULE_PASS	global-merge-func	GlobalMergeFuncPass	合并功能相同的全局函数，消除重复实现
MODULE_PASS	globalopt	GlobalOptPass	全局范围优化，包括常量传播、死代码删除、CFG 简化
MODULE_PASS	globalsplit	GlobalSplitPass	将全局变量拆分为热/冷区域，提高缓存局部性
MODULE_PASS	hipstdpar-interpose-alloc	HipStdParAllocationInterpositionPass	对 HIP 标准并行分配调用插装拦截，用于分析或模拟
MODULE_PASS	hipstdpar-select-accelerator-code	HipStdParAcceleratorCodeSelectionPass	根据目标加速器选择最优代码路径（比如 GPU vs CPU）
MODULE_PASS	hotcoldsplit	HotColdSplittingPass	将函数或基本块按热度拆分成热/冷部分，优化指令缓存
MODULE_PASS	inferattrs	InferFunctionAttrsPass	基于函数体分析推断可用属性（如纯函数、无副作用等）
MODULE_PASS	inliner-ml-advisor-release	ModuleInlinerWrapperPass	使用机器学习模型建议内联，针对 Release 构建收集统计并执行内联
MODULE_PASS	inliner-wrapper	ModuleInlinerWrapperPass	通用模块内联包装器，根据参数动态决定内联行为
MODULE_PASS	inliner-wrapper-no-mandatory-first	ModuleInlinerWrapperPass	模块内联包装器（不优先处理强制内联），优化裁剪内联顺序
MODULE_PASS	insert-gcov-profiling	GCOVProfilerPass	插装 GCOV 覆盖率分析点，生成运行时覆盖率数据
MODULE_PASS	instrprof	InstrProfilingLoweringPass	将 InstrumentationProfiler 插装调用下沉到 IR 中，生成测量钩子
MODULE_PASS	ctx-instr-lower	PGOCtxProfLoweringPass	将上下文敏感 PG O 插装高层接口下沉为低级钩子
MODULE_PASS	print<ctx-prof-analysis>	CtxProfAnalysisPrinterPass	打印上下文敏感 PG O 分析结果到标准错误流
MODULE_PASS	invalidate	InvalidateAllAnalysesPass	在模块变更后使所有分析结果失效，确保数据一致性
MODULE_PASS	iroutliner	IROutlinerPass	将重复 IR 模式抽取为函数，提高代码重用性和紧凑性
MODULE_PASS	jmc-instrumenter	JMCInstrumenterPass	插装 Just-My-Code 跟踪点，仅记录用户代码执行
MODULE_PASS	lower-emutls	LowerEmuTLSPass	将仿真 TLS 操作转换为显式内存访问，支持无本地 TLS 的目标
MODULE_PASS	lower-global-dtors	LowerGlobalDtorsPass	将全局析构函数列表转换为显式函数调用
MODULE_PASS	lower-ifunc	LowerIFuncPass	将基于 GNU IFUNC 的可重定位函数解析转为直接调用
MODULE_PASS	lowertypetests	LowerTypeTestsPass	将类型测试（type tests）内建指令降级为显式检查
MODULE_PASS	fatlto-cleanup	FatLtoCleanup	清理 FatLTO 中间产生的数据和标记，恢复模块基本状态
MODULE_PASS	pgo-force-function-attrs	PGOForceFunctionAttrsPass	基于 PGO 冷调用分析，强制为函数添加冷/热属性
MODULE_PASS	memprof-context-disambiguation	MemProfContextDisambiguation	在 MemProf 中为不同调用上下文分离内存访问，消除歧义
MODULE_PASS	memprof-module	ModuleMemProfilerPass	为模块插装内存访问探针，生成运行时追踪
MODULE_PASS	mergefunc	MergeFunctionsPass	合并相似或等价函数，减少代码重复
MODULE_PASS	metarenamer	MetaRenamerPass	对 IR 元素（函数、变量）进行可读性重命名
MODULE_PASS	module-inline	ModuleInlinerPass	模块级函数内联，执行常规内联转换
MODULE_PASS	name-anon-globals	NameAnonGlobalPass	为匿名全局符号生成唯一名称，便于调试和分析
MODULE_PASS	no-op-module	NoOpModulePass	空操作 Pass，占位测试
MODULE_PASS	nsan	NumericalStabilitySanitizerPass	插装检测数值计算稳定性问题
MODULE_PASS	objc-arc-apelim	ObjCARCAPElimPass	Objective-C ARC 模式下消除不必要的自动引用计数调用
MODULE_PASS	openmp-opt	OpenMPOptPass	针对 OpenMP 并行指令进行优化
MODULE_PASS	openmp-opt-postlink	OpenMPOptPass	全链接后对 OpenMP 代码进行二次优化
MODULE_PASS	partial-inliner	PartialInlinerPass	部分内联，仅内联小函数或满足阈值的函数
MODULE_PASS	pgo-icall-prom	PGOIndirectCallPromotion	PGO 基于探测数据将间接调用提升为直接调用
MODULE_PASS	pgo-instr-gen	PGOInstrumentationGen	生成 PGO 探针插装
MODULE_PASS	pgo-instr-use	PGOInstrumentationUse	使用先前插装的 PGO 数据进行优化
MODULE_PASS	pre-isel-intrinsic-lowering	PreISelIntrinsicLoweringPass	在选择指令前将内建函数降级为标准 IR
MODULE_PASS	print	PrintModulePass	打印模块 IR 到 stderr
MODULE_PASS	print-callgraph	CallGraphPrinterPass	打印调用图文本到 stderr
MODULE_PASS	print-callgraph-sccs	CallGraphSCCsPrinterPass	打印调用图强连通分量到 stderr
MODULE_PASS	print-ir-similarity	IRSimilarityAnalysisPrinterPass	打印 IR 相似度分组结果到 stderr
MODULE_PASS	print-lcg	LazyCallGraphPrinterPass	打印延迟调用图到 stderr
MODULE_PASS	print-lcg-dot	LazyCallGraphDOTPrinterPass	以 DOT 格式打印延迟调用图
MODULE_PASS	print-must-be-executed-contexts	MustBeExecutedContextPrinterPass	打印必定执行上下文分析结果到 stderr
MODULE_PASS	print-profile-summary	ProfileSummaryPrinterPass	打印 PGO 概要报告到 stderr
MODULE_PASS	print-stack-safety	StackSafetyGlobalPrinterPass	打印栈安全分析结果到 stderr
MODULE_PASS	print<dxil-metadata>	DXILMetadataAnalysisPrinterPass	打印 DXIL 元数据分析结果到 stderr
MODULE_PASS	print<dxil-resources>	DXILResourcePrinterPass	打印 DXIL 资源分析结果到 stderr
MODULE_PASS	print<inline-advisor>	InlineAdvisorAnalysisPrinterPass	打印内联建议分析结果到 stderr
MODULE_PASS	print<module-debuginfo>	ModuleDebugInfoPrinterPass	打印模块调试信息到 stderr
MODULE_PASS	print<reg-usage>	PhysicalRegisterUsageInfoPrinterPass	打印物理寄存器使用信息到 stderr
MODULE_PASS	pseudo-probe	SampleProfileProbePass	插装伪探针以支持低开销性能分析
MODULE_PASS	pseudo-probe-update	PseudoProbeUpdatePass	更新和合并伪探针信息
MODULE_PASS	recompute-globalsaa	RecomputeGlobalsAAPass	重新计算全局别名分析以反映最新 IR 改动
MODULE_PASS	rel-lookup-table-converter	RelLookupTableConverterPass	转换相对查找表以优化运行时查找性能
MODULE_PASS	rewrite-statepoints-for-gc	RewriteStatepointsForGC	重写 GC 状态点以支持精确垃圾回收
MODULE_PASS	rewrite-symbols	RewriteSymbolPass	重写符号名称或链接属性，支持虚拟化或混淆
MODULE_PASS	rpo-function-attrs	ReversePostOrderFunctionAttrsPass	按反后序遍历顺序推断函数属性以提升分析精度
MODULE_PASS	rtsan	RealtimeSanitizerPass	插装实时 Sanitizer 以检测运行时错误
MODULE_PASS	sample-profile	SampleProfileLoaderPass	加载采样分析配置并插装采样探针
MODULE_PASS	sancov-module	SanitizerCoveragePass	插装 Sanitizer 覆盖率探针以收集执行路径覆盖信息
MODULE_PASS	sanmd-module	SanitizerBinaryMetadataPass	生成二进制级别 Sanitizer 元数据
MODULE_PASS	scc-oz-module-inliner	buildInlinerPipeline	构建针对 Oz 优化级别的 SCC 内联流水线
MODULE_PASS	shadow-stack-gc-lowering	ShadowStackGCLoweringPass	将 Shadow Stack GC 转换为显式指令序列
MODULE_PASS	strip	StripSymbolsPass	删除所有符号表信息以减小二进制大小
MODULE_PASS	strip-dead-debug-info	StripDeadDebugInfoPass	删除未引用的调试信息以加快加载速度
MODULE_PASS	strip-dead-prototypes	StripDeadPrototypesPass	删除无用的函数原型声明
MODULE_PASS	strip-debug-declare	StripDebugDeclarePass	删除 llvm.dbg.declare 调试声明
MODULE_PASS	strip-nondebug	StripNonDebugSymbolsPass	删除非调试符号，仅保留调试相关符号
MODULE_PASS	strip-nonlinetable-debuginfo	StripNonLineTableDebugInfoPass	删除行号表以外的调试信息
MODULE_PASS	strip-dead-cg-profile	StripDeadCGProfilePass	删除无用的调用图配置文件数据
MODULE_PASS	trigger-crash-module	TriggerCrashModulePass	强制引发崩溃以测试 Pass 管道的鲁棒性
MODULE_PASS	trigger-verifier-error	TriggerVerifierErrorPass	强制触发验证器错误以测试验证流程
MODULE_PASS	tsan-module	ModuleThreadSanitizerPass	插装线程 Sanitizer 以检测数据竞争
MODULE_PASS	tysan	TypeSanitizerPass	插装类型 Sanitizer 以检测内存越界和类型混用
MODULE_PASS	verify	VerifierPass	验证所有 IR 变换后的合法性以确保无错误
MODULE_PASS	view-callgraph	CallGraphViewerPass	以图形化方式展示调用图（依赖 GUI）
MODULE_PASS	wholeprogramdevirt	WholeProgramDevirtPass	全程序级虚函数去虚化，转为直接调用
MODULE_PASS_WITH_PARAMS	asan	AddressSanitizerPass	插装 AddressSanitizer 以检测内存越界和使用后释放
MODULE_PASS_WITH_PARAMS	cg-profile	CGProfilePass	基于调用图数据插装或使用调用图分析
MODULE_PASS_WITH_PARAMS	global-merge	GlobalMergePass	按多种策略合并全局变量以减少冗余
MODULE_PASS_WITH_PARAMS	embed-bitcode	EmbedBitcodePass	将 Bitcode 嵌入到目标文件，支持 LTO 和摘要导出
MODULE_PASS_WITH_PARAMS	globaldce	GlobalDCEPass	删除全局范围内不可达的函数和变量
MODULE_PASS_WITH_PARAMS	hwasan	HWAddressSanitizerPass	插装硬件辅助 ASan 检测，并可选择恢复模式
MODULE_PASS_WITH_PARAMS	internalize	InternalizePass	将非保留全局符号标记为内部可见，优化符号导出
MODULE_PASS_WITH_PARAMS	ipsccp	IPSCCPPass	在跨函数常量传播中应用间过程 SCCP 分析
MODULE_PASS_WITH_PARAMS	loop-extract	LoopExtractorPass	从循环体中提取基本块用于独立分析或优化
MODULE_PASS_WITH_PARAMS	memprof-use	MemProfUsePass	指定采样文件并插装内存使用采样分析
MODULE_PASS_WITH_PARAMS	msan	MemorySanitizerPass	插装 MemorySanitizer 检测未初始化内存读取
MODULE_PASS_WITH_PARAMS	print<structural-hash>	StructuralHashPrinterPass	打印结构哈希分析结果，支持详细和忽略调用目标选项
CGSCC_ANALYSIS	no-op-cgscc	NoOpCGSCCAnalysis	CGSCC 级别空操作分析，占位用
CGSCC_ANALYSIS	fam-proxy	FunctionAnalysisManagerCGSCCProxy	在 CGSCC 管道中代理 FAM 分析结果
CGSCC_ANALYSIS	pass-instrumentation	PassInstrumentationAnalysis	插装 CGSCC 级别的 Pass 运行时数据采集
CGSCC_PASS	argpromotion	ArgumentPromotionPass	将函数内部可替换参数提升到寄存器以减少内存访问
CGSCC_PASS	attributor-cgscc	AttributorCGSCCPass	在 CGSCC 级别运行属性推导
CGSCC_PASS	attributor-light-cgscc	AttributorLightCGSCCPass	轻量级 CGSCC 属性推导
CGSCC_PASS	invalidate	InvalidateAllAnalysesPass	使 CGSCC 级别所有分析结果失效
CGSCC_PASS	no-op-cgscc	NoOpCGSCCPass	CGSCC 级别空操作 Pass
CGSCC_PASS	openmp-opt-cgscc	OpenMPOptCGSCCPass	在 CGSCC 管道中优化 OpenMP 代码
CGSCC_PASS	coro-annotation-elide	CoroAnnotationElidePass	消除协程注释以简化 CoroSplit 分析
CGSCC_PASS_WITH_PARAMS	coro-split	CoroSplitPass	分裂协程帧，可重用存储选项
CGSCC_PASS_WITH_PARAMS	function-attrs	PostOrderFunctionAttrsPass	CGSCC 级别后序推断函数属性，可跳过非递归函数
CGSCC_PASS_WITH_PARAMS	inline	InlinerPass	CGSCC 级别仅内联强制标记的调用
FUNCTION_ANALYSIS	aa	AAManager	构建和管理别名分析，检测指针可能指向的内存区域
FUNCTION_ANALYSIS	access-info	LoopAccessAnalysis	分析循环中内存访问模式，支持安全优化
FUNCTION_ANALYSIS	assumptions	AssumptionAnalysis	收集并利用假设条件以驱动优化决策
FUNCTION_ANALYSIS	bb-sections-profile-reader	BasicBlockSectionsProfileReaderAnalysis	从分段配置文件读取基本块执行频率信息
FUNCTION_ANALYSIS	block-freq	BlockFrequencyAnalysis	基于配置或分析推断基本块执行频率
FUNCTION_ANALYSIS	branch-prob	BranchProbabilityAnalysis	估算分支概率以辅助代码布局优化
FUNCTION_ANALYSIS	cycles	CycleAnalysis	分析依赖图中的循环，以识别并行化机会
FUNCTION_ANALYSIS	da	DependenceAnalysis	检测内存访问依赖关系，支持循环并行化和向量化
FUNCTION_ANALYSIS	debug-ata	DebugAssignmentTrackingAnalysis	跟踪变量赋值以调试和分析数据流
FUNCTION_ANALYSIS	demanded-bits	DemandedBitsAnalysis	识别实际使用的值位，支持位级别优化
FUNCTION_ANALYSIS	domfrontier	DominanceFrontierAnalysis	构建支配边界，用于 SSA 重构和优化
FUNCTION_ANALYSIS	domtree	DominatorTreeAnalysis	构建支配树，以便快速查询支配关系
FUNCTION_ANALYSIS	ephemerals	EphemeralValuesAnalysis	分析短生命周期值，用于消除不必要的存储
FUNCTION_ANALYSIS	func-properties	FunctionPropertiesAnalysis	推断函数属性（如无副作用、纯函数等）
FUNCTION_ANALYSIS	machine-function-info	MachineFunctionAnalysis	收集机器级函数信息，用于后端优化
FUNCTION_ANALYSIS	gc-function	GCFunctionAnalysis	分析垃圾回收相关函数调用模式
FUNCTION_ANALYSIS	inliner-size-estimator	InlineSizeEstimatorAnalysis	估算内联后代码规模，辅助内联决策
FUNCTION_ANALYSIS	last-run-tracking	LastRunTrackingAnalysis	跟踪上次 Pass 运行状态以支持增量优化
FUNCTION_ANALYSIS	lazy-value-info	LazyValueAnalysis	延迟评估值，以减少不必要的计算
FUNCTION_ANALYSIS	loops	LoopAnalysis	检测并分类循环，支持后续循环优化
FUNCTION_ANALYSIS	memdep	MemoryDependenceAnalysis	分析内存依赖，支持调度和并行优化
FUNCTION_ANALYSIS	memoryssa	MemorySSAAnalysis	构建 MemorySSA，以便精确跟踪内存定义与使用
FUNCTION_ANALYSIS	no-op-function	NoOpFunctionAnalysis	空操作分析，占位用
FUNCTION_ANALYSIS	opt-remark-emit	OptimizationRemarkEmitterAnalysis	在优化过程中生成诊断报告
FUNCTION_ANALYSIS	pass-instrumentation	PassInstrumentationAnalysis	插装函数级 Pass 运行统计采集
FUNCTION_ANALYSIS	phi-values	PhiValuesAnalysis	分析 φ 节点的值域，用于常量传播
FUNCTION_ANALYSIS	postdomtree	PostDominatorTreeAnalysis	构建后支配树，用于控制依赖分析
FUNCTION_ANALYSIS	regions	RegionInfoAnalysis	分析代码区域结构，支持大范围代码布局优化
FUNCTION_ANALYSIS	scalar-evolution	ScalarEvolutionAnalysis	对循环中的算术和指针进程建模
FUNCTION_ANALYSIS	should-not-run-function-passes	ShouldNotRunFunctionPassesAnalysis	判断哪些函数 Pass 应跳过
FUNCTION_ANALYSIS	should-run-extra-vector-passes	ShouldRunExtraVectorPasses	决定哪些函数需要额外向量化 Pass
FUNCTION_ANALYSIS	ssp-layout	SSPLayoutAnalysis	分析堆栈保护布局以插装安全检查
FUNCTION_ANALYSIS	stack-safety-local	StackSafetyAnalysis	本地函数级栈安全分析，检测潜在溢出
FUNCTION_ANALYSIS	target-ir	TM	获取目标架构的 IR 分析接口
FUNCTION_ANALYSIS	target-lib-info	TargetLibraryAnalysis	提供标准库函数的信息以支持内联和优化
FUNCTION_ANALYSIS	uniformity	UniformityInfoAnalysis	分析值在不同线程或向量元素间的一致性
FUNCTION_ANALYSIS	verify	VerifierAnalysis	验证函数级 IR 的合法性和一致性
FUNCTION_ALIAS_ANALYSIS	basic-aa	BasicAA	基础别名分析，快速检测简单指针别名情况
FUNCTION_ALIAS_ANALYSIS	objc-arc-aa	objcarc::ObjCARCAA	针对 Objective-C ARC 的别名分析
FUNCTION_ALIAS_ANALYSIS	scev-aa	SCEVAA	基于标量演化（SCEV）的别名分析
FUNCTION_ALIAS_ANALYSIS	scoped-noalias-aa	ScopedNoAliasAA	在特定作用域内进行无别名假设分析
FUNCTION_ALIAS_ANALYSIS	tbaa	TypeBasedAA	基于类型信息的别名分析，利用类型不变性消除别名
FUNCTION_PASS	aa-eval	AAEvaluator	评估别名分析结果，用于后续优化决策
FUNCTION_PASS	adce	ADCEPass	先进死代码删除（Aggressive DCE），移除尽可能多的无用代码
FUNCTION_PASS	add-discriminators	AddDiscriminatorsPass	在指令中添加调试鉴别器，改进混淆和剖析映射
FUNCTION_PASS	aggressive-instcombine	AggressiveInstCombinePass	更积极地合并和简化指令
FUNCTION_PASS	alignment-from-assumptions	AlignmentFromAssumptionsPass	根据假设推断并应用更严格的对齐
FUNCTION_PASS	annotation-remarks	AnnotationRemarksPass	发出关于注解使用的诊断备注
FUNCTION_PASS	assume-builder	AssumeBuilderPass	构建假设条件表达式，支持条件优化
FUNCTION_PASS	assume-simplify	AssumeSimplifyPass	简化假设条件，减少冗余判断
FUNCTION_PASS	atomic-expand	AtomicExpandPass	展开原子操作为平台指令序列
FUNCTION_PASS	bdce	BDCEPass	基本块死代码删除（Block DCE），移除未执行块
FUNCTION_PASS	break-crit-edges	BreakCriticalEdgesPass	拆分关键控制流边，以便 SSA 转换
FUNCTION_PASS	callbr-prepare	CallBrPreparePass	为调用/分支混合指令准备分析结构
FUNCTION_PASS	callsite-splitting	CallSiteSplittingPass	拆分多调用站点以启用不同优化策略
FUNCTION_PASS	chr	ControlHeightReductionPass	降低控制流高度，简化嵌套分支
FUNCTION_PASS	codegenprepare	CodeGenPreparePass	预处理 IR 以满足后端代码生成要求
FUNCTION_PASS	complex-deinterleaving	ComplexDeinterleavingPass	对复杂交错访问执行反交错处理
FUNCTION_PASS	consthoist	ConstantHoistingPass	将循环或条件内的常量提升到外部
FUNCTION_PASS	constraint-elimination	ConstraintEliminationPass	消除冗余约束条件
FUNCTION_PASS	coro-elide	CoroElidePass	在协程转换中消除无用中间状态
FUNCTION_PASS	correlated-propagation	CorrelatedValuePropagationPass	基于相关性传播常量
FUNCTION_PASS	count-visits	CountVisitsPass	插装基本块访问计数，用于分析或 Profile
FUNCTION_PASS	dce	DCEPass	标准死代码删除
FUNCTION_PASS	declare-to-assign	llvm::AssignmentTrackingPass	跟踪变量赋值，替换声明为赋值链
FUNCTION_PASS	dfa-jump-threading	DFAJumpThreadingPass	数据流驱动的跳转合并，优化分支可达性
FUNCTION_PASS	div-rem-pairs	DivRemPairsPass	合并除法和取余对以减少重复计算
FUNCTION_PASS	dot-cfg	CFGPrinterPass	将控制流图输出为 DOT 格式
FUNCTION_PASS	dot-cfg-only	CFGOnlyPrinterPass	仅输出 CFG，不生成分析
FUNCTION_PASS	dot-dom	DomPrinter	将支配树输出为 DOT 格式
FUNCTION_PASS	dot-dom-only	DomOnlyPrinter	仅输出支配树，不生成分析
FUNCTION_PASS	dot-post-dom	PostDomPrinter	将后支配树输出为 DOT
FUNCTION_PASS	dot-post-dom-only	PostDomOnlyPrinter	仅输出后支配树
FUNCTION_PASS	dse	DSEPass	删除冗余存储和加载（Dead Store Elimination）
FUNCTION_PASS	dwarf-eh-prepare	DwarfEHPreparePass	为 DWARF 异常处理生成辅助结构
FUNCTION_PASS	expand-large-div-rem	ExpandLargeDivRemPass	将大型除法/取余指令展开为循环或调用
FUNCTION_PASS	expand-fp	ExpandFpPass	展开浮点操作以满足目标架构要求
FUNCTION_PASS	expand-memcmp	ExpandMemCmpPass	将 memcmp 调用展开为字节比较循环
FUNCTION_PASS	extra-vector-passes	ExtraFunctionPassManager	对标记的函数执行额外向量化 Pass
FUNCTION_PASS	fix-irreducible	FixIrreduciblePass	转换不可约循环结构为可约
FUNCTION_PASS	flatten-cfg	FlattenCFGPass	将多分支结构扁平化以简化分析
FUNCTION_PASS	float2int	Float2IntPass	将浮点 to 整数转换指令标准化
FUNCTION_PASS	gc-lowering	GCLoweringPass	将垃圾回收相关调用转换为显式状态点
FUNCTION_PASS	guard-widening	GuardWideningPass	扩宽守护检查以减少分支
FUNCTION_PASS	gvn-hoist	GVNHoistPass	将公共子表达式提升出循环或分支
FUNCTION_PASS	gvn-sink	GVNSinkPass	将不常用计算下沉到分支内部
FUNCTION_PASS	helloworld	HelloWorldPass	示例 Pass，打印“Hello World”
FUNCTION_PASS	indirectbr-expand	IndirectBrExpandPass	展开 indirectbr 指令为 switch 或跳表
FUNCTION_PASS	infer-address-spaces	InferAddressSpacesPass	推断指针地址空间属性
FUNCTION_PASS	infer-alignment	InferAlignmentPass	推断并应用内存对齐属性
FUNCTION_PASS	inject-tli-mappings	InjectTLIMappings	注入目标特定映射信息，支持目标集成
FUNCTION_PASS	instcount	InstCountPass	统计指令数量和类型分布
FUNCTION_PASS	instnamer	InstructionNamerPass	为指令生成可读名称，辅助调试
FUNCTION_PASS	instsimplify	InstSimplifyPass	简化冰山浮点和整数指令
FUNCTION_PASS	interleaved-access	InterleavedAccessPass	将内存交错访问转换为标准访问
FUNCTION_PASS	interleaved-load-combine	InterleavedLoadCombinePass	合并交错加载为宽加载
FUNCTION_PASS	invalidate	InvalidateAllAnalysesPass	使所有函数级分析失效
FUNCTION_PASS	irce	IRCEPass	交互式冗余计算消除（IR-level CSE）
FUNCTION_PASS	jump-threading	JumpThreadingPass	进行跳转穿线以简化分支
FUNCTION_PASS	jump-table-to-switch	JumpTableToSwitchPass	将跳表转换为 switch 语句
FUNCTION_PASS	kcfi	KCFIPass	插装 KCFI 控制流完整性检查
FUNCTION_PASS	kernel-info	KernelInfoPrinter	打印内核特定信息
FUNCTION_PASS	lcssa	LCSSAPass	将循环退出块上的 PHI 转换为 LCSSA 形式
FUNCTION_PASS	libcalls-shrinkwrap	LibCallsShrinkWrapPass	缩减库调用保护代码路径
FUNCTION_PASS	load-store-vectorizer	LoadStoreVectorizerPass	向量化串行 load/store
FUNCTION_PASS	loop-data-prefetch	LoopDataPrefetchPass	在循环中插装数据预取指令
FUNCTION_PASS	loop-distribute	LoopDistributePass	将循环分布到多个独立循环中
FUNCTION_PASS	loop-fusion	LoopFusePass	合并相邻循环以减少循环开销
FUNCTION_PASS	loop-load-elim	LoopLoadEliminationPass	消除循环内冗余加载
FUNCTION_PASS	loop-simplify	LoopSimplifyPass	将循环标准化为单入口单出口形式
FUNCTION_PASS	loop-sink	LoopSinkPass	将不常用计算下沉
FUNCTION_PASS	loop-versioning	LoopVersioningPass	对循环进行版本化以消除边界检查
FUNCTION_PASS	lower-atomic	LowerAtomicPass	将原子指令降级为库调用或内联序列
FUNCTION_PASS	lower-constant-intrinsics	LowerConstantIntrinsicsPass	将常量内建函数展开为常规 IR
FUNCTION_PASS	lower-expect	LowerExpectIntrinsicPass	将 expect 内建函数转换为分支预测提示
FUNCTION_PASS	lower-guard-intrinsic	LowerGuardIntrinsicPass	将 guard 内建函数转换为条件跳转
FUNCTION_PASS	lower-invoke	LowerInvokePass	将 invoke 指令转换为普通调用+异常处理
FUNCTION_PASS	lower-switch	LowerSwitchPass	将 switch 指令转换为跳表或二分查找
FUNCTION_PASS	lower-widenable-condition	LowerWidenableConditionPass	将可扩展条件转换为动态检查
FUNCTION_PASS	make-guards-explicit	MakeGuardsExplicitPass	将隐式守护条件显式化，便于后续优化
FUNCTION_PASS	mem2reg	PromotePass	将内存分配的局部变量提升到寄存器 (Mem2Reg)
FUNCTION_PASS	memcpyopt	MemCpyOptPass	优化 memcpy 调用，合并或移除冗余内存复制
FUNCTION_PASS	memprof	MemProfilerPass	插装内存探测器，以收集内存访问性能数据
FUNCTION_PASS	mergeicmps	MergeICmpsPass	合并相邻的相同 icmp 比较以减少指令
FUNCTION_PASS	mergereturn	UnifyFunctionExitNodesPass	将多个函数返回点合并为单一出口
FUNCTION_PASS	move-auto-init	MoveAutoInitPass	将自动变量初始化代码移动到更优位置
FUNCTION_PASS	nary-reassociate	NaryReassociatePass	对多元加减运算重新关联以增强常量传播
FUNCTION_PASS	newgvn	NewGVNPass	执行新版全局值编号 (GVN) 优化，消除公共子表达式
FUNCTION_PASS	no-op-function	NoOpFunctionPass	空操作函数级 Pass，占位不做变换
FUNCTION_PASS	objc-arc	ObjCARCOptPass	Objective-C ARC 自动引用计数优化
FUNCTION_PASS	objc-arc-contract	ObjCARCContractPass	ARC 优化中合并 retain/release 对
FUNCTION_PASS	objc-arc-expand	ObjCARCExpandPass	将 ARC 内建操作展开为显式调用
FUNCTION_PASS	pa-eval	PAEvalPass	对指令进行预测分析，以支持分支预测优化
FUNCTION_PASS	partially-inline-libcalls	PartiallyInlineLibCallsPass	将部分库函数内联以减少调用开销
FUNCTION_PASS	pgo-memop-opt	PGOMemOPSizeOpt	基于 PGO 数据优化内存操作大小
FUNCTION_PASS	place-safepoints	PlaceSafepointsPass	插入垃圾回收安全点
FUNCTION_PASS	print	PrintFunctionPass	打印函数级 IR 到 stderr
FUNCTION_PASS	print-alias-sets	AliasSetsPrinterPass	打印函数别名集信息到 stderr
FUNCTION_PASS	print-cfg-sccs	CFGSCCPrinterPass	打印函数内 SCC CFG 到 stderr
FUNCTION_PASS	print-memderefs	MemDerefPrinterPass	打印可能的内存解引用点
FUNCTION_PASS	print-mustexecute	MustExecutePrinterPass	打印必须执行的指令上下文
FUNCTION_PASS	print-predicateinfo	PredicateInfoPrinterPass	打印谓词分析信息
FUNCTION_PASS	print<access-info>	LoopAccessInfoPrinterPass	打印循环访问信息
FUNCTION_PASS	print<assumptions>	AssumptionPrinterPass	打印假设分析结果
FUNCTION_PASS	print<block-freq>	BlockFrequencyPrinterPass	打印基本块频率
FUNCTION_PASS	print<branch-prob>	BranchProbabilityPrinterPass	打印分支概率
FUNCTION_PASS	print<cost-model>	CostModelPrinterPass	打印成本模型估算
FUNCTION_PASS	print<cycles>	CycleInfoPrinterPass	打印循环依赖分析信息
FUNCTION_PASS	print<da>	DependenceAnalysisPrinterPass	打印依赖分析结果
FUNCTION_PASS	print<debug-ata>	DebugAssignmentTrackingPrinterPass	打印赋值跟踪信息
FUNCTION_PASS	print<delinearization>	DelinearizationPrinterPass	打印指针去线性化信息
FUNCTION_PASS	print<demanded-bits>	DemandedBitsPrinterPass	打印位需求分析结果
FUNCTION_PASS	print<domfrontier>	DominanceFrontierPrinterPass	打印支配边界
FUNCTION_PASS	print<domtree>	DominatorTreePrinterPass	打印支配树
FUNCTION_PASS	print<func-properties>	FunctionPropertiesPrinterPass	打印函数属性分析结果
FUNCTION_PASS	print<inline-cost>	InlineCostAnnotationPrinterPass	打印内联成本注解
FUNCTION_PASS	print<inliner-size-estimator>	InlineSizeEstimatorAnalysisPrinterPass	打印内联大小估算
FUNCTION_PASS	print<lazy-value-info>	LazyValueInfoPrinterPass	打印延迟值分析信息
FUNCTION_PASS	print<loops>	LoopPrinterPass	打印循环结构信息
FUNCTION_PASS	print<memoryssa-walker>	MemorySSAWalkerPrinterPass	打印 MemorySSA 遍历器信息
FUNCTION_PASS	print<phi-values>	PhiValuesPrinterPass	打印 φ 节点值信息
FUNCTION_PASS	print<postdomtree>	PostDominatorTreePrinterPass	打印后支配树
FUNCTION_PASS	print<regions>	RegionInfoPrinterPass	打印区域信息
FUNCTION_PASS	print<scalar-evolution>	ScalarEvolutionPrinterPass	打印标量演化分析结果
FUNCTION_PASS	print、	StackSafetyPrinterPass	打印栈安全本地分析结果
FUNCTION_PASS	print<uniformity>	UniformityInfoPrinterPass	打印一致性分析信息
FUNCTION_PASS	reassociate	ReassociatePass	对加减乘除表达式重新关联
FUNCTION_PASS	redundant-dbg-inst-elim	RedundantDbgInstEliminationPass	删除冗余调试指令
FUNCTION_PASS	reg2mem	RegToMemPass	将寄存器变量重新映射回内存
FUNCTION_PASS	safe-stack	SafeStackPass	插装安全栈以防止栈溢出
FUNCTION_PASS	sandbox-vectorizer	SandboxVectorizerPass	在沙箱模式下向量化内存访问
FUNCTION_PASS	scalarize-masked-mem-intrin	ScalarizeMaskedMemIntrinPass	将掩码内存内建展开为标量操作
FUNCTION_PASS	sccp	SCCPPass	稀疏条件常量传播 (SCCP)
FUNCTION_PASS	select-optimize	SelectOptimizePass	优化 select 内建指令
FUNCTION_PASS	separate-const-offset-from-gep	SeparateConstOffsetFromGEPPass	从 GEP 提取常量偏移
FUNCTION_PASS	sink	SinkingPass	将计算下沉到更冷的分支
FUNCTION_PASS	sjlj-eh-prepare	SjLjEHPreparePass	为 setjmp/longjmp 异常处理准备辅助结构
FUNCTION_PASS	slp-vectorizer	SLPVectorizerPass	基于超块的向量化
FUNCTION_PASS	slsr	StraightLineStrengthReducePass	直线代码强度归约
FUNCTION_PASS	stack-protector	StackProtectorPass	插装栈保护以检测溢出
FUNCTION_PASS	strip-gc-relocates	StripGCRelocates	删除垃圾回收重定位指令
FUNCTION_PASS	tailcallelim	TailCallElimPass	消除尾调用并转为跳转
FUNCTION_PASS	transform-warning	WarnMissedTransformationsPass	对未应用的变换发出警告
FUNCTION_PASS	trigger-crash-function	TriggerCrashFunctionPass	强制在函数中引发崩溃以测试管道
FUNCTION_PASS	trigger-verifier-error	TriggerVerifierErrorPass	强制触发验证器错误
FUNCTION_PASS	tsan	ThreadSanitizerPass	插装线程 Sanitizer 以检测数据竞争
FUNCTION_PASS	typepromotion	TypePromotionPass	将小整数类型提升为更大类型以优化指令
FUNCTION_PASS	unify-loop-exits	UnifyLoopExitsPass	合并循环退出点
FUNCTION_PASS	vector-combine	VectorCombinePass	合并向量操作以提高利用率
FUNCTION_PASS	verify	VerifierPass	验证函数级 IR 合法性
FUNCTION_PASS	verify	CycleInfoVerifierPass	验证循环依赖分析正确性
FUNCTION_PASS	verify	DominatorTreeVerifierPass	验证支配树正确性
FUNCTION_PASS	verify	LoopVerifierPass	验证循环分析正确性
FUNCTION_PASS	verify	MemorySSAVerifierPass	验证 MemorySSA 正确性
FUNCTION_PASS	verify	RegionInfoVerifierPass	验证区域信息正确性
FUNCTION_PASS	verify	SafepointIRVerifierPass	验证安全点 IR 正确性
FUNCTION_PASS	verify	ScalarEvolutionVerifierPass	验证标量演化分析正确性
FUNCTION_PASS	view-cfg	CFGViewerPass	图形化展示函数内控制流图
FUNCTION_PASS	view-cfg-only	CFGOnlyViewerPass	仅图形化展示 CFG
FUNCTION_PASS	view-dom	DomViewer	图形化展示支配树
FUNCTION_PASS	view-dom-only	DomOnlyViewer	仅图形化展示支配树
FUNCTION_PASS	view-post-dom	PostDomViewer	图形化展示后支配树
FUNCTION_PASS	view-post-dom-only	PostDomOnlyViewer	仅图形化展示后支配树
FUNCTION_PASS	wasm-eh-prepare	WasmEHPreparePass	为 WebAssembly 异常处理生成辅助结构
FUNCTION_PASS_WITH_PARAMS	cfguard	CFGuardPass	插装 Control-Flow Guard 检查与跳转保护
FUNCTION_PASS_WITH_PARAMS	early-cse	EarlyCSEPass	早期公共子表达式消除，可选 MemorySSA 支持
FUNCTION_PASS_WITH_PARAMS	ee-instrument	EntryExitInstrumenterPass	插装函数入口/出口钩子，可选后内联模式
FUNCTION_PASS_WITH_PARAMS	function-simplification		构建函数级简化流水线，支持不同优化级别
FUNCTION_PASS_WITH_PARAMS	gvn	GVNPass	全局值编号消除公共子表达式，选项控制预合并与 MemorySSA
FUNCTION_PASS_WITH_PARAMS	hardware-loops	HardwareLoopsPass	将循环转换为硬件循环指令，可强制、嵌套与位宽选项
FUNCTION_PASS_WITH_PARAMS	instcombine	InstCombinePass	指令合并与常见模式简化，控制循环信息与 fixpoint 验证
FUNCTION_PASS_WITH_PARAMS	lint	LintPass	静态“代码审查”检查，遇错可中止
FUNCTION_PASS_WITH_PARAMS	loop-unroll	LoopUnrollPass	循环展开，支持部分/全展开与剥离策略
FUNCTION_PASS_WITH_PARAMS	loop-vectorize	LoopVectorizePass	循环向量化，强制/排除交错与向量化策略
FUNCTION_PASS_WITH_PARAMS	lower-allow-check	LowerAllowCheckPass	将允许检查谓词内建降低为显式条件
FUNCTION_PASS_WITH_PARAMS	lower-matrix-intrinsics	LowerMatrixIntrinsicsPass	将矩阵内建展开为循环或标量运算，可选最小化策略
FUNCTION_PASS_WITH_PARAMS	normalize	IRNormalizerPass	对 IR 做标准化重排，控制操作顺序与重命名
FUNCTION_PASS_WITH_PARAMS	mldst-motion	MergedLoadStoreMotionPass	合并迁移加载/存储，优化访存合并与 BB 尾部分割
FUNCTION_PASS_WITH_PARAMS	print<da>	DependenceAnalysisPrinterPass	打印依赖分析结果，可选归一化输出
FUNCTION_PASS_WITH_PARAMS	print<memoryssa>	MemorySSAPrinterPass	打印 MemorySSA 结构，可选跳过优化检查
FUNCTION_PASS_WITH_PARAMS	print<stack-lifetime>	StackLifetimePrinterPass	打印栈生命周期信息，选择 may/must 分析
FUNCTION_PASS_WITH_PARAMS	scalarizer	ScalarizerPass	将矢量/内建内存操作标量化，细化 load/store 与插入/extract
FUNCTION_PASS_WITH_PARAMS	separate-const-offset-from-gep	SeparateConstOffsetFromGEPPass	从 GEP 指令中分离常量偏移，可降低 GEP 复杂度
FUNCTION_PASS_WITH_PARAMS	simplifycfg	SimplifyCFGPass	简化控制流图，支持 switch 优化、循环保留与公共指令提升/下沉
FUNCTION_PASS_WITH_PARAMS	speculative-execution	SpeculativeExecutionPass	插装或重写分支以进行投机执行，可选仅针对分歧目标
FUNCTION_PASS_WITH_PARAMS	sroa	SROAPass	聚合类型标量替换，将 struct/array 拆为标量以支持 Mem2Reg
FUNCTION_PASS_WITH_PARAMS	structurizecfg	StructurizeCFG	将 CFG 转换为结构化控制流，以支持 GPU/Shader 后端
FUNCTION_PASS_WITH_PARAMS	win-eh-prepare	WinEHPreparePass	为 Windows 异常处理生成 PHI 和辅助块，可降级仅捕获 switch PHI
FUNCTION_PASS_WITH_PARAMS	bounds-checking	BoundsCheckingPass	插装数组/指针越界检查，可选 trap 中断行为
LOOPNEST_PASS	loop-flatten	LoopFlattenPass	展平嵌套循环，将多层循环转换为单层
LOOPNEST_PASS	loop-interchange	LoopInterchangePass	交换内外循环以改善数据局部性
LOOPNEST_PASS	loop-unroll-and-jam	LoopUnrollAndJamPass	解卷循环并融合循环体以提高并行度
LOOPNEST_PASS	no-op-loopnest	NoOpLoopNestPass	空操作 LoopNest Pass，占位测试
LOOP_ANALYSIS	ddg	DDGAnalysis	构建循环数据依赖图（DDG）以分析依赖关系
LOOP_ANALYSIS	iv-users	IVUsersAnalysis	分析归纳变量的使用情况以辅助变换
LOOP_ANALYSIS	no-op-loop	NoOpLoopAnalysis	空操作 Loop Analysis，占位用
LOOP_ANALYSIS	pass-instrumentation	PassInstrumentationAnalysis	插装循环级 Pass 运行统计
LOOP_ANALYSIS	should-run-extra-simple-loop-unswitch	ShouldRunExtraSimpleLoopUnswitch	判断是否执行简单循环非交换优化
LOOP_PASS	canon-freeze	CanonicalizeFreezeInLoopsPass	标准化循环中的 freeze 操作以简化优化
LOOP_PASS	dot-ddg	DDGDotPrinterPass	将循环数据依赖图输出为 DOT 格式
LOOP_PASS	guard-widening	GuardWideningPass	扩宽循环守护条件以减少分支
LOOP_PASS	extra-simple-loop-unswitch-passes	ExtraLoopPassManager	对可简单非交换的循环执行附加 Pass
LOOP_PASS	indvars	IndVarSimplifyPass	归纳变量简化，标准化 IV 用法
LOOP_PASS	invalidate	InvalidateAllAnalysesPass	使所有循环级分析结果失效
LOOP_PASS	loop-bound-split	LoopBoundSplitPass	按循环边界条件拆分循环以移除检查
LOOP_PASS	loop-deletion	LoopDeletionPass	删除不执行或无效的循环
LOOP_PASS	loop-idiom	LoopIdiomRecognizePass	识别并替换常见循环习语
LOOP_PASS	loop-idiom-vectorize	LoopIdiomVectorizePass	将识别的习语向量化
LOOP_PASS	loop-instsimplify	LoopInstSimplifyPass	在循环内简化指令
LOOP_PASS	loop-predication	LoopPredicationPass	循环谓词化，移出条件分支
LOOP_PASS	loop-reduce	LoopStrengthReducePass	循环强度归约，简化乘除为加法
LOOP_PASS	loop-term-fold	LoopTermFoldPass	折叠循环终止条件表达式
LOOP_PASS	loop-simplifycfg	LoopSimplifyCFGPass	将循环 CFG 标准化为单入口单出口
LOOP_PASS	loop-unroll-full	LoopFullUnrollPass	对循环进行完全展开
LOOP_PASS	loop-versioning-licm	LoopVersioningLICMPass	循环版本化，结合 LICM 消除边界检查
LOOP_PASS	no-op-loop	NoOpLoopPass	空操作 Loop Pass，占位测试
LOOP_PASS	print	PrintLoopPass	打印循环信息到 stderr
LOOP_PASS	print<ddg>	DDGAnalysisPrinterPass	打印循环数据依赖图分析结果
LOOP_PASS	print<iv-users>	IVUsersPrinterPass	打印归纳变量使用情况
LOOP_PASS	print<loop-cache-cost>	LoopCachePrinterPass	打印循环缓存成本估算
LOOP_PASS	print<loopnest>	LoopNestPrinterPass	打印循环嵌套结构
LOOP_PASS_WITH_PARAMS	licm	LICMPass	循环内存量化消除（LICM），可选投机执行
LOOP_PASS_WITH_PARAMS	lnicm	LNICMPass	延迟 LICM，待条件满足后再提升公共子表达式
LOOP_PASS_WITH_PARAMS	loop-rotate	LoopRotatePass	循环旋转，重排循环头部以优化分支和并行
LOOP_PASS_WITH_PARAMS	simple-loop-unswitch	SimpleLoopUnswitchPass	简单循环非交换，移出循环不变条件

附录 C-解析脚本

#!/usr/bin/env python3
"""
生成 LLVM PassRegistry.def 宏定义的 Markdown 表格
用法：python3 generate_pass_table.py PassRegistry.def > passes.md
"""

import re, sys, itertools

def glue_lines(lines):
    """跨行累积直到括号平衡并含注释，输出(逻辑行号, 拼合行)"""
    depth, buf = 0, []
    for ln, raw in enumerate(lines, 1):
        txt = raw.rstrip("\n")
        if not txt.strip():
            continue
        buf.append(txt)
        depth += txt.count("(") - txt.count(")")
        if depth == 0 and "//" in txt:
            yield ln, " ".join(buf)
            buf.clear()
    if buf:
        yield ln, " ".join(buf)

# 宏名前缀
MACROS = r'\w+_(?:PASS(?:_WITH_PARAMS)?|ANALYSIS|ALIAS_ANALYSIS|NEST_PASS)'

# 模式1：第二个参数为字符串（允许为空）
P1 = re.compile(
    rf'^(?P<macro>{MACROS})\s*'
    r'\(\s*"(?P<short>[^"]+)"\s*,\s*'      # "short"
    r'"(?P<name>[^"]*)"'                   # "Name"（可为空）
    r'.*?\)\s*//\s*(?P<comment>.+)$'       # ) // comment
)

# 模式2：第二个参数为构造器名
P2 = re.compile(
    rf'^(?P<macro>{MACROS})\s*'
    r'\(\s*"(?P<short>[^"]+)"\s*,\s*'      # "short"
    r'(?P<name>[A-Za-z_][A-Za-z0-9_:<>]*)' # Name
    r'.*?\)\s*//\s*(?P<comment>.+)$'       # ) // comment
)

def parse(path):
    ok, bad = [], []
    with open(path, encoding='utf-8') as f:
        for ln, line in glue_lines(f):
            s = line.strip()
            m = P1.match(s) or P2.match(s)
            if m:
                ok.append(m.groupdict())
            else:
                bad.append((ln, s))
    return ok, bad

def to_markdown(rows):
    header = [
        "| 宏类型 | 缩写 | Pass/Analysis 名称 | 注释 |",
        "|--------|------|--------------------|------|"
    ]
    body = [
        f"| {r['macro']} | {r['short']} | {r['name']} | {r['comment']} |"
        for r in rows
    ]
    return "\n".join(itertools.chain(header, body))

def main():
    if len(sys.argv) != 2:
        sys.exit(f"Usage: {sys.argv[0]} PassRegistry.def")
    ok, bad = parse(sys.argv[1])
    sys.stderr.write(f"[*] 解析成功 {len(ok)} 条\n")
    if bad:
        sys.stderr.write(f"[!] 未匹配 {len(bad)} 条，前 20 行示例：\n")
        for ln, txt in bad[:20]:
            sys.stderr.write(f"    Line {ln}: {txt}\n")
        if len(bad) > 20:
            sys.stderr.write("    ...\n")
    print(to_markdown(ok))

if __name__ == '__main__':
    main()