为中端加入常量传播Pass

Pass_ID_List.md

@@ -14,220 +14,10 @@
 
 Mem2Reg 遍的主要目标是将那些不必要的、只用于局部标量变量的内存分配 (alloca 指令) 消除，并将这些变量的值转换为 SSA 形式。这有助于减少内存访问，提高代码效率，并为后续的优化创造更好的条件。
 
-通过Mem2Reg理解删除指令时对use关系的维护：
-
-在 `Mem2Reg` 优化遍中，当 `load` 和 `store` 指令被删除时，其 `use` 关系（即它们作为操作数与其他 `Value` 对象之间的连接）的正确消除是一个关键问题，尤其涉及到 `AllocaInst`。
-
-结合您提供的 `Mem2RegContext::renameVariables` 代码和我们之前讨论的 `usedelete` 逻辑，下面是 `use` 关系如何被正确消除的详细过程：
-
-### 问题回顾：`Use` 关系的双向性
-
-在您的 IR 设计中，`Use` 对象扮演着连接 `User`（使用者，如 `LoadInst`）和 `Value`（被使用者，如 `AllocaInst`）的双向角色：
-
-* 一个 `User` 持有对其操作数 `Value` 的 `Use` 对象（通过 `User::operands` 列表）。
-* 一个 `Value` 持有所有使用它的 `User` 的 `Use` 对象（通过 `Value::uses` 列表）。
-
-原始问题是：当一个 `LoadInst` 或 `StoreInst` 被删除时，如果不对其作为操作数与 `AllocaInst` 之间的 `Use` 关系进行明确清理，`AllocaInst` 的 `uses` 列表中就会留下指向已删除 `LoadInst` / `StoreInst` 的 `Use` 对象，导致内部的 `User*` 指针悬空，在后续访问时引发 `segmentation fault`。
-
-### `Mem2Reg` 中 `load`/`store` 指令的删除行为
-
-在 `Mem2RegContext::renameVariables` 函数中，`load` 和 `store` 指令被处理时，其行为如下：
-
-1.  **处理 `LoadInst`：**
-    当找到一个指向可提升 `AllocaInst` 的 `LoadInst` 时，其用途会被 `replaceAllUsesWith(allocaToValueStackMap[alloca].top())` 替换。这意味着任何原本使用 `LoadInst` 本身计算结果的指令，现在都直接使用 SSA 值栈顶部的 `Value`。
-    **重点：** 这一步处理的是 `LoadInst` 作为**被使用的值 (Value)** 时，其 `uses` 列表的清理。即，将 `LoadInst` 的所有使用者重定向到新的 SSA 值，并把这些 `Use` 对象从 `LoadInst` 的 `uses` 列表中移除。
-
-2.  **处理 `StoreInst`：**
-    当找到一个指向可提升 `AllocaInst` 的 `StoreInst` 时，`StoreInst` 存储的值会被压入值栈。`StoreInst` 本身并不产生可被其他指令直接使用的值（其类型是 `void`），所以它没有 `uses` 列表需要替换。
-    **重点：** `StoreInst` 的主要作用是更新内存状态，在 SSA 形式下，它被移除后需要清理它作为**使用者 (User)** 时的操作数关系。
-
-在这两种情况下，一旦 `load` 或 `store` 指令的 SSA 转换完成，它们都会通过 `instIter = SysYIROptUtils::usedelete(instIter)` 被显式删除。
-
-### `SysYIROptUtils::usedelete` 如何正确消除 `Use` 关系
-
-关键在于对 `SysYIROptUtils::usedelete` 函数的修改，使其在删除指令时，同时处理该指令作为 `User` 和 `Value` 的两种 `Use` 关系：
-
-1.  **清理指令作为 `Value` 时的 `uses` 列表 (由 `replaceAllUsesWith` 完成)：**
-    在 `usedelete` 函数中，`inst->replaceAllUsesWith(UndefinedValue::get(inst->getType()))` 的调用至关重要。这确保了：
-    * 如果被删除的 `Instruction`（例如 `LoadInst`）产生了结果值并被其他指令使用，所有这些使用者都会被重定向到 `UndefinedValue`（或者 `Mem2Reg` 中具体的 SSA 值）。
-    * 这个过程会遍历 `LoadInst` 的 `uses` 列表，并将这些 `Use` 对象从 `LoadInst` 的 `uses` 列表中移除。这意味着 `LoadInst` 自己不再被任何其他指令使用。
-
-2.  **清理指令作为 `User` 时其操作数的 `uses` 列表 (由 `RemoveUserOperandUses` 完成)：**
-    这是您提出的、并已集成到 `usedelete` 中的关键改进点。对于一个被删除的 `Instruction`（它同时也是 `User`），我们需要清理它**自己使用的操作数**所维护的 `use` 关系。
-    * 例如，`LoadInst %op1` 使用了 `%op1`（一个 `AllocaInst`）。当 `LoadInst` 被删除时，`AllocaInst` 的 `uses` 列表中有一个 `Use` 对象指向这个 `LoadInst`。
-    * `RemoveUserOperandUses` 函数会遍历被删除 `User`（即 `LoadInst` 或 `StoreInst`）的 `operands` 列表。
-    * 对于 `operands` 列表中的每个 `std::shared_ptr<Use> use_ptr`，它会获取 `Use` 对象内部指向的 `Value`（例如 `AllocaInst*`），然后调用 `value->removeUse(use_ptr)`。
-    * 这个 `removeUse` 调用会负责将 `use_ptr` 从 `AllocaInst` 的 `uses` 列表中删除。
-
-### 总结
-
-通过在 `SysYIROptUtils::usedelete` 中同时执行这两个步骤：
-
-* `replaceAllUsesWith`：处理被删除指令**作为结果被使用**时的 `use` 关系。
-* `RemoveUserOperandUses`：处理被删除指令**作为使用者（User）时，其操作数**的 `use` 关系。
-
-这就确保了当 `Mem2Reg` 遍历并删除 `load` 和 `store` 指令时，无论是它们作为 `Value` 的使用者，还是它们作为 `User` 的操作数，所有相关的 `Use` 对象都能被正确地从 `Value` 的 `uses` 列表中移除，从而避免了悬空指针和后续的 `segmentation fault`。
-
-最后，当所有指向某个 `AllocaInst` 的 `load` 和 `store` 指令都被移除后，`AllocaInst` 的 `uses` 列表将变得干净（只包含 Phi 指令，如果它们在 SSA 转换中需要保留 Alloca 作为操作数），这时在 `Mem2RegContext::cleanup()` 阶段，`SysYIROptUtils::usedelete(alloca)` 就可以安全地删除 `AllocaInst` 本身了。
-
 ## Reg2Mem
 
 我们的Reg2Mem 遍的主要目标是作为 Mem2Reg 的一种逆操作，但更具体是解决后端无法识别 PhiInst 指令的问题。主要的速录是将函数参数和 PhiInst 指令的结果从 SSA 形式转换回内存形式，通过插入 alloca、load 和 store 指令来实现。其他非 Phi 的指令结果将保持 SSA 形式。
 
-## SCCP
-
-SCCP（稀疏条件常量传播）是一种编译器优化技术，它结合了常量传播和死代码消除。其核心思想是在程序执行过程中，尝试识别并替换那些在编译时就能确定其值的变量（常量），同时移除那些永远不会被执行到的代码块（不可达代码）。
-
-以下是 SCCP 的实现思路：
-
-1. 核心数据结构与工作列表：
-
-Lattice 值（Lattice Value）: SCCP 使用三值格（Three-Valued Lattice）来表示变量的状态：
-
-Top (T): 初始状态，表示变量的值未知，但可能是一个常量。
-
-Constant (C): 表示变量的值已经确定为一个具体的常量。
-
-Bottom (⊥): 表示变量的值不确定或不是一个常量（例如，它可能在运行时有多个不同的值，或者从内存中加载）。一旦变量状态变为 Bottom，它就不能再变回 Constant 或 Top。
-
-SSAPValue: 封装了 Lattice 值和常量具体值（如果状态是 Constant）。
-
-*valState (map<Value, SSAPValue>):** 存储程序中每个 Value（变量、指令结果等）的当前 SCCP Lattice 状态。
-
-*ExecutableBlocks (set<BasicBlock>):** 存储在分析过程中被确定为可执行的基本块。
-
-工作列表 (Worklists):
-
-cfgWorkList (queue<pair<BasicBlock, BasicBlock>>):** 存储待处理的控制流图（CFG）边。当一个块被标记为可执行时，它的后继边会被添加到这个列表。
-
-*ssaWorkList (queue<Instruction>):** 存储待处理的 SSA (Static Single Assignment) 指令。当一个指令的任何操作数的状态发生变化时，该指令就会被添加到这个列表，需要重新评估。
-
-2. 初始化：
-
-所有 Value 的状态都被初始化为 Top。
-
-所有基本块都被初始化为不可执行。
-
-函数的入口基本块被标记为可执行，并且该块中的所有指令被添加到 ssaWorkList。
-
-3. 迭代过程 (Fixed-Point Iteration)：
-
-SCCP 的核心是一个迭代过程，它交替处理 CFG 工作列表和 SSA 工作列表，直到达到一个不动点（即没有更多的状态变化）。
-
-处理 cfgWorkList:
-
-从 cfgWorkList 中取出一个边 (prev, next)。
-
-如果 next 块之前是不可执行的，现在通过 prev 块可达，则将其标记为可执行 (markBlockExecutable)。
-
-一旦 next 块变为可执行，其内部的所有指令（特别是 Phi 指令）都需要被重新评估，因此将它们添加到 ssaWorkList。
-
-处理 ssaWorkList:
-
-从 ssaWorkList 中取出一个指令 inst。
-
-重要： 只有当 inst 所在的块是可执行的，才处理该指令。不可执行块中的指令不参与常量传播。
-
-计算新的 Lattice 值 (computeLatticeValue): 根据指令类型和其操作数的当前 Lattice 状态，计算 inst 的新的 Lattice 状态。
-
-常量折叠: 如果所有操作数都是常量，则可以直接执行运算并得到一个新的常量结果。
-
-Bottom 传播: 如果任何操作数是 Bottom，或者运算规则导致不确定（例如除以零），则结果为 Bottom。
-
-Phi 指令的特殊处理: Phi 指令的值取决于其所有可执行的前驱块传入的值。
-
-如果所有可执行前驱都提供了相同的常量 C，则 Phi 结果为 C。
-
-如果有任何可执行前驱提供了 Bottom，或者不同的可执行前驱提供了不同的常量，则 Phi 结果为 Bottom。
-
-如果所有可执行前驱都提供了 Top，则 Phi 结果仍为 Top。
-
-更新状态: 如果 inst 的新计算出的 Lattice 值与它当前存储的值不同，则更新 valState[inst]。
-
-传播变化: 如果 inst 的状态发生变化，那么所有使用 inst 作为操作数的指令都可能受到影响，需要重新评估。因此，将 inst 的所有使用者添加到 ssaWorkList。
-
-处理终结符指令 (BranchInst, ReturnInst):
-
-对于条件分支 BranchInst，如果其条件操作数变为常量：
-
-如果条件为真，则只有真分支的目标块是可达的，将该边添加到 cfgWorkList。
-
-如果条件为假，则只有假分支的目标块是可达的，将该边添加到 cfgWorkList。
-
-如果条件不是常量（Top 或 Bottom），则两个分支都可能被执行，将两边的边都添加到 cfgWorkList。
-
-这会影响 CFG 的可达性分析，可能导致新的块被标记为可执行。
-
-4. 应用优化 (Transformation)：
-
-当两个工作列表都为空，达到不动点后，程序代码开始进行实际的修改：
-
-常量替换:
-
-遍历所有指令。如果指令的 valState 为 Constant，则用相应的 ConstantValue 替换该指令的所有用途 (replaceAllUsesWith)。
-
-将该指令标记为待删除。
-
-对于指令的操作数，如果其 valState 为 Constant，则直接将操作数替换为对应的 ConstantValue（常量折叠）。
-
-删除死指令: 遍历所有标记为待删除的指令，并从其父基本块中删除它们。
-
-删除不可达基本块: 遍历函数中的所有基本块。如果一个基本块没有被标记为可执行 (ExecutableBlocks 中不存在)，则将其从函数中删除。但入口块不能删除。
-
-简化分支指令:
-
-遍历所有可执行的基本块的终结符指令。
-
-对于条件分支 BranchInst，如果其条件操作数在 valState 中是 Constant：
-
-如果条件为真，则将该条件分支替换为一个无条件跳转到真分支目标块的指令。
-
-如果条件为假，则将该条件分支替换为一个无条件跳转到假分支目标块的指令。
-
-更新 CFG，移除不可达的分支边和其前驱信息。
-
-computeLatticeValue 的具体逻辑：
-
-这个函数是 SCCP 的核心逻辑，它定义了如何根据指令类型和操作数的当前 Lattice 状态来计算指令结果的 Lattice 状态。
-
-二元运算 (Add, Sub, Mul, Div, Rem, ICmp, And, Or):
-
-如果任何一个操作数是 Bottom，结果就是 Bottom。
-
-如果任何一个操作数是 Top，结果就是 Top。
-
-如果两个操作数都是 Constant，执行实际的常量运算，结果是一个新的 Constant。
-
-一元运算 (Neg, Not):
-
-如果操作数是 Bottom，结果就是 Bottom。
-
-如果操作数是 Top，结果就是 Top。
-
-如果操作数是 Constant，执行实际的常量运算，结果是一个新的 Constant。
-
-Load 指令: 通常情况下，Load 的结果会被标记为 Bottom，因为内存内容通常在编译时无法确定。但如果加载的是已知的全局常量，可能可以确定。在提供的代码中，它通常返回 Bottom。
-
-Store 指令: Store 不产生值，所以其 SSAPValue 保持 Top 或不关心。
-
-Call 指令: 大多数 Call 指令（尤其是对外部或有副作用的函数）的结果都是 Bottom。对于纯函数，如果所有参数都是常量，理论上可以折叠，但这需要额外的分析。
-
-GetElementPtr (GEP) 指令: GEP 计算内存地址。如果所有索引都是常量，地址本身是常量。但 SCCP 关注的是数据值，因此这里通常返回 Bottom，除非有特定的指针常量跟踪。
-
-Phi 指令: 如上所述，基于所有可执行前驱的传入值进行聚合。
-
-Alloc 指令: Alloc 分配内存，返回一个指针。其内容通常是 Bottom。
-
-Branch 和 Return 指令: 这些是终结符指令，不产生一个可用于其他指令的值，通常 SSAPValue 保持 Top 或不关心。
-
-类型转换 (ZExt, SExt, Trunc, FtoI, ItoF): 如果操作数是 Constant，则执行相应的类型转换，结果仍为 Constant。对于浮点数转换，由于 SSAPValue 的 constantVal 为 int 类型，所以对浮点数的操作会保守地返回 Bottom。
-
-未处理的指令: 默认情况下，任何未明确处理的指令都被保守地假定为产生 Bottom 值。
-
-浮点数处理的注意事项：
-
-在提供的代码中，SSAPValue 的 constantVal 是 int 类型。这使得浮点数常量传播变得复杂。对于浮点数相关的指令（kFAdd, kFMul, kFCmp, kFNeg, kFNot, kItoF, kFtoI 等），如果不能将浮点值准确地存储在 int 中，或者不能可靠地执行浮点运算，那么通常会保守地将结果设置为 Bottom。一个更完善的 SCCP 实现会使用 std::variant<int, float> 或独立的浮点常量存储来处理浮点数。
-
 
 # 后续优化可能涉及的改动
 
@@ -235,12 +25,4 @@ Branch 和 Return 指令: 这些是终结符指令，不产生一个可用于其
 
 好处：优化友好性，方便mem2reg提升
 目前没有实现这个机制，如果想要实现首先解决同一函数不同域的同名变量命名区分
-需要保证符号表能正确维护域中的局部变量
-
-
-# 关于中端优化提升编译器性能的TODO
-
-## usedelete_withinstdelte方法
-
-这个方法删除了use关系并移除了指令，逻辑是根据Instruction* inst去find对应的迭代器并erase
-有些情况下外部持有迭代器和inst,可以省略find过程
+需要保证符号表能正确维护域中的局部变量

doc/markdowns/IR.md

@@ -0,0 +1,169 @@
+这个头文件定义了一个用于生成中间表示（IR）的数据结构，主要用于编译器前端将抽象语法树（AST）转换为中间代码。以下是文件中定义的主要类和功能的整理和解释：
+
+---
+
+### **1. 类型系统（Type System）**
+#### **1.1 `Type` 类**
+- **作用**：表示所有基本标量类型（如 `int`、`float`、`void` 等）以及指针类型和函数类型。
+- **成员**：
+  - `Kind` 枚举：表示类型的种类（如 `kInt`、`kFloat`、`kPointer` 等）。
+  - `kind`：当前类型的种类。
+  - 构造函数：`Type(Kind kind)`，用于初始化类型。
+  - 静态方法：如 `getIntType()`、`getFloatType()` 等，用于获取特定类型的单例对象。
+  - 类型检查方法：如 `isInt()`、`isFloat()` 等，用于检查当前类型是否为某种类型。
+  - `getSize()`：获取类型的大小。
+  - `as<T>()`：将当前类型动态转换为派生类（如 `PointerType` 或 `FunctionType`）。
+
+#### **1.2 `PointerType` 类**
+- **作用**：表示指针类型，派生自 `Type`。
+- **成员**：
+  - `baseType`：指针指向的基础类型。
+  - 静态方法：`get(Type *baseType)`，用于获取指向 `baseType` 的指针类型。
+  - `getBaseType()`：获取指针指向的基础类型。
+
+#### **1.3 `FunctionType` 类**
+- **作用**：表示函数类型，派生自 `Type`。
+- **成员**：
+  - `returnType`：函数的返回类型。
+  - `paramTypes`：函数的参数类型列表。
+  - 静态方法：`get(Type *returnType, const std::vector<Type *> &paramTypes)`，用于获取函数类型。
+  - `getReturnType()`：获取函数的返回类型。
+  - `getParamTypes()`：获取函数的参数类型列表。
+
+---
+
+### **2. 中间表示（IR）**
+#### **2.1 `Value` 类**
+- **作用**：表示 IR 中的所有值（如指令、常量、参数等）。
+- **成员**：
+  - `Kind` 枚举：表示值的种类（如 `kAdd`、`kSub`、`kConstant` 等）。
+  - `kind`：当前值的种类。
+  - `type`：值的类型。
+  - `name`：值的名称。
+  - `uses`：值的用途列表（表示哪些指令使用了该值）。
+  - 构造函数：`Value(Kind kind, Type *type, const std::string &name)`。
+  - 类型检查方法：如 `isInt()`、`isFloat()` 等。
+  - `getUses()`：获取值的用途列表。
+  - `replaceAllUsesWith(Value *value)`：将该值的所有用途替换为另一个值。
+  - `print(std::ostream &os)`：打印值的表示。
+
+#### **2.2 `ConstantValue` 类**
+- **作用**：表示编译时常量（如整数常量、浮点数常量）。
+- **成员**：
+  - `iScalar` 和 `fScalar`：分别存储整数和浮点数常量的值。
+  - 静态方法：`get(int value)` 和 `get(float value)`，用于获取常量值。
+  - `getInt()` 和 `getFloat()`：获取常量的值。
+
+#### **2.3 `Argument` 类**
+- **作用**：表示函数或基本块的参数。
+- **成员**：
+  - `block`：参数所属的基本块。
+  - `index`：参数的索引。
+  - 构造函数：`Argument(Type *type, BasicBlock *block, int index, const std::string &name)`。
+  - `getParent()`：获取参数所属的基本块。
+  - `getIndex()`：获取参数的索引。
+
+#### **2.4 `BasicBlock` 类**
+- **作用**：表示基本块，包含一系列指令。
+- **成员**：
+  - `parent`：基本块所属的函数。
+  - `instructions`：基本块中的指令列表。
+  - `arguments`：基本块的参数列表。
+  - `successors` 和 `predecessors`：基本块的后继和前驱列表。
+  - 构造函数：`BasicBlock(Function *parent, const std::string &name)`。
+  - `getParent()`：获取基本块所属的函数。
+  - `getInstructions()`：获取基本块中的指令列表。
+  - `createArgument()`：为基本块创建一个参数。
+
+#### **2.5 `Instruction` 类**
+- **作用**：表示 IR 中的指令，派生自 `User`。
+- **成员**：
+  - `Kind` 枚举：表示指令的种类（如 `kAdd`、`kSub`、`kLoad` 等）。
+  - `kind`：当前指令的种类。
+  - `parent`：指令所属的基本块。
+  - 构造函数：`Instruction(Kind kind, Type *type, BasicBlock *parent, const std::string &name)`。
+  - `getParent()`：获取指令所属的基本块。
+  - `getFunction()`：获取指令所属的函数。
+  - 指令分类方法：如 `isBinary()`、`isUnary()`、`isMemory()` 等。
+
+#### **2.6 `User` 类**
+- **作用**：表示使用其他值的指令或全局值，派生自 `Value`。
+- **成员**：
+  - `operands`：指令的操作数列表。
+  - 构造函数：`User(Kind kind, Type *type, const std::string &name)`。
+  - `getOperand(int index)`：获取指定索引的操作数。
+  - `addOperand(Value *value)`：添加一个操作数。
+  - `replaceOperand(int index, Value *value)`：替换指定索引的操作数。
+
+#### **2.7 具体指令类**
+- **`CallInst`**：表示函数调用指令。
+- **`UnaryInst`**：表示一元操作指令（如取反、类型转换）。
+- **`BinaryInst`**：表示二元操作指令（如加法、减法）。
+- **`ReturnInst`**：表示返回指令。
+- **`UncondBrInst`**：表示无条件跳转指令。
+- **`CondBrInst`**：表示条件跳转指令。
+- **`AllocaInst`**：表示栈内存分配指令。
+- **`LoadInst`**：表示从内存加载值的指令。
+- **`StoreInst`**：表示将值存储到内存的指令。
+
+---
+
+### **3. 模块和函数**
+#### **3.1 `Function` 类**
+- **作用**：表示函数，包含多个基本块。
+- **成员**：
+  - `parent`：函数所属的模块。
+  - `blocks`：函数中的基本块列表。
+  - 构造函数：`Function(Module *parent, Type *type, const std::string &name)`。
+  - `getReturnType()`：获取函数的返回类型。
+  - `getParamTypes()`：获取函数的参数类型列表。
+  - `addBasicBlock()`：为函数添加一个基本块。
+
+#### **3.2 `GlobalValue` 类**
+- **作用**：表示全局变量或常量。
+- **成员**：
+  - `parent`：全局值所属的模块。
+  - `hasInit`：是否有初始化值。
+  - `isConst`：是否是常量。
+  - 构造函数：`GlobalValue(Module *parent, Type *type, const std::string &name, const std::vector<Value *> &dims, Value *init)`。
+  - `init()`：获取全局值的初始化值。
+
+#### **3.3 `Module` 类**
+- **作用**：表示整个编译单元（如一个源文件）。
+- **成员**：
+  - `children`：模块中的所有值（如函数、全局变量）。
+  - `functions`：模块中的函数列表。
+  - `globals`：模块中的全局变量列表。
+  - `createFunction()`：创建一个函数。
+  - `createGlobalValue()`：创建一个全局变量。
+  - `getFunction()`：获取指定名称的函数。
+  - `getGlobalValue()`：获取指定名称的全局变量。
+
+---
+
+### **4. 工具类**
+#### **4.1 `Use` 类**
+- **作用**：表示值与其使用者之间的关系。
+- **成员**：
+  - `index`：值在使用者操作数列表中的索引。
+  - `user`：使用者。
+  - `value`：被使用的值。
+  - 构造函数：`Use(int index, User *user, Value *value)`。
+  - `getValue()`：获取被使用的值。
+
+#### **4.2 `range` 类**
+- **作用**：封装迭代器对 `[begin, end)`，用于遍历容器。
+- **成员**：
+  - `begin()` 和 `end()`：返回范围的起始和结束迭代器。
+  - `size()`：返回范围的大小。
+  - `empty()`：判断范围是否为空。
+
+---
+
+### **5. 总结**
+- **类型系统**：`Type`、`PointerType`、`FunctionType` 用于表示 IR 中的类型。
+- **中间表示**：`Value`、`ConstantValue`、`Instruction` 等用于表示 IR 中的值和指令。
+- **模块和函数**：`Module`、`Function`、`GlobalValue` 用于组织 IR 的结构。
+- **工具类**：`Use` 和 `range` 用于辅助实现 IR 的数据结构和遍历。
+
+这个头文件定义了一个完整的 IR 数据结构，适用于编译器前端将 AST 转换为中间代码，并支持后续的优化和目标代码生成。

doc/markdowns/IRbuilder.md

@@ -0,0 +1,156 @@
+`IRBuilder.h` 文件定义了一个 `IRBuilder` 类，用于简化中间表示（IR）的构建过程。`IRBuilder` 提供了创建各种 IR 指令的便捷方法，并将这些指令插入到指定的基本块中。以下是对文件中主要内容的整理和解释：
+
+---
+
+### **1. `IRBuilder` 类的作用**
+`IRBuilder` 是一个工具类，用于在生成中间表示（IR）时简化指令的创建和插入操作。它的主要功能包括：
+- 提供创建各种 IR 指令的工厂方法。
+- 将创建的指令插入到指定的基本块中。
+- 支持在基本块的任意位置插入指令。
+
+---
+
+### **2. 主要成员**
+
+#### **2.1 成员变量**
+- **`block`**：当前操作的基本块。
+- **`position`**：当前操作的插入位置（基本块中的迭代器）。
+
+#### **2.2 构造函数**
+- **默认构造函数**：`IRBuilder()`。
+- **带参数的构造函数**：
+  - `IRBuilder(BasicBlock *block)`：初始化 `IRBuilder`，并设置当前基本块和插入位置（默认在基本块末尾）。
+  - `IRBuilder(BasicBlock *block, BasicBlock::iterator position)`：初始化 `IRBuilder`，并设置当前基本块和插入位置。
+
+#### **2.3 设置方法**
+- **`setPosition(BasicBlock *block, BasicBlock::iterator position)`**：设置当前基本块和插入位置。
+- **`setPosition(BasicBlock::iterator position)`**：设置当前插入位置。
+
+#### **2.4 获取方法**
+- **`getBasicBlock()`**：获取当前基本块。
+- **`getPosition()`**：获取当前插入位置。
+
+---
+
+### **3. 指令创建方法**
+`IRBuilder` 提供了多种工厂方法，用于创建不同类型的 IR 指令。这些方法会将创建的指令插入到当前基本块的指定位置。
+
+#### **3.1 函数调用指令**
+- **`createCallInst(Function *callee, const std::vector<Value *> &args, const std::string &name)`**：
+  - 创建一个函数调用指令。
+  - 参数：
+    - `callee`：被调用的函数。
+    - `args`：函数参数列表。
+    - `name`：指令的名称（可选）。
+  - 返回：`CallInst*`。
+
+#### **3.2 一元操作指令**
+- **`createUnaryInst(Instruction::Kind kind, Type *type, Value *operand, const std::string &name)`**：
+  - 创建一个一元操作指令（如取反、类型转换）。
+  - 参数：
+    - `kind`：指令的类型（如 `kNeg`、`kFtoI` 等）。
+    - `type`：指令的结果类型。
+    - `operand`：操作数。
+    - `name`：指令的名称（可选）。
+  - 返回：`UnaryInst*`。
+
+- **具体一元操作指令**：
+  - `createNegInst(Value *operand, const std::string &name)`：创建整数取反指令。
+  - `createNotInst(Value *operand, const std::string &name)`：创建逻辑取反指令。
+  - `createFtoIInst(Value *operand, const std::string &name)`：创建浮点数转整数指令。
+  - `createFNegInst(Value *operand, const std::string &name)`：创建浮点数取反指令。
+  - `createIToFInst(Value *operand, const std::string &name)`：创建整数转浮点数指令。
+
+#### **3.3 二元操作指令**
+- **`createBinaryInst(Instruction::Kind kind, Type *type, Value *lhs, Value *rhs, const std::string &name)`**：
+  - 创建一个二元操作指令（如加法、减法）。
+  - 参数：
+    - `kind`：指令的类型（如 `kAdd`、`kSub` 等）。
+    - `type`：指令的结果类型。
+    - `lhs` 和 `rhs`：左操作数和右操作数。
+    - `name`：指令的名称（可选）。
+  - 返回：`BinaryInst*`。
+
+- **具体二元操作指令**：
+  - 整数运算：
+    - `createAddInst(Value *lhs, Value *rhs, const std::string &name)`：创建整数加法指令。
+    - `createSubInst(Value *lhs, Value *rhs, const std::string &name)`：创建整数减法指令。
+    - `createMulInst(Value *lhs, Value *rhs, const std::string &name)`：创建整数乘法指令。
+    - `createDivInst(Value *lhs, Value *rhs, const std::string &name)`：创建整数除法指令。
+    - `createRemInst(Value *lhs, Value *rhs, const std::string &name)`：创建整数取余指令。
+  - 整数比较：
+    - `createICmpEQInst(Value *lhs, Value *rhs, const std::string &name)`：创建整数相等比较指令。
+    - `createICmpNEInst(Value *lhs, Value *rhs, const std::string &name)`：创建整数不等比较指令。
+    - `createICmpLTInst(Value *lhs, Value *rhs, const std::string &name)`：创建整数小于比较指令。
+    - `createICmpLEInst(Value *lhs, Value *rhs, const std::string &name)`：创建整数小于等于比较指令。
+    - `createICmpGTInst(Value *lhs, Value *rhs, const std::string &name)`：创建整数大于比较指令。
+    - `createICmpGEInst(Value *lhs, Value *rhs, const std::string &name)`：创建整数大于等于比较指令。
+  - 浮点数运算：
+    - `createFAddInst(Value *lhs, Value *rhs, const std::string &name)`：创建浮点数加法指令。
+    - `createFSubInst(Value *lhs, Value *rhs, const std::string &name)`：创建浮点数减法指令。
+    - `createFMulInst(Value *lhs, Value *rhs, const std::string &name)`：创建浮点数乘法指令。
+    - `createFDivInst(Value *lhs, Value *rhs, const std::string &name)`：创建浮点数除法指令。
+    - `createFRemInst(Value *lhs, Value *rhs, const std::string &name)`：创建浮点数取余指令。
+  - 浮点数比较：
+    - `createFCmpEQInst(Value *lhs, Value *rhs, const std::string &name)`：创建浮点数相等比较指令。
+    - `createFCmpNEInst(Value *lhs, Value *rhs, const std::string &name)`：创建浮点数不等比较指令。
+    - `createFCmpLTInst(Value *lhs, Value *rhs, const std::string &name)`：创建浮点数小于比较指令。
+    - `createFCmpLEInst(Value *lhs, Value *rhs, const std::string &name)`：创建浮点数小于等于比较指令。
+    - `createFCmpGTInst(Value *lhs, Value *rhs, const std::string &name)`：创建浮点数大于比较指令。
+    - `createFCmpGEInst(Value *lhs, Value *rhs, const std::string &name)`：创建浮点数大于等于比较指令。
+
+#### **3.4 控制流指令**
+- **`createReturnInst(Value *value)`**：
+  - 创建返回指令。
+  - 参数：
+    - `value`：返回值（可选）。
+  - 返回：`ReturnInst*`。
+
+- **`createUncondBrInst(BasicBlock *block, std::vector<Value *> args)`**：
+  - 创建无条件跳转指令。
+  - 参数：
+    - `block`：目标基本块。
+    - `args`：跳转参数（可选）。
+  - 返回：`UncondBrInst*`。
+
+- **`createCondBrInst(Value *condition, BasicBlock *thenBlock, BasicBlock *elseBlock, const std::vector<Value *> &thenArgs, const std::vector<Value *> &elseArgs)`**：
+  - 创建条件跳转指令。
+  - 参数：
+    - `condition`：跳转条件。
+    - `thenBlock`：条件为真时的目标基本块。
+    - `elseBlock`：条件为假时的目标基本块。
+    - `thenArgs` 和 `elseArgs`：跳转参数（可选）。
+  - 返回：`CondBrInst*`。
+
+#### **3.5 内存操作指令**
+- **`createAllocaInst(Type *type, const std::vector<Value *> &dims, const std::string &name)`**：
+  - 创建栈内存分配指令。
+  - 参数：
+    - `type`：分配的类型。
+    - `dims`：数组维度（可选）。
+    - `name`：指令的名称（可选）。
+  - 返回：`AllocaInst*`。
+
+- **`createLoadInst(Value *pointer, const std::vector<Value *> &indices, const std::string &name)`**：
+  - 创建加载指令。
+  - 参数：
+    - `pointer`：指针值。
+    - `indices`：数组索引（可选）。
+    - `name`：指令的名称（可选）。
+  - 返回：`LoadInst*`。
+
+- **`createStoreInst(Value *value, Value *pointer, const std::vector<Value *> &indices, const std::string &name)`**：
+  - 创建存储指令。
+  - 参数：
+    - `value`：要存储的值。
+    - `pointer`：指针值。
+    - `indices`：数组索引（可选）。
+    - `name`：指令的名称（可选）。
+  - 返回：`StoreInst*`。
+
+---
+
+### **4. 总结**
+- `IRBuilder` 是一个用于简化 IR 构建的工具类，提供了创建各种 IR 指令的工厂方法。
+- 通过 `IRBuilder`，可以方便地在指定基本块的任意位置插入指令。
+- 该类的设计使得 IR 的生成更加模块化和易于维护。

doc/markdowns/IRcpp.md

@@ -0,0 +1,121 @@
+这个 `IR.cpp` 文件实现了 `IR.h` 中定义的中间表示（IR）数据结构的功能。它包含了类型系统、值、指令、基本块、函数和模块的具体实现，以及一些辅助函数用于打印 IR 的内容。以下是对文件中主要内容的整理和解释：
+
+---
+
+### **1. 辅助函数**
+#### **1.1 `interleave` 函数**
+- **作用**：用于在输出流中插入分隔符（如逗号）来打印容器中的元素。
+- **示例**：
+  ```cpp
+  interleave(os, container, ", ");
+  ```
+
+#### **1.2 打印函数**
+- **`printVarName`**：打印变量名，全局变量以 `@` 开头，局部变量以 `%` 开头。
+- **`printBlockName`**：打印基本块名，以 `^` 开头。
+- **`printFunctionName`**：打印函数名，以 `@` 开头。
+- **`printOperand`**：打印操作数，如果是常量则直接打印值，否则打印变量名。
+
+---
+
+### **2. 类型系统**
+#### **2.1 `Type` 类的实现**
+- **静态方法**：
+  - `getIntType()`、`getFloatType()`、`getVoidType()`、`getLabelType()`：返回对应类型的单例对象。
+  - `getPointerType(Type *baseType)`：返回指向 `baseType` 的指针类型。
+  - `getFunctionType(Type *returnType, const vector<Type *> &paramTypes)`：返回函数类型。
+- **`getSize()`**：返回类型的大小（如 `int` 和 `float` 为 4 字节，指针为 8 字节）。
+- **`print()`**：打印类型的表示。
+
+#### **2.2 `PointerType` 类的实现**
+- **静态方法**：
+  - `get(Type *baseType)`：返回指向 `baseType` 的指针类型，使用 `std::map` 缓存已创建的指针类型。
+- **`getBaseType()`**：返回指针指向的基础类型。
+
+#### **2.3 `FunctionType` 类的实现**
+- **静态方法**：
+  - `get(Type *returnType, const vector<Type *> &paramTypes)`：返回函数类型，使用 `std::set` 缓存已创建的函数类型。
+- **`getReturnType()`** 和 `getParamTypes()`：分别返回函数的返回类型和参数类型列表。
+
+---
+
+### **3. 值（Value）**
+#### **3.1 `Value` 类的实现**
+- **`replaceAllUsesWith(Value *value)`**：将该值的所有用途替换为另一个值。
+- **`isConstant()`**：判断值是否为常量（包括常量值、全局值和函数）。
+
+#### **3.2 `ConstantValue` 类的实现**
+- **静态方法**：
+  - `get(int value)` 和 `get(float value)`：返回整数或浮点数常量，使用 `std::map` 缓存已创建的常量。
+- **`getInt()` 和 `getFloat()`**：返回常量的值。
+- **`print()`**：打印常量的值。
+
+#### **3.3 `Argument` 类的实现**
+- **构造函数**：初始化参数的类型、所属基本块和索引。
+- **`print()`**：打印参数的表示。
+
+---
+
+### **4. 基本块（BasicBlock）**
+#### **4.1 `BasicBlock` 类的实现**
+- **构造函数**：初始化基本块的名称和所属函数。
+- **`print()`**：打印基本块的表示，包括参数和指令。
+
+---
+
+### **5. 指令（Instruction）**
+#### **5.1 `Instruction` 类的实现**
+- **构造函数**：初始化指令的类型、所属基本块和名称。
+- **`print()`**：由具体指令类实现。
+
+#### **5.2 具体指令类的实现**
+- **`CallInst`**：表示函数调用指令。
+  - **`print()`**：打印函数调用的表示。
+- **`UnaryInst`**：表示一元操作指令（如取反、类型转换）。
+  - **`print()`**：打印一元操作的表示。
+- **`BinaryInst`**：表示二元操作指令（如加法、减法）。
+  - **`print()`**：打印二元操作的表示。
+- **`ReturnInst`**：表示返回指令。
+  - **`print()`**：打印返回指令的表示。
+- **`UncondBrInst`**：表示无条件跳转指令。
+  - **`print()`**：打印无条件跳转的表示。
+- **`CondBrInst`**：表示条件跳转指令。
+  - **`print()`**：打印条件跳转的表示。
+- **`AllocaInst`**：表示栈内存分配指令。
+  - **`print()`**：打印内存分配的表示。
+- **`LoadInst`**：表示从内存加载值的指令。
+  - **`print()`**：打印加载指令的表示。
+- **`StoreInst`**：表示将值存储到内存的指令。
+  - **`print()`**：打印存储指令的表示。
+
+---
+
+### **6. 函数（Function）**
+#### **6.1 `Function` 类的实现**
+- **构造函数**：初始化函数的名称、返回类型和参数类型。
+- **`print()`**：打印函数的表示，包括基本块和指令。
+
+---
+
+### **7. 模块（Module）**
+#### **7.1 `Module` 类的实现**
+- **`print()`**：打印模块的表示，包括所有函数和全局变量。
+
+---
+
+### **8. 用户（User）**
+#### **8.1 `User` 类的实现**
+- **`setOperand(int index, Value *value)`**：设置指定索引的操作数。
+- **`replaceOperand(int index, Value *value)`**：替换指定索引的操作数，并更新用途列表。
+
+---
+
+### **9. 总结**
+- **类型系统**：实现了 `Type`、`PointerType` 和 `FunctionType`，用于表示 IR 中的类型。
+- **值**：实现了 `Value`、`ConstantValue` 和 `Argument`，用于表示 IR 中的值和参数。
+- **基本块**：实现了 `BasicBlock`，用于组织指令。
+- **指令**：实现了多种具体指令类（如 `CallInst`、`BinaryInst` 等），用于表示 IR 中的操作。
+- **函数和模块**：实现了 `Function` 和 `Module`，用于组织 IR 的结构。
+- **打印功能**：通过 `print()` 方法，可以将 IR 的内容输出为可读的文本格式。
+
+这个文件是编译器中间表示的核心实现，能够将抽象语法树（AST）转换为中间代码，并支持后续的优化和目标代码生成。

script/runit-riscv64.sh

@@ -60,7 +60,11 @@ display_file_content() {
 # 清理临时文件的函数
 clean_tmp() {
     echo "正在清理临时目录: ${TMP_DIR}"
-    rm -rf "${TMP_DIR}"/*
+    rm -rf "${TMP_DIR}"/*.s \
+           "${TMP_DIR}"/*_sysyc_riscv64 \
+           "${TMP_DIR}"/*_sysyc_riscv64.actual_out \
+           "${TMP_DIR}"/*_sysyc_riscv64.expected_stdout \
+           "${TMP_DIR}"/*_sysyc_riscv64.o
     echo "清理完成。"
 }
 

script/runit-single.sh

@@ -21,7 +21,6 @@ QEMU_RISCV64="qemu-riscv64"
 # --- 初始化变量 ---
 EXECUTE_MODE=false
 CLEAN_MODE=false
-OPTIMIZE_FLAG=""      # 用于存储 -O1 标志
 SYSYC_TIMEOUT=10      # sysyc 编译超时 (秒)
 GCC_TIMEOUT=10        # gcc 编译超时 (秒)
 EXEC_TIMEOUT=5        # qemu 自动化执行超时 (秒)
@@ -40,7 +39,6 @@ show_help() {
     echo "选项:"
     echo "  -e, --executable         编译为可执行文件并运行测试 (必须)。"
     echo "  -c, --clean              清理 tmp 临时目录下的所有文件。"
-    echo "  -O1                      启用 sysyc 的 -O1 优化。"
     echo "  -sct N                   设置 sysyc 编译超时为 N 秒 (默认: 10)。"
     echo "  -gct N                   设置 gcc 交叉编译超时为 N 秒 (默认: 10)。"
     echo "  -et N                    设置 qemu 自动化执行超时为 N 秒 (默认: 5)。"
@@ -70,7 +68,7 @@ display_file_content() {
     fi
 }
 
-# --- 参数解析 ---
+# --- 本次修改点: 整个参数解析逻辑被重写 ---
 # 使用标准的 while 循环来健壮地处理任意顺序的参数
 while [[ "$#" -gt 0 ]]; do
     case "$1" in
@@ -82,10 +80,6 @@ while [[ "$#" -gt 0 ]]; do
             CLEAN_MODE=true
             shift # 消耗选项
             ;;
-        -O1)
-            OPTIMIZE_FLAG="-O1"
-            shift # 消耗选项
-            ;;
         -sct)
             if [[ -n "$2" && "$2" =~ ^[0-9]+$ ]]; then SYSYC_TIMEOUT="$2"; shift 2; else echo "错误: -sct 需要一个正整数参数。" >&2; exit 1; fi
             ;;
@@ -150,7 +144,6 @@ mkdir -p "${TMP_DIR}"
 TOTAL_CASES=${#SY_FILES[@]}
 
 echo "SysY 单例测试运行器启动..."
-if [ -n "$OPTIMIZE_FLAG" ]; then echo "优化等级: ${OPTIMIZE_FLAG}"; fi
 echo "超时设置: sysyc=${SYSYC_TIMEOUT}s, gcc=${GCC_TIMEOUT}s, qemu=${EXEC_TIMEOUT}s"
 echo "失败输出最大行数: ${MAX_OUTPUT_LINES}"
 echo ""
@@ -171,21 +164,9 @@ for sy_file in "${SY_FILES[@]}"; do
     echo "======================================================================"
     echo "正在处理: ${sy_file}"
 
-    # --- 本次修改点: 拷贝源文件到 tmp 目录 ---
-    echo "  拷贝源文件到 ${TMP_DIR}..."
-    cp "${sy_file}" "${TMP_DIR}/$(basename "${sy_file}")"
-    if [ -f "${input_file}" ]; then
-        cp "${input_file}" "${TMP_DIR}/$(basename "${input_file}")"
-    fi
-    if [ -f "${output_reference_file}" ]; then
-        cp "${output_reference_file}" "${TMP_DIR}/$(basename "${output_reference_file}")"
-    fi
-    
     # 步骤 1: sysyc 编译
     echo "  使用 sysyc 编译 (超时 ${SYSYC_TIMEOUT}s)..."
-    timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -S "${sy_file}" ${OPTIMIZE_FLAG} -o "${assembly_file}"
-    timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -s ir "${sy_file}" ${OPTIMIZE_FLAG} > "${ir_file}"
-    # timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -s asmd "${sy_file}" > "${assembly_debug_file}" 2>&1
+    timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -s ir "${sy_file}" > "${ir_file}"
     SYSYC_STATUS=$?
     if [ $SYSYC_STATUS -eq 124 ]; then
         echo -e "\e[31m错误: SysY 编译 ${sy_file} IR超时\e[0m"
@@ -194,10 +175,12 @@ for sy_file in "${SY_FILES[@]}"; do
         echo -e "\e[31m错误: SysY 编译 ${sy_file} IR失败，退出码: ${SYSYC_STATUS}\e[0m"
         is_passed=0
     fi
+    timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -S "${sy_file}" -o "${assembly_file}"
     if [ $? -ne 0 ]; then
         echo -e "\e[31m错误: SysY 编译失败或超时。\e[0m"
         is_passed=0
     fi
+    # timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -s asmd "${sy_file}" > "${assembly_debug_file}" 2>&1
 
     # 步骤 2: GCC 编译
     if [ "$is_passed" -eq 1 ]; then

script/runit.sh

@@ -16,8 +16,8 @@ SYSYC="${BUILD_BIN_DIR}/sysyc"
 GCC_RISCV64="riscv64-linux-gnu-gcc"
 QEMU_RISCV64="qemu-riscv64"
 
+# --- 新增功能: 初始化变量 ---
 EXECUTE_MODE=false
-OPTIMIZE_FLAG=""      # 用于存储 -O1 标志
 SYSYC_TIMEOUT=10      # sysyc 编译超时 (秒)
 GCC_TIMEOUT=10        # gcc 编译超时 (秒)
 EXEC_TIMEOUT=5        # qemu 执行超时 (秒)
@@ -35,7 +35,6 @@ show_help() {
     echo "选项:"
     echo "  -e, --executable         编译为可执行文件并运行测试。"
     echo "  -c, --clean              清理 'tmp' 目录下的所有生成文件。"
-    echo "  -O1                      启用 sysyc 的 -O1 优化。"
     echo "  -set [f|h|p|all]...    指定要运行的测试集 (functional, h_functional, performance)。可多选，默认为 all。"
     echo "  -sct N                   设置 sysyc 编译超时为 N 秒 (默认: 10)。"
     echo "  -gct N                   设置 gcc 交叉编译超时为 N 秒 (默认: 10)。"
@@ -86,12 +85,9 @@ while [[ "$#" -gt 0 ]]; do
             clean_tmp
             exit 0
             ;;
-        -O1)
-            OPTIMIZE_FLAG="-O1"
-            shift
-            ;;
         -set)
             shift # 移过 '-set'
+            # 消耗所有后续参数直到遇到下一个选项
             while [[ "$#" -gt 0 && ! "$1" =~ ^- ]]; do
                 TEST_SETS+=("$1")
                 shift
@@ -129,6 +125,7 @@ SET_MAP[p]="performance"
 
 SEARCH_PATHS=()
 
+# 如果未指定测试集，或指定了 'all'，则搜索所有目录
 if [ ${#TEST_SETS[@]} -eq 0 ] || [[ " ${TEST_SETS[@]} " =~ " all " ]]; then
     SEARCH_PATHS+=("${TESTDATA_DIR}")
 else
@@ -141,13 +138,13 @@ else
     done
 fi
 
+# 如果没有有效的搜索路径，则退出
 if [ ${#SEARCH_PATHS[@]} -eq 0 ]; then
     echo -e "\e[31m错误: 没有找到有效的测试集目录，测试中止。\e[0m"
     exit 1
 fi
 
 echo "SysY 测试运行器启动..."
-if [ -n "$OPTIMIZE_FLAG" ]; then echo "优化等级: ${OPTIMIZE_FLAG}"; fi
 echo "输入目录: ${SEARCH_PATHS[@]}"
 echo "临时目录: ${TMP_DIR}"
 echo "执行模式: ${EXECUTE_MODE}"
@@ -157,6 +154,7 @@ if ${EXECUTE_MODE}; then
 fi
 echo ""
 
+# 使用构建好的路径查找 .sy 文件并排序
 sy_files=$(find "${SEARCH_PATHS[@]}" -name "*.sy" | sort -V)
 if [ -z "$sy_files" ]; then
     echo "在指定目录中未找到任何 .sy 文件。"
@@ -164,6 +162,7 @@ if [ -z "$sy_files" ]; then
 fi
 TOTAL_CASES=$(echo "$sy_files" | wc -w)
 
+# --- 修复: 使用 here-string (<<<) 代替管道 (|) 来避免子 shell 问题 ---
 while IFS= read -r sy_file; do
     is_passed=1 # 1 表示通过, 0 表示失败
 
@@ -177,8 +176,10 @@ while IFS= read -r sy_file; do
     output_actual_file="${TMP_DIR}/${output_base_name}_sysyc_riscv64.actual_out"
 
     echo "正在处理: $(basename "$sy_file") (路径: ${relative_path_no_ext}.sy)"
+
+    # 步骤 1: 使用 sysyc 编译 .sy 到 .s
     echo "  使用 sysyc 编译 (超时 ${SYSYC_TIMEOUT}s)..."
-    timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -S "${sy_file}" -o "${assembly_file}" ${OPTIMIZE_FLAG}
+    timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -S "${sy_file}" -o "${assembly_file}"
     SYSYC_STATUS=$?
     if [ $SYSYC_STATUS -eq 124 ]; then
         echo -e "\e[31m错误: SysY 编译 ${sy_file} 超时\e[0m"
@@ -188,7 +189,9 @@ while IFS= read -r sy_file; do
         is_passed=0
     fi
 
+    # 只有当 EXECUTE_MODE 为 true 且上一步成功时才继续
     if ${EXECUTE_MODE} && [ "$is_passed" -eq 1 ]; then
+        # 步骤 2: 使用 riscv64-linux-gnu-gcc 编译 .s 到可执行文件
         echo "  使用 gcc 编译 (超时 ${GCC_TIMEOUT}s)..."
         timeout -s KILL ${GCC_TIMEOUT} "${GCC_RISCV64}" "${assembly_file}" -o "${executable_file}" -L"${LIB_DIR}" -lsysy_riscv -static
         GCC_STATUS=$?
@@ -210,6 +213,7 @@ while IFS= read -r sy_file; do
         continue
     fi
 
+    # 步骤 3, 4, 5: 只有当编译都成功时才执行
     if [ "$is_passed" -eq 1 ]; then
         echo "  正在执行 (超时 ${EXEC_TIMEOUT}s)..."
         

src/backend/RISCv64/CMakeLists.txt

@@ -5,15 +5,12 @@ add_library(riscv64_backend_lib STATIC
     RISCv64ISel.cpp
     RISCv64LLIR.cpp
     RISCv64RegAlloc.cpp
-    RISCv64LinearScan.cpp
     Handler/CalleeSavedHandler.cpp
     Handler/LegalizeImmediates.cpp
     Handler/PrologueEpilogueInsertion.cpp
-    Handler/EliminateFrameIndices.cpp
     Optimize/Peephole.cpp
     Optimize/PostRA_Scheduler.cpp
     Optimize/PreRA_Scheduler.cpp
-    Optimize/DivStrengthReduction.cpp
 )
 
 # 包含后端模块所需的头文件路径

src/backend/RISCv64/Handler/CalleeSavedHandler.cpp

@@ -8,6 +8,11 @@ namespace sysy {
 
 char CalleeSavedHandler::ID = 0;
 
+// 辅助函数，用于判断一个物理寄存器是否为浮点寄存器
+static bool is_fp_reg(PhysicalReg reg) {
+    return reg >= PhysicalReg::F0 && reg <= PhysicalReg::F31;
+}
+
 bool CalleeSavedHandler::runOnFunction(Function *F, AnalysisManager& AM) {
     // This pass works on MachineFunction level, not IR level
     return false;
@@ -15,37 +20,114 @@ bool CalleeSavedHandler::runOnFunction(Function *F, AnalysisManager& AM) {
 
 void CalleeSavedHandler::runOnMachineFunction(MachineFunction* mfunc) {
     StackFrameInfo& frame_info = mfunc->getFrameInfo();
-    const std::set<PhysicalReg>& used_callee_saved = frame_info.used_callee_saved_regs;
+    
+    std::set<PhysicalReg> used_callee_saved;
+
+    // 1. 扫描所有指令，找出被使用的callee-saved寄存器
+    //    这个Pass在RegAlloc之后运行，所以可以访问到物理寄存器
+    for (auto& mbb : mfunc->getBlocks()) {
+        for (auto& instr : mbb->getInstructions()) {
+            for (auto& op : instr->getOperands()) {
+                
+                auto check_and_insert_reg = [&](RegOperand* reg_op) {
+                    if (reg_op && !reg_op->isVirtual()) {
+                        PhysicalReg preg = reg_op->getPReg();
+                        
+                        // 检查整数 s1-s11
+                        if (preg >= PhysicalReg::S1 && preg <= PhysicalReg::S11) {
+                            used_callee_saved.insert(preg);
+                        } 
+                        // 检查浮点 fs0-fs11 (f8,f9,f18-f27)
+                        else if ((preg >= PhysicalReg::F8 && preg <= PhysicalReg::F9) || (preg >= PhysicalReg::F18 && preg <= PhysicalReg::F27)) {
+                            used_callee_saved.insert(preg);
+                        }
+                    }
+                };
+
+                if (op->getKind() == MachineOperand::KIND_REG) {
+                    check_and_insert_reg(static_cast<RegOperand*>(op.get()));
+                } else if (op->getKind() == MachineOperand::KIND_MEM) {
+                    check_and_insert_reg(static_cast<MemOperand*>(op.get())->getBase());
+                }
+            }
+        }
+    }
 
     if (used_callee_saved.empty()) {
         frame_info.callee_saved_size = 0;
-        frame_info.callee_saved_regs_to_store.clear();
         return;
     }
 
-    // 1. 计算被调用者保存寄存器所需的总空间大小
-    // s0 总是由 PEI Pass 单独处理，这里不计入大小，但要确保它在列表中
-    int size = 0;
-    std::set<PhysicalReg> regs_to_save = used_callee_saved;
-    if (regs_to_save.count(PhysicalReg::S0)) {
-        regs_to_save.erase(PhysicalReg::S0);
+    // 2. 计算并更新 frame_info
+    frame_info.callee_saved_size = used_callee_saved.size() * 8;
+
+    // 为了布局确定性和恢复顺序一致，对寄存器排序
+    std::vector<PhysicalReg> sorted_regs(used_callee_saved.begin(), used_callee_saved.end());
+    std::sort(sorted_regs.begin(), sorted_regs.end());
+    
+    // 3. 在函数序言中插入保存指令
+    MachineBasicBlock* entry_block = mfunc->getBlocks().front().get();
+    auto& entry_instrs = entry_block->getInstructions();
+    // 插入点在函数入口标签之后，或者就是最开始
+    auto insert_pos = entry_instrs.begin();
+    if (!entry_instrs.empty() && entry_instrs.front()->getOpcode() == RVOpcodes::LABEL) {
+        insert_pos = std::next(insert_pos);
     }
-    size = regs_to_save.size() * 8; // 每个寄存器占8字节 (64-bit)
-    frame_info.callee_saved_size = size;
+    
+    std::vector<std::unique_ptr<MachineInstr>> save_instrs;
+    // [关键] 从局部变量区域之后开始分配空间
+    int current_offset = - (16 + frame_info.locals_size);
 
-    // 2. 创建一个有序的、需要保存的寄存器列表，以便后续 Pass 确定地生成代码
-    // s0 不应包含在此列表中，因为它由 PEI Pass 特殊处理
-    std::vector<PhysicalReg> sorted_regs(regs_to_save.begin(), regs_to_save.end());
-    std::sort(sorted_regs.begin(), sorted_regs.end(), [](PhysicalReg a, PhysicalReg b){ 
-        return static_cast<int>(a) < static_cast<int>(b); 
-    });
-    frame_info.callee_saved_regs_to_store = sorted_regs;
+    for (PhysicalReg reg : sorted_regs) {
+        current_offset -= 8;
+        RVOpcodes save_op = is_fp_reg(reg) ? RVOpcodes::FSD : RVOpcodes::SD;
 
-    // 3. 更新栈帧总大小。
-    // 这是初步计算，PEI Pass 会进行最终的对齐。
-    frame_info.total_size = frame_info.locals_size + 
-                            frame_info.spill_size + 
-                            frame_info.callee_saved_size;
+        auto save_instr = std::make_unique<MachineInstr>(save_op);
+        save_instr->addOperand(std::make_unique<RegOperand>(reg));
+        save_instr->addOperand(std::make_unique<MemOperand>(
+            std::make_unique<RegOperand>(PhysicalReg::S0), // 基址为帧指针 s0
+            std::make_unique<ImmOperand>(current_offset)
+        ));
+        save_instrs.push_back(std::move(save_instr));
+    }
+
+    if (!save_instrs.empty()) {
+        entry_instrs.insert(insert_pos,
+                            std::make_move_iterator(save_instrs.begin()),
+                            std::make_move_iterator(save_instrs.end()));
+    }
+
+    // 4. 在函数结尾（ret之前）插入恢复指令
+    for (auto& mbb : mfunc->getBlocks()) {
+        for (auto it = mbb->getInstructions().begin(); it != mbb->getInstructions().end(); ++it) {
+            if ((*it)->getOpcode() == RVOpcodes::RET) {
+                std::vector<std::unique_ptr<MachineInstr>> restore_instrs;
+                // [关键] 使用与保存时完全相同的逻辑来计算偏移量
+                current_offset = - (16 + frame_info.locals_size);
+                
+                for (PhysicalReg reg : sorted_regs) {
+                    current_offset -= 8;
+                    RVOpcodes restore_op = is_fp_reg(reg) ? RVOpcodes::FLD : RVOpcodes::LD;
+
+                    auto restore_instr = std::make_unique<MachineInstr>(restore_op);
+                    restore_instr->addOperand(std::make_unique<RegOperand>(reg));
+                    restore_instr->addOperand(std::make_unique<MemOperand>(
+                        std::make_unique<RegOperand>(PhysicalReg::S0),
+                        std::make_unique<ImmOperand>(current_offset)
+                    ));
+                    restore_instrs.push_back(std::move(restore_instr));
+                }
+                
+                if (!restore_instrs.empty()) {
+                    mbb->getInstructions().insert(it,
+                                                std::make_move_iterator(restore_instrs.begin()),
+                                                std::make_move_iterator(restore_instrs.end()));
+                }
+                goto next_block_label;
+            }
+        }
+        next_block_label:;
+    }
 }
 
-} // namespace sysy
+} // namespace sysy

src/backend/RISCv64/Handler/EliminateFrameIndices.cpp

@@ -1,235 +0,0 @@
-#include "EliminateFrameIndices.h"
-#include "RISCv64ISel.h"
-#include <cassert>
-#include <vector>
-
-namespace sysy {
-
-// getTypeSizeInBytes 是一个通用辅助函数，保持不变
-unsigned EliminateFrameIndicesPass::getTypeSizeInBytes(Type* type) {
-    if (!type) {
-        assert(false && "Cannot get size of a null type.");
-        return 0;
-    }
-
-    switch (type->getKind()) {
-        case Type::kInt:
-        case Type::kFloat:
-            return 4;
-        case Type::kPointer:
-            return 8;
-        case Type::kArray: {
-            auto arrayType = type->as<ArrayType>();
-            return arrayType->getNumElements() * getTypeSizeInBytes(arrayType->getElementType());
-        }
-        default:
-            assert(false && "Unsupported type for size calculation.");
-            return 0;
-    }
-}
-
-void EliminateFrameIndicesPass::runOnMachineFunction(MachineFunction* mfunc) {
-    StackFrameInfo& frame_info = mfunc->getFrameInfo();
-    Function* F = mfunc->getFunc();
-    RISCv64ISel* isel = mfunc->getISel();
-    
-    // 在这里处理栈传递的参数，以便在寄存器分配前就将数据流显式化，修复溢出逻辑的BUG。
-
-    // 2. 只为局部变量(AllocaInst)分配栈空间和计算偏移量
-    // 局部变量从 s0 下方（负偏移量）开始分配，紧接着为 ra 和 s0 预留的16字节之后
-    int local_var_offset = 16;
-    
-    if(F) { // 确保函数指针有效
-        for (auto& bb : F->getBasicBlocks()) {
-            for (auto& inst : bb->getInstructions()) {
-                if (auto alloca = dynamic_cast<AllocaInst*>(inst.get())) {
-                    Type* allocated_type = alloca->getType()->as<PointerType>()->getBaseType();
-                    int size = getTypeSizeInBytes(allocated_type);
-                    
-                    // 优化栈帧大小：对于大数组使用4字节对齐，小对象使用8字节对齐
-                    if (size >= 256) {  // 大数组优化
-                        size = (size + 3) & ~3;  // 4字节对齐
-                    } else {
-                        size = (size + 7) & ~7;  // 8字节对齐
-                    }
-                    if (size == 0) size = 4; // 最小4字节
-
-                    local_var_offset += size;
-                    unsigned alloca_vreg = isel->getVReg(alloca);
-                    // 局部变量使用相对于s0的负向偏移
-                    frame_info.alloca_offsets[alloca_vreg] = -local_var_offset;
-                }
-            }
-        }
-    }
-    
-    // 记录仅由AllocaInst分配的局部变量的总大小
-    frame_info.locals_size = local_var_offset - 16;
-    // 记录局部变量区域分配结束的最终偏移量
-    frame_info.locals_end_offset = -local_var_offset;
-
-    // 在函数入口为所有栈传递的参数插入load指令
-    // 这个步骤至关重要：它在寄存器分配之前，为这些参数的vreg创建了明确的“定义(def)”指令。
-    // 这解决了在高寄存器压力下，当这些vreg被溢出时，`rewriteProgram`找不到其定义点而崩溃的问题。
-    if (F && isel && !mfunc->getBlocks().empty()) {
-        MachineBasicBlock* entry_block = mfunc->getBlocks().front().get();
-        std::vector<std::unique_ptr<MachineInstr>> arg_load_instrs;
-        
-        // 步骤 3.1: 生成所有加载栈参数的指令，暂存起来
-        int arg_idx = 0;
-        for (Argument* arg : F->getArguments()) {
-            // 根据ABI，前8个整型/指针参数通过寄存器传递，这里只处理超出部分。
-            if (arg_idx >= 8) {
-                // 计算参数在调用者栈帧中的位置，该位置相对于被调用者的帧指针s0是正向偏移。
-                // 第9个参数(arg_idx=8)位于 0(s0)，第10个(arg_idx=9)位于 8(s0)，以此类推。
-                int offset = (arg_idx - 8) * 8; 
-                unsigned arg_vreg = isel->getVReg(arg);
-                Type* arg_type = arg->getType();
-
-                // 根据参数类型选择正确的加载指令
-                RVOpcodes load_op;
-                if (arg_type->isFloat()) {
-                    load_op = RVOpcodes::FLW; // 单精度浮点
-                } else if (arg_type->isPointer()) {
-                    load_op = RVOpcodes::LD;  // 64位指针
-                } else {
-                    load_op = RVOpcodes::LW;  // 32位整数
-                }
-                
-                // 创建加载指令: lw/ld/flw vreg, offset(s0)
-                auto load_instr = std::make_unique<MachineInstr>(load_op);
-                load_instr->addOperand(std::make_unique<RegOperand>(arg_vreg));
-                load_instr->addOperand(std::make_unique<MemOperand>(
-                    std::make_unique<RegOperand>(PhysicalReg::S0), // 基址为帧指针
-                    std::make_unique<ImmOperand>(offset)
-                ));
-                arg_load_instrs.push_back(std::move(load_instr));
-            }
-            arg_idx++;
-        }
-        
-        //仅当有需要加载的栈参数时，才执行插入逻辑
-        if (!arg_load_instrs.empty()) {
-            auto& entry_instrs = entry_block->getInstructions();
-            auto insertion_point = entry_instrs.begin(); // 默认插入点为块的开头
-            auto last_arg_save_it = entry_instrs.end();
-
-            // 步骤 3.2: 寻找一个安全的插入点。
-            // 遍历入口块的指令，找到最后一条保存“寄存器传递参数”的伪指令。
-            // 这样可以确保我们在所有 a0-a7 参数被保存之后，才执行可能覆盖它们的加载指令。
-            for (auto it = entry_instrs.begin(); it != entry_instrs.end(); ++it) {
-                MachineInstr* instr = it->get();
-                // 寻找代表保存参数到栈的伪指令
-                if (instr->getOpcode() == RVOpcodes::FRAME_STORE_W ||
-                    instr->getOpcode() == RVOpcodes::FRAME_STORE_D ||
-                    instr->getOpcode() == RVOpcodes::FRAME_STORE_F) {
-                    
-                    // 检查被保存的值是否是寄存器参数 (arg_no < 8)
-                    auto& operands = instr->getOperands();
-                    if (operands.empty() || operands[0]->getKind() != MachineOperand::KIND_REG) continue;
-                    
-                    unsigned src_vreg = static_cast<RegOperand*>(operands[0].get())->getVRegNum();
-                    Value* ir_value = isel->getVRegValueMap().count(src_vreg) ? isel->getVRegValueMap().at(src_vreg) : nullptr;
-                    
-                    if (auto ir_arg = dynamic_cast<Argument*>(ir_value)) {
-                        if (ir_arg->getIndex() < 8) {
-                            last_arg_save_it = it; // 找到了一个保存寄存器参数的指令，更新位置
-                        }
-                    }
-                }
-            }
-
-            // 如果找到了这样的保存指令，我们的插入点就在它之后
-            if (last_arg_save_it != entry_instrs.end()) {
-                insertion_point = std::next(last_arg_save_it);
-            }
-
-            // 步骤 3.3: 在计算出的安全位置，一次性插入所有新创建的参数加载指令
-            entry_instrs.insert(insertion_point,
-                                std::make_move_iterator(arg_load_instrs.begin()),
-                                std::make_move_iterator(arg_load_instrs.end()));
-        }
-    }
-
-    // 4. 遍历所有机器指令，将访问局部变量的伪指令展开为真实指令
-    for (auto& mbb : mfunc->getBlocks()) {
-        std::vector<std::unique_ptr<MachineInstr>> new_instructions;
-        for (auto& instr_ptr : mbb->getInstructions()) {
-            RVOpcodes opcode = instr_ptr->getOpcode();
-
-            if (opcode == RVOpcodes::FRAME_LOAD_W || opcode == RVOpcodes::FRAME_LOAD_D || opcode == RVOpcodes::FRAME_LOAD_F) {
-                RVOpcodes real_load_op;
-                if (opcode == RVOpcodes::FRAME_LOAD_W) real_load_op = RVOpcodes::LW;
-                else if (opcode == RVOpcodes::FRAME_LOAD_D) real_load_op = RVOpcodes::LD;
-                else real_load_op = RVOpcodes::FLW;
-
-                auto& operands = instr_ptr->getOperands();
-                unsigned dest_vreg = static_cast<RegOperand*>(operands[0].get())->getVRegNum();
-                unsigned alloca_vreg = static_cast<RegOperand*>(operands[1].get())->getVRegNum();
-                int offset = frame_info.alloca_offsets.at(alloca_vreg);
-                auto addr_vreg = isel->getNewVReg(Type::getPointerType(Type::getIntType()));
-
-                // 展开为: addi addr_vreg, s0, offset
-                auto addi = std::make_unique<MachineInstr>(RVOpcodes::ADDI);
-                addi->addOperand(std::make_unique<RegOperand>(addr_vreg));
-                addi->addOperand(std::make_unique<RegOperand>(PhysicalReg::S0));
-                addi->addOperand(std::make_unique<ImmOperand>(offset));
-                new_instructions.push_back(std::move(addi));
-
-                // 展开为: lw/ld/flw dest_vreg, 0(addr_vreg)
-                auto load_instr = std::make_unique<MachineInstr>(real_load_op);
-                load_instr->addOperand(std::make_unique<RegOperand>(dest_vreg));
-                load_instr->addOperand(std::make_unique<MemOperand>(
-                    std::make_unique<RegOperand>(addr_vreg),
-                    std::make_unique<ImmOperand>(0)));
-                new_instructions.push_back(std::move(load_instr));
-
-            } else if (opcode == RVOpcodes::FRAME_STORE_W || opcode == RVOpcodes::FRAME_STORE_D || opcode == RVOpcodes::FRAME_STORE_F) {
-                RVOpcodes real_store_op;
-                if (opcode == RVOpcodes::FRAME_STORE_W) real_store_op = RVOpcodes::SW;
-                else if (opcode == RVOpcodes::FRAME_STORE_D) real_store_op = RVOpcodes::SD;
-                else real_store_op = RVOpcodes::FSW;
-
-                auto& operands = instr_ptr->getOperands();
-                unsigned src_vreg = static_cast<RegOperand*>(operands[0].get())->getVRegNum();
-                unsigned alloca_vreg = static_cast<RegOperand*>(operands[1].get())->getVRegNum();
-                int offset = frame_info.alloca_offsets.at(alloca_vreg);
-                auto addr_vreg = isel->getNewVReg(Type::getPointerType(Type::getIntType()));
-                
-                // 展开为: addi addr_vreg, s0, offset
-                auto addi = std::make_unique<MachineInstr>(RVOpcodes::ADDI);
-                addi->addOperand(std::make_unique<RegOperand>(addr_vreg));
-                addi->addOperand(std::make_unique<RegOperand>(PhysicalReg::S0));
-                addi->addOperand(std::make_unique<ImmOperand>(offset));
-                new_instructions.push_back(std::move(addi));
-
-                // 展开为: sw/sd/fsw src_vreg, 0(addr_vreg)
-                auto store_instr = std::make_unique<MachineInstr>(real_store_op);
-                store_instr->addOperand(std::make_unique<RegOperand>(src_vreg));
-                store_instr->addOperand(std::make_unique<MemOperand>(
-                    std::make_unique<RegOperand>(addr_vreg),
-                    std::make_unique<ImmOperand>(0)));
-                new_instructions.push_back(std::move(store_instr));
-
-            } else if (instr_ptr->getOpcode() == RVOpcodes::FRAME_ADDR) { 
-                auto& operands = instr_ptr->getOperands();
-                unsigned dest_vreg = static_cast<RegOperand*>(operands[0].get())->getVRegNum();
-                unsigned alloca_vreg = static_cast<RegOperand*>(operands[1].get())->getVRegNum();
-                int offset = frame_info.alloca_offsets.at(alloca_vreg);
-
-                // 将 `frame_addr rd, rs` 展开为 `addi rd, s0, offset`
-                auto addi = std::make_unique<MachineInstr>(RVOpcodes::ADDI);
-                addi->addOperand(std::make_unique<RegOperand>(dest_vreg));
-                addi->addOperand(std::make_unique<RegOperand>(PhysicalReg::S0));
-                addi->addOperand(std::make_unique<ImmOperand>(offset));
-                new_instructions.push_back(std::move(addi));
-
-            } else {
-                new_instructions.push_back(std::move(instr_ptr));
-            }
-        }
-        mbb->getInstructions() = std::move(new_instructions);
-    }
-}
-
-} // namespace sysy

src/backend/RISCv64/Handler/PrologueEpilogueInsertion.cpp

@@ -1,22 +1,17 @@
 #include "PrologueEpilogueInsertion.h"
-#include "RISCv64LLIR.h" // 假设包含了 PhysicalReg, RVOpcodes 等定义
 #include "RISCv64ISel.h"
+#include "RISCv64RegAlloc.h" // 需要访问RegAlloc的结果
 #include <algorithm>
-#include <vector>
-#include <set>
 
 namespace sysy {
 
 char PrologueEpilogueInsertionPass::ID = 0;
 
 void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc) {
-    StackFrameInfo& frame_info = mfunc->getFrameInfo();
-    Function* F = mfunc->getFunc();
-    RISCv64ISel* isel = mfunc->getISel();
-    
-    // 1. 清理 KEEPALIVE 伪指令
     for (auto& mbb : mfunc->getBlocks()) {
         auto& instrs = mbb->getInstructions();
+        
+        // 使用标准的 Erase-Remove Idiom 来删除满足条件的元素
         instrs.erase(
             std::remove_if(instrs.begin(), instrs.end(),
                 [](const std::unique_ptr<MachineInstr>& instr) {
@@ -27,59 +22,39 @@ void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc)
         );
     }
     
-    // 2. 确定需要保存的被调用者保存寄存器 (callee-saved)
+    StackFrameInfo& frame_info = mfunc->getFrameInfo();
+    Function* F = mfunc->getFunc();
+    RISCv64ISel* isel = mfunc->getISel();
+    
+    // [关键] 获取寄存器分配的结果 (vreg -> preg 的映射)
+    // RegAlloc Pass 必须已经运行过
     auto& vreg_to_preg_map = frame_info.vreg_to_preg_map;
-    std::set<PhysicalReg> used_callee_saved_regs_set;
-    const auto& callee_saved_int = getCalleeSavedIntRegs();
-    const auto& callee_saved_fp = getCalleeSavedFpRegs();
 
-    for (const auto& pair : vreg_to_preg_map) {
-        PhysicalReg preg = pair.second;
-        bool is_int_cs = std::find(callee_saved_int.begin(), callee_saved_int.end(), preg) != callee_saved_int.end();
-        bool is_fp_cs = std::find(callee_saved_fp.begin(), callee_saved_fp.end(), preg) != callee_saved_fp.end();
-        if ((is_int_cs && preg != PhysicalReg::S0) || is_fp_cs) {
-            used_callee_saved_regs_set.insert(preg);
-        }
-    }
-    frame_info.callee_saved_regs_to_store.assign(
-        used_callee_saved_regs_set.begin(), used_callee_saved_regs_set.end()
-    );
-    std::sort(frame_info.callee_saved_regs_to_store.begin(), frame_info.callee_saved_regs_to_store.end());
-    frame_info.callee_saved_size = frame_info.callee_saved_regs_to_store.size() * 8;
-
-    // 3. 计算最终的栈帧总大小，包含栈溢出保护
+    // 完全遵循 AsmPrinter 中的计算逻辑
     int total_stack_size = frame_info.locals_size + 
                            frame_info.spill_size + 
                            frame_info.callee_saved_size + 
-                           16;
+                           16; // 为 ra 和 s0 固定的16字节
     
-    // 栈溢出保护：增加最大栈帧大小以容纳大型数组
-    const int MAX_STACK_FRAME_SIZE = 8192; // 8KB to handle large arrays like 256*4*2 = 2048 bytes
-    if (total_stack_size > MAX_STACK_FRAME_SIZE) {
-        // 如果仍然超过限制，尝试优化对齐方式
-        std::cerr << "Warning: Stack frame size " << total_stack_size 
-                  << " exceeds recommended limit " << MAX_STACK_FRAME_SIZE << " for function " 
-                  << mfunc->getName() << std::endl;
-    }
-    
-    // 优化：减少对齐开销，使用16字节对齐而非更大的对齐
     int aligned_stack_size = (total_stack_size + 15) & ~15;
     frame_info.total_size = aligned_stack_size;
 
+    // 只有在需要分配栈空间时才生成指令
     if (aligned_stack_size > 0) {
-        // --- 4. 插入完整的序言 ---
+        // --- 1. 插入序言 ---
         MachineBasicBlock* entry_block = mfunc->getBlocks().front().get();
         auto& entry_instrs = entry_block->getInstructions();
+
         std::vector<std::unique_ptr<MachineInstr>> prologue_instrs;
 
-        // 4.1. 分配栈帧
+        // 1. addi sp, sp, -aligned_stack_size
         auto alloc_stack = std::make_unique<MachineInstr>(RVOpcodes::ADDI);
         alloc_stack->addOperand(std::make_unique<RegOperand>(PhysicalReg::SP));
         alloc_stack->addOperand(std::make_unique<RegOperand>(PhysicalReg::SP));
         alloc_stack->addOperand(std::make_unique<ImmOperand>(-aligned_stack_size));
         prologue_instrs.push_back(std::move(alloc_stack));
 
-        // 4.2. 保存 ra 和 s0
+        // 2. sd ra, (aligned_stack_size - 8)(sp)
         auto save_ra = std::make_unique<MachineInstr>(RVOpcodes::SD);
         save_ra->addOperand(std::make_unique<RegOperand>(PhysicalReg::RA));
         save_ra->addOperand(std::make_unique<MemOperand>(
@@ -87,6 +62,8 @@ void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc)
             std::make_unique<ImmOperand>(aligned_stack_size - 8)
         ));
         prologue_instrs.push_back(std::move(save_ra));
+
+        // 3. sd s0, (aligned_stack_size - 16)(sp)
         auto save_fp = std::make_unique<MachineInstr>(RVOpcodes::SD);
         save_fp->addOperand(std::make_unique<RegOperand>(PhysicalReg::S0));
         save_fp->addOperand(std::make_unique<MemOperand>(
@@ -95,55 +72,66 @@ void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc)
         ));
         prologue_instrs.push_back(std::move(save_fp));
         
-        // 4.3. 设置新的帧指针 s0
+        // 4. addi s0, sp, aligned_stack_size
         auto set_fp = std::make_unique<MachineInstr>(RVOpcodes::ADDI);
         set_fp->addOperand(std::make_unique<RegOperand>(PhysicalReg::S0));
         set_fp->addOperand(std::make_unique<RegOperand>(PhysicalReg::SP));
         set_fp->addOperand(std::make_unique<ImmOperand>(aligned_stack_size));
         prologue_instrs.push_back(std::move(set_fp));
+
+        // --- 在s0设置完毕后，使用物理寄存器加载栈参数 ---
+        if (F && isel) {
+            int arg_idx = 0;
+            for (Argument* arg : F->getArguments()) {
+                if (arg_idx >= 8) {
+                    unsigned vreg = isel->getVReg(arg);
+                    
+                    if (frame_info.alloca_offsets.count(vreg) && vreg_to_preg_map.count(vreg)) {
+                        int offset = frame_info.alloca_offsets.at(vreg);
+                        PhysicalReg dest_preg = vreg_to_preg_map.at(vreg);
+                        Type* arg_type = arg->getType();
+
+                        if (arg_type->isFloat()) {
+                            auto load_arg = std::make_unique<MachineInstr>(RVOpcodes::FLW);
+                            load_arg->addOperand(std::make_unique<RegOperand>(dest_preg));
+                            load_arg->addOperand(std::make_unique<MemOperand>(
+                                std::make_unique<RegOperand>(PhysicalReg::S0),
+                                std::make_unique<ImmOperand>(offset)
+                            ));
+                            prologue_instrs.push_back(std::move(load_arg));
+                        } else {
+                            RVOpcodes load_op = arg_type->isPointer() ? RVOpcodes::LD : RVOpcodes::LW;
+                            auto load_arg = std::make_unique<MachineInstr>(load_op);
+                            load_arg->addOperand(std::make_unique<RegOperand>(dest_preg));
+                            load_arg->addOperand(std::make_unique<MemOperand>(
+                                std::make_unique<RegOperand>(PhysicalReg::S0),
+                                std::make_unique<ImmOperand>(offset)
+                            ));
+                            prologue_instrs.push_back(std::move(load_arg));
+                        }
+                    }
+                }
+                arg_idx++;
+            }
+        }
         
-        // 4.4. 保存所有使用到的被调用者保存寄存器
-        int next_available_offset = -(16 + frame_info.locals_size + frame_info.spill_size);
-        for (const auto& reg : frame_info.callee_saved_regs_to_store) {
-            // 改为“先更新，后使用”逻辑
-            next_available_offset -= 8; // 先为当前寄存器分配下一个可用槽位
-            RVOpcodes store_op = isFPR(reg) ? RVOpcodes::FSD : RVOpcodes::SD;
-            auto save_cs_reg = std::make_unique<MachineInstr>(store_op);
-            save_cs_reg->addOperand(std::make_unique<RegOperand>(reg));
-            save_cs_reg->addOperand(std::make_unique<MemOperand>(
-                std::make_unique<RegOperand>(PhysicalReg::S0),
-                std::make_unique<ImmOperand>(next_available_offset) // 使用新计算出的正确偏移
-            ));
-            prologue_instrs.push_back(std::move(save_cs_reg));
-            // 不再需要在循环末尾递减
+        // 确定插入点
+        auto insert_pos = entry_instrs.begin();
+        
+        // 一次性将所有序言指令插入
+        if (!prologue_instrs.empty()) {
+            entry_instrs.insert(insert_pos, 
+                                std::make_move_iterator(prologue_instrs.begin()),
+                                std::make_move_iterator(prologue_instrs.end()));
         }
 
-        // 4.5. 将所有生成的序言指令一次性插入到函数入口
-        entry_instrs.insert(entry_instrs.begin(), 
-                            std::make_move_iterator(prologue_instrs.begin()),
-                            std::make_move_iterator(prologue_instrs.end()));
-
-        // --- 5. 插入完整的尾声 ---
+        // --- 2. 插入尾声 (此部分逻辑保持不变) ---
         for (auto& mbb : mfunc->getBlocks()) {
             for (auto it = mbb->getInstructions().begin(); it != mbb->getInstructions().end(); ++it) {
                 if ((*it)->getOpcode() == RVOpcodes::RET) {
                     std::vector<std::unique_ptr<MachineInstr>> epilogue_instrs;
-                    
-                    // 5.1. 恢复被调用者保存寄存器
-                    int next_available_offset_restore = -(16 + frame_info.locals_size + frame_info.spill_size);
-                    for (const auto& reg : frame_info.callee_saved_regs_to_store) {
-                        next_available_offset_restore -= 8; // 为下一个寄存器准备偏移
-                        RVOpcodes load_op = isFPR(reg) ? RVOpcodes::FLD : RVOpcodes::LD;
-                        auto restore_cs_reg = std::make_unique<MachineInstr>(load_op);
-                        restore_cs_reg->addOperand(std::make_unique<RegOperand>(reg));
-                        restore_cs_reg->addOperand(std::make_unique<MemOperand>(
-                            std::make_unique<RegOperand>(PhysicalReg::S0),
-                            std::make_unique<ImmOperand>(next_available_offset_restore) // 使用当前偏移
-                        ));
-                        epilogue_instrs.push_back(std::move(restore_cs_reg));
-                    }
 
-                    // 5.2. 恢复 ra 和 s0
+                    // 1. ld ra
                     auto restore_ra = std::make_unique<MachineInstr>(RVOpcodes::LD);
                     restore_ra->addOperand(std::make_unique<RegOperand>(PhysicalReg::RA));
                     restore_ra->addOperand(std::make_unique<MemOperand>(
@@ -151,6 +139,8 @@ void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc)
                         std::make_unique<ImmOperand>(aligned_stack_size - 8)
                     ));
                     epilogue_instrs.push_back(std::move(restore_ra));
+
+                    // 2. ld s0
                     auto restore_fp = std::make_unique<MachineInstr>(RVOpcodes::LD);
                     restore_fp->addOperand(std::make_unique<RegOperand>(PhysicalReg::S0));
                     restore_fp->addOperand(std::make_unique<MemOperand>(
@@ -159,18 +149,18 @@ void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc)
                     ));
                     epilogue_instrs.push_back(std::move(restore_fp));
 
-                    // 5.3. 释放栈帧
+                    // 3. addi sp, sp, aligned_stack_size
                     auto dealloc_stack = std::make_unique<MachineInstr>(RVOpcodes::ADDI);
                     dealloc_stack->addOperand(std::make_unique<RegOperand>(PhysicalReg::SP));
                     dealloc_stack->addOperand(std::make_unique<RegOperand>(PhysicalReg::SP));
                     dealloc_stack->addOperand(std::make_unique<ImmOperand>(aligned_stack_size));
                     epilogue_instrs.push_back(std::move(dealloc_stack));
 
-                    // 将尾声指令插入到 RET 指令之前
-                    mbb->getInstructions().insert(it, 
-                                                  std::make_move_iterator(epilogue_instrs.begin()),
-                                                  std::make_move_iterator(epilogue_instrs.end()));
-                    
+                    if (!epilogue_instrs.empty()) {
+                        mbb->getInstructions().insert(it, 
+                                                    std::make_move_iterator(epilogue_instrs.begin()),
+                                                    std::make_move_iterator(epilogue_instrs.end()));
+                    }
                     goto next_block;
                 }
             }

src/backend/RISCv64/Optimize/DivStrengthReduction.cpp

@@ -1,282 +0,0 @@
-#include "DivStrengthReduction.h"
-#include <cmath>
-#include <cstdint>
-
-namespace sysy {
-
-char DivStrengthReduction::ID = 0;
-
-bool DivStrengthReduction::runOnFunction(Function *F, AnalysisManager& AM) {
-    // This pass works on MachineFunction level, not IR level
-    return false;
-}
-
-void DivStrengthReduction::runOnMachineFunction(MachineFunction *mfunc) {
-    if (!mfunc)
-        return;
-
-    bool debug = false; // Set to true for debugging
-    if (debug)
-        std::cout << "Running DivStrengthReduction optimization..." << std::endl;
-
-    int next_temp_reg = 1000;
-    auto createTempReg = [&]() -> int {
-        return next_temp_reg++;
-    };
-
-    struct MagicInfo {
-        int64_t magic;
-        int shift;
-    };
-    
-    auto computeMagic = [](int64_t d, bool is_32bit) -> MagicInfo {
-        int word_size = is_32bit ? 32 : 64;
-        uint64_t ad = std::abs(d);
-        
-        if (ad == 0) return {0, 0};
-        
-        int l = std::floor(std::log2(ad));
-        if ((ad & (ad - 1)) == 0) { // power of 2
-             l = 0; // special case for power of 2, shift will be calculated differently
-        }
-
-        __int128_t one = 1;
-        __int128_t num;
-        int total_shift;
-
-        if (is_32bit) {
-            total_shift = 31 + l;
-            num = one << total_shift;
-        } else {
-            total_shift = 63 + l;
-            num = one << total_shift;
-        }
-        
-        __int128_t den = ad;
-        int64_t magic = (num / den) + 1;
-        
-        return {magic, total_shift};
-    };
-
-    auto isPowerOfTwo = [](int64_t n) -> bool {
-        return n > 0 && (n & (n - 1)) == 0;
-    };
-
-    auto getPowerOfTwoExponent = [](int64_t n) -> int {
-        if (n <= 0 || (n & (n - 1)) != 0) return -1;
-        int shift = 0;
-        while (n > 1) {
-            n >>= 1;
-            shift++;
-        }
-        return shift;
-    };
-
-    struct InstructionReplacement {
-        size_t index;
-        size_t count_to_erase;
-        std::vector<std::unique_ptr<MachineInstr>> newInstrs;
-    };
-    
-    for (auto &mbb_uptr : mfunc->getBlocks()) {
-        auto &mbb = *mbb_uptr;
-        auto &instrs = mbb.getInstructions();
-        std::vector<InstructionReplacement> replacements;
-        
-        for (size_t i = 0; i < instrs.size(); ++i) {
-            auto *instr = instrs[i].get();
-            
-            bool is_32bit = (instr->getOpcode() == RVOpcodes::DIVW);
-            
-            if (instr->getOpcode() != RVOpcodes::DIV && !is_32bit) {
-                continue;
-            }
-            
-            if (instr->getOperands().size() != 3) {
-                continue;
-            }
-            
-            auto *dst_op = instr->getOperands()[0].get();
-            auto *src1_op = instr->getOperands()[1].get();
-            auto *src2_op = instr->getOperands()[2].get();
-
-            int64_t divisor = 0;
-            bool const_divisor_found = false;
-            size_t instructions_to_replace = 1;
-
-            if (src2_op->getKind() == MachineOperand::KIND_IMM) {
-                divisor = static_cast<ImmOperand *>(src2_op)->getValue();
-                const_divisor_found = true;
-            } else if (src2_op->getKind() == MachineOperand::KIND_REG) {
-                if (i > 0) {
-                    auto *prev_instr = instrs[i - 1].get();
-                    if (prev_instr->getOpcode() == RVOpcodes::LI && prev_instr->getOperands().size() == 2) {
-                        auto *li_dst_op = prev_instr->getOperands()[0].get();
-                        auto *li_imm_op = prev_instr->getOperands()[1].get();
-                        if (li_dst_op->getKind() == MachineOperand::KIND_REG && li_imm_op->getKind() == MachineOperand::KIND_IMM) {
-                            auto *div_reg_op = static_cast<RegOperand *>(src2_op);
-                            auto *li_dst_reg_op = static_cast<RegOperand *>(li_dst_op);
-                            if (div_reg_op->isVirtual() && li_dst_reg_op->isVirtual() &&
-                                div_reg_op->getVRegNum() == li_dst_reg_op->getVRegNum()) {
-                                divisor = static_cast<ImmOperand *>(li_imm_op)->getValue();
-                                const_divisor_found = true;
-                                instructions_to_replace = 2;
-                            }
-                        }
-                    }
-                }
-            }
-
-            if (!const_divisor_found) {
-                continue;
-            }
-            
-            auto *dst_reg = static_cast<RegOperand *>(dst_op);
-            auto *src1_reg = static_cast<RegOperand *>(src1_op);
-            
-            if (divisor == 0) continue;
-            
-            std::vector<std::unique_ptr<MachineInstr>> newInstrs;
-            
-            if (divisor == 1) {
-                auto moveInstr = std::make_unique<MachineInstr>(is_32bit ? RVOpcodes::ADDW : RVOpcodes::ADD);
-                moveInstr->addOperand(std::make_unique<RegOperand>(*dst_reg));
-                moveInstr->addOperand(std::make_unique<RegOperand>(*src1_reg));
-                moveInstr->addOperand(std::make_unique<RegOperand>(PhysicalReg::ZERO));
-                newInstrs.push_back(std::move(moveInstr));
-            }
-            else if (divisor == -1) {
-                auto negInstr = std::make_unique<MachineInstr>(is_32bit ? RVOpcodes::SUBW : RVOpcodes::SUB);
-                negInstr->addOperand(std::make_unique<RegOperand>(*dst_reg));
-                negInstr->addOperand(std::make_unique<RegOperand>(PhysicalReg::ZERO));
-                negInstr->addOperand(std::make_unique<RegOperand>(*src1_reg));
-                newInstrs.push_back(std::move(negInstr));
-            }
-            else if (isPowerOfTwo(std::abs(divisor))) {
-                int shift = getPowerOfTwoExponent(std::abs(divisor));
-                int temp_reg = createTempReg();
-                
-                auto sraSignInstr = std::make_unique<MachineInstr>(is_32bit ? RVOpcodes::SRAIW : RVOpcodes::SRAI);
-                sraSignInstr->addOperand(std::make_unique<RegOperand>(temp_reg));
-                sraSignInstr->addOperand(std::make_unique<RegOperand>(*src1_reg));
-                sraSignInstr->addOperand(std::make_unique<ImmOperand>(is_32bit ? 31 : 63));
-                newInstrs.push_back(std::move(sraSignInstr));
-                
-                auto srlInstr = std::make_unique<MachineInstr>(is_32bit ? RVOpcodes::SRLIW : RVOpcodes::SRLI);
-                srlInstr->addOperand(std::make_unique<RegOperand>(temp_reg));
-                srlInstr->addOperand(std::make_unique<RegOperand>(temp_reg));
-                srlInstr->addOperand(std::make_unique<ImmOperand>((is_32bit ? 32 : 64) - shift));
-                newInstrs.push_back(std::move(srlInstr));
-                
-                auto addInstr = std::make_unique<MachineInstr>(is_32bit ? RVOpcodes::ADDW : RVOpcodes::ADD);
-                addInstr->addOperand(std::make_unique<RegOperand>(temp_reg));
-                addInstr->addOperand(std::make_unique<RegOperand>(*src1_reg));
-                addInstr->addOperand(std::make_unique<RegOperand>(temp_reg));
-                newInstrs.push_back(std::move(addInstr));
-                
-                auto sraInstr = std::make_unique<MachineInstr>(is_32bit ? RVOpcodes::SRAIW : RVOpcodes::SRAI);
-                sraInstr->addOperand(std::make_unique<RegOperand>(temp_reg));
-                sraInstr->addOperand(std::make_unique<RegOperand>(temp_reg));
-                sraInstr->addOperand(std::make_unique<ImmOperand>(shift));
-                newInstrs.push_back(std::move(sraInstr));
-
-                if (divisor < 0) {
-                    auto negInstr = std::make_unique<MachineInstr>(is_32bit ? RVOpcodes::SUBW : RVOpcodes::SUB);
-                    negInstr->addOperand(std::make_unique<RegOperand>(*dst_reg));
-                    negInstr->addOperand(std::make_unique<RegOperand>(PhysicalReg::ZERO));
-                    negInstr->addOperand(std::make_unique<RegOperand>(temp_reg));
-                    newInstrs.push_back(std::move(negInstr));
-                } else {
-                    auto moveInstr = std::make_unique<MachineInstr>(is_32bit ? RVOpcodes::ADDW : RVOpcodes::ADD);
-                    moveInstr->addOperand(std::make_unique<RegOperand>(*dst_reg));
-                    moveInstr->addOperand(std::make_unique<RegOperand>(temp_reg));
-                    moveInstr->addOperand(std::make_unique<RegOperand>(PhysicalReg::ZERO));
-                    newInstrs.push_back(std::move(moveInstr));
-                }
-            }
-            else {
-                auto magic_info = computeMagic(divisor, is_32bit);
-                int magic_reg = createTempReg();
-                int temp_reg = createTempReg();
-
-                auto loadInstr = std::make_unique<MachineInstr>(RVOpcodes::LI);
-                loadInstr->addOperand(std::make_unique<RegOperand>(magic_reg));
-                loadInstr->addOperand(std::make_unique<ImmOperand>(magic_info.magic));
-                newInstrs.push_back(std::move(loadInstr));
-
-                if (is_32bit) {
-                    auto mulInstr = std::make_unique<MachineInstr>(RVOpcodes::MUL);
-                    mulInstr->addOperand(std::make_unique<RegOperand>(temp_reg));
-                    mulInstr->addOperand(std::make_unique<RegOperand>(*src1_reg));
-                    mulInstr->addOperand(std::make_unique<RegOperand>(magic_reg));
-                    newInstrs.push_back(std::move(mulInstr));
-
-                    auto sraInstr = std::make_unique<MachineInstr>(RVOpcodes::SRAI);
-                    sraInstr->addOperand(std::make_unique<RegOperand>(temp_reg));
-                    sraInstr->addOperand(std::make_unique<RegOperand>(temp_reg));
-                    sraInstr->addOperand(std::make_unique<ImmOperand>(magic_info.shift));
-                    newInstrs.push_back(std::move(sraInstr));
-                } else {
-                    auto mulhInstr = std::make_unique<MachineInstr>(RVOpcodes::MULH);
-                    mulhInstr->addOperand(std::make_unique<RegOperand>(temp_reg));
-                    mulhInstr->addOperand(std::make_unique<RegOperand>(*src1_reg));
-                    mulhInstr->addOperand(std::make_unique<RegOperand>(magic_reg));
-                    newInstrs.push_back(std::move(mulhInstr));
-                    
-                    int post_shift = magic_info.shift - 63;
-                    if (post_shift > 0) {
-                        auto sraInstr = std::make_unique<MachineInstr>(RVOpcodes::SRAI);
-                        sraInstr->addOperand(std::make_unique<RegOperand>(temp_reg));
-                        sraInstr->addOperand(std::make_unique<RegOperand>(temp_reg));
-                        sraInstr->addOperand(std::make_unique<ImmOperand>(post_shift));
-                        newInstrs.push_back(std::move(sraInstr));
-                    }
-                }
-                
-                int sign_reg = createTempReg();
-                auto sraSignInstr = std::make_unique<MachineInstr>(is_32bit ? RVOpcodes::SRAIW : RVOpcodes::SRAI);
-                sraSignInstr->addOperand(std::make_unique<RegOperand>(sign_reg));
-                sraSignInstr->addOperand(std::make_unique<RegOperand>(*src1_reg));
-                sraSignInstr->addOperand(std::make_unique<ImmOperand>(is_32bit ? 31 : 63));
-                newInstrs.push_back(std::move(sraSignInstr));
-
-                auto subInstr = std::make_unique<MachineInstr>(is_32bit ? RVOpcodes::SUBW : RVOpcodes::SUB);
-                subInstr->addOperand(std::make_unique<RegOperand>(temp_reg));
-                subInstr->addOperand(std::make_unique<RegOperand>(temp_reg));
-                subInstr->addOperand(std::make_unique<RegOperand>(sign_reg));
-                newInstrs.push_back(std::move(subInstr));
-
-                if (divisor < 0) {
-                    auto negInstr = std::make_unique<MachineInstr>(is_32bit ? RVOpcodes::SUBW : RVOpcodes::SUB);
-                    negInstr->addOperand(std::make_unique<RegOperand>(*dst_reg));
-                    negInstr->addOperand(std::make_unique<RegOperand>(PhysicalReg::ZERO));
-                    negInstr->addOperand(std::make_unique<RegOperand>(temp_reg));
-                    newInstrs.push_back(std::move(negInstr));
-                } else {
-                    auto moveInstr = std::make_unique<MachineInstr>(is_32bit ? RVOpcodes::ADDW : RVOpcodes::ADD);
-                    moveInstr->addOperand(std::make_unique<RegOperand>(*dst_reg));
-                    moveInstr->addOperand(std::make_unique<RegOperand>(temp_reg));
-                    moveInstr->addOperand(std::make_unique<RegOperand>(PhysicalReg::ZERO));
-                    newInstrs.push_back(std::move(moveInstr));
-                }
-            }
-            
-            if (!newInstrs.empty()) {
-                size_t start_index = i;
-                if (instructions_to_replace == 2) {
-                    start_index = i - 1;
-                }
-                replacements.push_back({start_index, instructions_to_replace, std::move(newInstrs)});
-            }
-        }
-        
-        for (auto it = replacements.rbegin(); it != replacements.rend(); ++it) {
-            instrs.erase(instrs.begin() + it->index, instrs.begin() + it->index + it->count_to_erase);
-            instrs.insert(instrs.begin() + it->index, 
-                         std::make_move_iterator(it->newInstrs.begin()),
-                         std::make_move_iterator(it->newInstrs.end()));
-        }
-    }
-}
-
-} // namespace sysy

src/backend/RISCv64/RISCv64AsmPrinter.cpp

@@ -1,8 +1,7 @@
 #include "RISCv64AsmPrinter.h"
 #include "RISCv64ISel.h"
 #include <stdexcept>
-#include <sstream>
-#include <iostream>
+
 namespace sysy {
 
 // 检查是否为内存加载/存储指令，以处理特殊的打印格式
@@ -61,7 +60,7 @@ void RISCv64AsmPrinter::printInstruction(MachineInstr* instr, bool debug) {
         case RVOpcodes::ADD:   *OS << "add ";   break; case RVOpcodes::ADDI:  *OS << "addi ";  break;
         case RVOpcodes::ADDW:  *OS << "addw ";  break; case RVOpcodes::ADDIW: *OS << "addiw "; break;
         case RVOpcodes::SUB:   *OS << "sub ";   break; case RVOpcodes::SUBW:  *OS << "subw ";  break;
-        case RVOpcodes::MUL:   *OS << "mul ";   break; case RVOpcodes::MULW:  *OS << "mulw ";  break; case RVOpcodes::MULH:  *OS << "mulh ";  break;
+        case RVOpcodes::MUL:   *OS << "mul ";   break; case RVOpcodes::MULW:  *OS << "mulw ";  break;
         case RVOpcodes::DIV:   *OS << "div ";   break; case RVOpcodes::DIVW:  *OS << "divw ";  break;
         case RVOpcodes::REM:   *OS << "rem ";   break; case RVOpcodes::REMW:  *OS << "remw ";  break;
         case RVOpcodes::XOR:   *OS << "xor ";   break; case RVOpcodes::XORI:  *OS << "xori ";  break;
@@ -82,7 +81,7 @@ void RISCv64AsmPrinter::printInstruction(MachineInstr* instr, bool debug) {
         case RVOpcodes::SB:    *OS << "sb ";    break; case RVOpcodes::LD:    *OS << "ld ";    break;
         case RVOpcodes::SD:    *OS << "sd ";    break; case RVOpcodes::FLW:   *OS << "flw ";   break;
         case RVOpcodes::FSW:   *OS << "fsw ";   break; case RVOpcodes::FLD:   *OS << "fld ";   break;
-        case RVOpcodes::FSD:   *OS << "fsd ";   break; 
+        case RVOpcodes::FSD:   *OS << "fsd ";   break;
         case RVOpcodes::J:     *OS << "j ";     break; case RVOpcodes::JAL:   *OS << "jal ";   break;
         case RVOpcodes::JALR:  *OS << "jalr ";  break; case RVOpcodes::RET:   *OS << "ret";    break;
         case RVOpcodes::BEQ:   *OS << "beq ";   break; case RVOpcodes::BNE:   *OS << "bne ";   break;
@@ -102,11 +101,10 @@ void RISCv64AsmPrinter::printInstruction(MachineInstr* instr, bool debug) {
         case RVOpcodes::FLE_S:   *OS << "fle.s ";   break;
         case RVOpcodes::FCVT_S_W: *OS << "fcvt.s.w "; break;
         case RVOpcodes::FCVT_W_S: *OS << "fcvt.w.s "; break;
-        case RVOpcodes::FCVT_W_S_RTZ: *OS << "fcvt.w.s "; break;
         case RVOpcodes::FMV_S:    *OS << "fmv.s ";    break;
         case RVOpcodes::FMV_W_X:  *OS << "fmv.w.x ";  break;
         case RVOpcodes::FMV_X_W:  *OS << "fmv.x.w ";  break;
-        case RVOpcodes::CALL: { // 为CALL指令添加特殊处理逻辑
+        case RVOpcodes::CALL: { // [核心修改] 为CALL指令添加特殊处理逻辑
             *OS << "call ";
             // 遍历所有操作数，只寻找并打印函数名标签
             for (const auto& op : instr->getOperands()) {
@@ -238,30 +236,4 @@ std::string RISCv64AsmPrinter::regToString(PhysicalReg reg) {
     }
 }
 
-std::string RISCv64AsmPrinter::formatInstr(const MachineInstr* instr) {
-    if (!instr) return "(null instr)";
-    
-    // 使用 stringstream 作为临时的输出目标
-    std::stringstream ss;
-    
-    // 关键: 临时将类成员 'OS' 指向我们的 stringstream
-    std::ostream* old_os = this->OS;
-    this->OS = &ss;
-    
-    // 修正: 调用正确的内部打印函数 printMachineInstr
-    printInstruction(const_cast<MachineInstr*>(instr), false);
-    
-    // 恢复旧的 ostream 指针
-    this->OS = old_os;
-    
-    // 获取stringstream的内容并做一些清理
-    std::string result = ss.str();
-    size_t endpos = result.find_last_not_of(" \t\n\r");
-    if (std::string::npos != endpos) {
-        result = result.substr(0, endpos + 1);
-    }
-    
-    return result;
-}
-
 } // namespace sysy

src/backend/RISCv64/RISCv64Backend.cpp

@@ -1,13 +1,10 @@
 #include "RISCv64Backend.h"
 #include "RISCv64ISel.h"
 #include "RISCv64RegAlloc.h"
-#include "RISCv64LinearScan.h" // <--- 新增此行
 #include "RISCv64AsmPrinter.h"
 #include "RISCv64Passes.h"
 #include <sstream>
-#include <future>   // <--- 新增此行
-#include <chrono>   // <--- 新增此行
-#include <iostream> // <--- 新增此行，用于打印超时警告
+
 namespace sysy {
 
 // 顶层入口
@@ -15,39 +12,6 @@ std::string RISCv64CodeGen::code_gen() {
     return module_gen();
 }
 
-unsigned RISCv64CodeGen::getTypeSizeInBytes(Type* type) {
-    if (!type) {
-        assert(false && "Cannot get size of a null type.");
-        return 0;
-    }
-
-    switch (type->getKind()) {
-        // 对于SysY语言，基本类型int和float都占用4字节
-        case Type::kInt:
-        case Type::kFloat:
-            return 4;
-
-        // 指针类型在RISC-V 64位架构下占用8字节
-        // 虽然SysY没有'int*'语法，但数组变量在IR层面本身就是指针类型
-        case Type::kPointer:
-            return 8;
-
-        // 数组类型的总大小 = 元素数量 * 单个元素的大小
-        case Type::kArray: {
-            auto arrayType = type->as<ArrayType>();
-            // 递归调用以计算元素大小
-            return arrayType->getNumElements() * getTypeSizeInBytes(arrayType->getElementType());
-        }
-
-        // 其他类型，如Void, Label等不占用栈空间，或者不应该出现在这里
-        default:
-            // 如果遇到未处理的类型，触发断言，方便调试
-            // assert(false && "Unsupported type for size calculation.");
-            return 0; // 对于像Label或Void这样的类型，返回0是合理的
-    }
-}
-
-
 void printInitializer(std::stringstream& ss, const ValueCounter& init_values) {
     for (size_t i = 0; i < init_values.getValues().size(); ++i) {
         auto val = init_values.getValues()[i];
@@ -75,36 +39,18 @@ std::string RISCv64CodeGen::module_gen() {
 
     for (const auto& global_ptr : module->getGlobals()) {
         GlobalValue* global = global_ptr.get();
-        
-        // 使用更健壮的逻辑来判断是否为大型零初始化数组
-        bool is_all_zeros = true;
         const auto& init_values = global->getInitValues();
         
-        // 检查初始化值是否全部为0
-        if (init_values.getValues().empty()) {
-            // 如果 ValueCounter 为空，GlobalValue 的构造函数会确保它是零初始化的
-            is_all_zeros = true;
-        } else {
-            for (auto val : init_values.getValues()) {
-                if (auto const_val = dynamic_cast<ConstantValue*>(val)) {
-                    if (!const_val->isZero()) {
-                        is_all_zeros = false;
-                        break;
-                    }
-                } else {
-                    // 如果初始值包含非常量（例如，另一个全局变量的地址），则不认为是纯零初始化
-                    is_all_zeros = false;
-                    break;
+        // 判断是否为大型零初始化数组，以便放入.bss段
+        bool is_large_zero_array = false;
+        if (init_values.getValues().size() == 1) {
+            if (auto const_val = dynamic_cast<ConstantValue*>(init_values.getValues()[0])) {
+                if (const_val->isInt() && const_val->getInt() == 0 && init_values.getNumbers()[0] > 16) {
+                    is_large_zero_array = true;
                 }
             }
         }
 
-        // 使用 getTypeSizeInBytes 检查总大小是否超过阈值 (16个整数 = 64字节)
-        Type* allocated_type = global->getType()->as<PointerType>()->getBaseType();
-        unsigned total_size = getTypeSizeInBytes(allocated_type);
-        
-        bool is_large_zero_array = is_all_zeros && (total_size > 64);
-
         if (is_large_zero_array) {
             bss_globals.push_back(global);
         } else {
@@ -112,12 +58,12 @@ std::string RISCv64CodeGen::module_gen() {
         }
     }
 
-    // --- 步骤2：生成 .bss 段的代码 ---
+    // --- 步骤2：生成 .bss 段的代码 (这部分不变) ---
     if (!bss_globals.empty()) {
         ss << ".bss\n";
         for (GlobalValue* global : bss_globals) {
-            Type* allocated_type = global->getType()->as<PointerType>()->getBaseType();
-            unsigned total_size = getTypeSizeInBytes(allocated_type);
+            unsigned count = global->getInitValues().getNumbers()[0];
+            unsigned total_size = count * 4; // 假设元素都是4字节
 
             ss << "    .align 3\n";
             ss << ".globl " << global->getName() << "\n";
@@ -128,67 +74,33 @@ std::string RISCv64CodeGen::module_gen() {
         }
     }
     
-    // --- 步骤3：生成 .data 段的代码 ---
+    // --- [修改] 步骤3：生成 .data 段的代码 ---
+    // 我们需要检查 data_globals 和 常量列表是否都为空
     if (!data_globals.empty() || !module->getConsts().empty()) {
         ss << ".data\n";
 
-        // a. 处理普通的全局变量 (GlobalValue)
+        // a. 先处理普通的全局变量 (GlobalValue)
         for (GlobalValue* global : data_globals) {
-            Type* allocated_type = global->getType()->as<PointerType>()->getBaseType();
-            unsigned total_size = getTypeSizeInBytes(allocated_type);
-            
-            ss << "    .align 3\n";
             ss << ".globl " << global->getName() << "\n";
-            ss << ".type " << global->getName() << ", @object\n";
-            ss << ".size " << global->getName() << ", " << total_size << "\n";
             ss << global->getName() << ":\n";
-            bool is_all_zeros = true;
-            const auto& init_values = global->getInitValues();
-            if (init_values.getValues().empty()) {
-                is_all_zeros = true;
-            } else {
-                for (auto val : init_values.getValues()) {
-                    if (auto const_val = dynamic_cast<ConstantValue*>(val)) {
-                        if (!const_val->isZero()) {
-                            is_all_zeros = false;
-                            break;
-                        }
-                    } else {
-                        is_all_zeros = false;
-                        break;
-                    }
-                }
-            }
-            if (is_all_zeros) {
-                ss << "    .zero " << total_size << "\n";
-            } else {
-                // 对于有非零初始值的变量，保持原有的打印逻辑。
-                printInitializer(ss, global->getInitValues());
-            }
+            printInitializer(ss, global->getInitValues());
         }
 
-        // b. 处理全局常量 (ConstantVariable)
+        // b. [新增] 再处理全局常量 (ConstantVariable)
         for (const auto& const_ptr : module->getConsts()) {
             ConstantVariable* cnst = const_ptr.get();
-            Type* allocated_type = cnst->getType()->as<PointerType>()->getBaseType();
-            unsigned total_size = getTypeSizeInBytes(allocated_type);
-
-            ss << "    .align 3\n";
             ss << ".globl " << cnst->getName() << "\n";
-            ss << ".type " << cnst->getName() << ", @object\n";
-            ss << ".size " << cnst->getName() << ", " << total_size << "\n";
             ss << cnst->getName() << ":\n";
             printInitializer(ss, cnst->getInitValues());
         }
     }
 
-    // --- 步骤4：处理函数 (.text段) 的逻辑 ---
+    // --- 处理函数 (.text段) 的逻辑保持不变 ---
     if (!module->getFunctions().empty()) {
         ss << ".text\n";
         for (const auto& func_pair : module->getFunctions()) {
-            if (func_pair.second.get() && !func_pair.second->getBasicBlocks().empty()) {
+            if (func_pair.second.get()) {
                 ss << function_gen(func_pair.second.get());
-                if (DEBUG) std::cerr << "Function: " << func_pair.first << " generated.\n";
             }
         }
     }
@@ -203,58 +115,25 @@ std::string RISCv64CodeGen::function_gen(Function* func) {
     std::unique_ptr<MachineFunction> mfunc = isel.runOnFunction(func);
 
     // 第一次调试打印输出
-    std::stringstream ss_after_isel;
-    RISCv64AsmPrinter printer_isel(mfunc.get());
-    printer_isel.run(ss_after_isel, true);
+    std::stringstream ss1;
+    RISCv64AsmPrinter printer1(mfunc.get());
+    printer1.run(ss1, true);
 
-    if (DEBUG) {
-        std::cerr << "====== Intermediate Representation after Instruction Selection ======\n" 
-        << ss_after_isel.str();
-    }
-    
-    // 阶段 2: 消除帧索引 (展开伪指令，计算局部变量偏移)
-    // 这个Pass必须在寄存器分配之前运行
-    EliminateFrameIndicesPass efi_pass;
-    efi_pass.runOnMachineFunction(mfunc.get());
-
-    if (DEBUG) {
-        std::cerr << "====== stack info after eliminate frame indices  ======\n";
-        mfunc->dumpStackFrameInfo(std::cerr);
-        std::stringstream ss_after_eli;
-        printer_isel.run(ss_after_eli, true);
-        std::cerr << "====== LLIR after eliminate frame indices ======\n" 
-        << ss_after_eli.str();
-    }
-
-    // // 阶段 2: 除法强度削弱优化 (Division Strength Reduction)
-    // DivStrengthReduction div_strength_reduction;
-    // div_strength_reduction.runOnMachineFunction(mfunc.get());
-
-    // // 阶段 2.1: 指令调度 (Instruction Scheduling)
-    // PreRA_Scheduler scheduler;
-    // scheduler.runOnMachineFunction(mfunc.get());
+    // 阶段 2: 指令调度 (Instruction Scheduling)
+    PreRA_Scheduler scheduler;
+    scheduler.runOnMachineFunction(mfunc.get());
 
     // 阶段 3: 物理寄存器分配 (Register Allocation)
     RISCv64RegAlloc reg_alloc(mfunc.get());
     reg_alloc.run();
 
-    if (DEBUG) {
-        std::cerr << "====== stack info after reg alloc ======\n";
-        mfunc->dumpStackFrameInfo(std::cerr);
-    }
-
     // 阶段 3.1: 处理被调用者保存寄存器
     CalleeSavedHandler callee_handler;
     callee_handler.runOnMachineFunction(mfunc.get());
 
-    if (DEBUG) {
-        std::cerr << "====== stack info after callee handler ======\n";
-        mfunc->dumpStackFrameInfo(std::cerr);
-    }
-
-    // // 阶段 4: 窥孔优化 (Peephole Optimization)
-    // PeepholeOptimizer peephole;
-    // peephole.runOnMachineFunction(mfunc.get());
+    // 阶段 4: 窥孔优化 (Peephole Optimization)
+    PeepholeOptimizer peephole;
+    peephole.runOnMachineFunction(mfunc.get());
 
     // 阶段 5: 局部指令调度 (Local Scheduling)
     PostRA_Scheduler local_scheduler;
@@ -264,7 +143,7 @@ std::string RISCv64CodeGen::function_gen(Function* func) {
     PrologueEpilogueInsertionPass pei_pass;
     pei_pass.runOnMachineFunction(mfunc.get());
 
-    // 阶段 3.3: 大立即数合法化
+    // 阶段 3.3: 清理产生的大立即数
     LegalizeImmediatesPass legalizer;
     legalizer.runOnMachineFunction(mfunc.get());
 
@@ -272,7 +151,7 @@ std::string RISCv64CodeGen::function_gen(Function* func) {
     std::stringstream ss;
     RISCv64AsmPrinter printer(mfunc.get());
     printer.run(ss);
-
+    if (DEBUG) ss << "\n" << ss1.str(); // 将指令选择阶段的结果也包含在最终输出中
     return ss.str();
 }
 

src/backend/RISCv64/RISCv64ISel.cpp

@@ -1,10 +1,9 @@
 #include "RISCv64ISel.h"
-#include "IR.h"  // For GlobalValue
 #include <stdexcept>
 #include <set>
 #include <functional>
-#include <cmath>
-#include <limits>
+#include <cmath> // For std::fabs
+#include <limits> // For std::numeric_limits
 #include <iostream>
 
 namespace sysy {
@@ -168,6 +167,33 @@ void RISCv64ISel::selectBasicBlock(BasicBlock* bb) {
             select_recursive(node_to_select);
         }
     }
+
+    if (CurMBB == MFunc->getBlocks().front().get()) { // 只对入口块操作
+        auto keepalive = std::make_unique<MachineInstr>(RVOpcodes::PSEUDO_KEEPALIVE);
+        for (Argument* arg : F->getArguments()) {
+            keepalive->addOperand(std::make_unique<RegOperand>(getVReg(arg)));
+        }
+
+        auto& instrs = CurMBB->getInstructions();
+        auto insert_pos = instrs.end();
+
+        // 关键：检查基本块是否以一个“终止指令”结尾
+        if (!instrs.empty()) {
+            RVOpcodes last_op = instrs.back()->getOpcode();
+            // 扩充了判断条件，涵盖所有可能的终止指令
+            if (last_op == RVOpcodes::J || last_op == RVOpcodes::RET ||
+                last_op == RVOpcodes::BEQ || last_op == RVOpcodes::BNE ||
+                last_op == RVOpcodes::BLT || last_op == RVOpcodes::BGE ||
+                last_op == RVOpcodes::BLTU || last_op == RVOpcodes::BGEU)
+            {
+                // 如果是，插入点就在这个终止指令之前
+                insert_pos = std::prev(instrs.end());
+            }
+        }
+        
+        // 在计算出的正确位置插入伪指令
+        instrs.insert(insert_pos, std::move(keepalive));
+    }
 }
 
 // 核心函数：为DAG节点选择并生成MachineInstr (已修复和增强的完整版本)
@@ -183,12 +209,8 @@ void RISCv64ISel::selectNode(DAGNode* node) {
         case DAGNode::CONSTANT:
         case DAGNode::ALLOCA_ADDR:
             if (node->value) {
-                // GlobalValue objects (global variables) should not get virtual registers
-                // since they represent memory addresses, not register-allocated values
-                if (dynamic_cast<GlobalValue*>(node->value) == nullptr) {
-                    // 确保它有一个关联的虚拟寄存器即可，不生成代码。
-                    getVReg(node->value);
-                }
+                // 确保它有一个关联的虚拟寄存器即可，不生成代码。
+                getVReg(node->value);
             }
             break;
         
@@ -380,7 +402,7 @@ void RISCv64ISel::selectNode(DAGNode* node) {
                 Value* base = nullptr;
                 Value* offset = nullptr;
 
-                // 扩展基地址的判断，使其可以识别 AllocaInst 或 GlobalValue
+                // [修改] 扩展基地址的判断，使其可以识别 AllocaInst 或 GlobalValue
                 if (dynamic_cast<AllocaInst*>(lhs) || dynamic_cast<GlobalValue*>(lhs)) {
                     base = lhs;
                     offset = rhs;
@@ -399,7 +421,7 @@ void RISCv64ISel::selectNode(DAGNode* node) {
                         CurMBB->addInstruction(std::move(li));
                     }
                     
-                    // 2. 根据基地址的类型，生成不同的指令来获取基地址
+                    // 2. [修改] 根据基地址的类型，生成不同的指令来获取基地址
                     auto base_addr_vreg = getNewVReg(Type::getIntType()); // 创建一个新的临时vreg来存放基地址
 
                     // 情况一：基地址是局部栈变量
@@ -430,7 +452,7 @@ void RISCv64ISel::selectNode(DAGNode* node) {
                 }
             }
 
-            // 在BINARY节点内部按需加载常量操作数。
+            // [V2优点] 在BINARY节点内部按需加载常量操作数。
             auto load_val_if_const = [&](Value* val) {
                 if (auto c = dynamic_cast<ConstantValue*>(val)) {
                     if (DEBUG) {
@@ -461,7 +483,7 @@ void RISCv64ISel::selectNode(DAGNode* node) {
             auto dest_vreg = getVReg(bin);
             auto lhs_vreg = getVReg(lhs);
 
-            // 融合 ADDIW 优化。
+            // [V2优点] 融合 ADDIW 优化。
             if (rhs_is_imm_opt) {
                 auto rhs_const = dynamic_cast<ConstantValue*>(rhs);
                 auto instr = std::make_unique<MachineInstr>(RVOpcodes::ADDIW);
@@ -517,15 +539,6 @@ void RISCv64ISel::selectNode(DAGNode* node) {
                     CurMBB->addInstruction(std::move(instr));
                     break;
                 }
-                case Instruction::kSRA: {
-                    auto rhs_const = dynamic_cast<ConstantInteger*>(rhs);
-                    auto instr = std::make_unique<MachineInstr>(RVOpcodes::SRAIW);
-                    instr->addOperand(std::make_unique<RegOperand>(dest_vreg));
-                    instr->addOperand(std::make_unique<RegOperand>(lhs_vreg));
-                    instr->addOperand(std::make_unique<ImmOperand>(rhs_const->getInt()));
-                    CurMBB->addInstruction(std::move(instr));
-                    break;
-                }
                 case BinaryInst::kICmpEQ: { // 等于 (a == b) -> (subw; seqz)
                     auto sub = std::make_unique<MachineInstr>(RVOpcodes::SUBW);
                     sub->addOperand(std::make_unique<RegOperand>(dest_vreg));
@@ -745,9 +758,8 @@ void RISCv64ISel::selectNode(DAGNode* node) {
                     CurMBB->addInstruction(std::move(instr));
                     break;
                 }
-                case Instruction::kFtoI: { // 浮点 to 整数 (使用硬件指令进行向零截断)
-                    // 直接生成一条带有 rtz 舍入模式的转换指令
-                    auto instr = std::make_unique<MachineInstr>(RVOpcodes::FCVT_W_S_RTZ);
+                case Instruction::kFtoI: { // 浮点 to 整数
+                    auto instr = std::make_unique<MachineInstr>(RVOpcodes::FCVT_W_S);
                     instr->addOperand(std::make_unique<RegOperand>(dest_vreg)); // 目标是整数vreg
                     instr->addOperand(std::make_unique<RegOperand>(src_vreg));  // 源是浮点vreg
                     CurMBB->addInstruction(std::move(instr));
@@ -931,7 +943,7 @@ void RISCv64ISel::selectNode(DAGNode* node) {
             
             // --- 步骤 3: 生成CALL指令 ---
             auto call_instr = std::make_unique<MachineInstr>(RVOpcodes::CALL);
-            // 如果函数有返回值，将它的目标虚拟寄存器作为第一个操作数
+            // [协议] 如果函数有返回值，将它的目标虚拟寄存器作为第一个操作数
             if (!call->getType()->isVoid()) {
                 unsigned dest_vreg = getVReg(call);
                 call_instr->addOperand(std::make_unique<RegOperand>(dest_vreg));
@@ -1008,7 +1020,7 @@ void RISCv64ISel::selectNode(DAGNode* node) {
                 } else {
                     // --- 处理整数/指针返回值 ---
                     // 返回值需要被放入 a0
-                    // 在RETURN节点内加载常量返回值
+                    // [V2优点] 在RETURN节点内加载常量返回值
                     if (auto const_val = dynamic_cast<ConstantValue*>(ret_val)) {
                         auto li_instr = std::make_unique<MachineInstr>(RVOpcodes::LI);
                         li_instr->addOperand(std::make_unique<RegOperand>(PhysicalReg::A0));
@@ -1022,7 +1034,7 @@ void RISCv64ISel::selectNode(DAGNode* node) {
                     }
                 }
             }
-            // 函数尾声（epilogue）不由RETURN节点生成，
+            // [V1设计保留] 函数尾声（epilogue）不由RETURN节点生成，
             // 而是由后续的AsmPrinter或其它Pass统一处理，这是一种常见且有效的模块化设计。
             auto ret_mi = std::make_unique<MachineInstr>(RVOpcodes::RET);
             CurMBB->addInstruction(std::move(ret_mi));
@@ -1036,7 +1048,7 @@ void RISCv64ISel::selectNode(DAGNode* node) {
             auto then_bb_name = cond_br->getThenBlock()->getName();
             auto else_bb_name = cond_br->getElseBlock()->getName();
 
-            // 检查分支条件是否为编译期常量
+            // [优化] 检查分支条件是否为编译期常量
             if (auto const_cond = dynamic_cast<ConstantValue*>(condition)) {
                 // 如果条件是常量，直接生成一个无条件跳转J，而不是BNE
                 if (const_cond->getInt() != 0) { // 条件为 true
@@ -1051,7 +1063,7 @@ void RISCv64ISel::selectNode(DAGNode* node) {
             } 
             // 如果条件不是常量，则执行标准流程
             else {
-                // 为条件变量生成加载指令（如果它是常量的话，尽管上面已经处理了）
+                // [修复] 为条件变量生成加载指令（如果它是常量的话，尽管上面已经处理了）
                 // 这一步是为了逻辑完整，以防有其他类型的常量没有被捕获
                 if (auto const_val = dynamic_cast<ConstantValue*>(condition)) {
                     auto li = std::make_unique<MachineInstr>(RVOpcodes::LI);
@@ -1085,7 +1097,7 @@ void RISCv64ISel::selectNode(DAGNode* node) {
     }
 
         case DAGNode::MEMSET: {
-            // Memset的核心展开逻辑在虚拟寄存器层面是正确的，无需修改。
+            // [V1设计保留] Memset的核心展开逻辑在虚拟寄存器层面是正确的，无需修改。
             // 之前的bug是由于其输入（地址、值、大小）的虚拟寄存器未被正确初始化。
             // 在修复了CONSTANT/ALLOCA_ADDR的加载问题后，此处的逻辑现在可以正常工作。
 
@@ -1131,11 +1143,10 @@ void RISCv64ISel::selectNode(DAGNode* node) {
             auto r_value_byte = getVReg(memset->getValue());
             
             // 为memset内部逻辑创建新的临时虚拟寄存器
-            Type* ptr_type = Type::getPointerType(Type::getIntType()); 
-            auto r_counter = getNewVReg(ptr_type);
-            auto r_end_addr = getNewVReg(ptr_type);
-            auto r_current_addr = getNewVReg(ptr_type);
-             auto r_temp_val = getNewVReg(Type::getIntType());
+            auto r_counter = getNewVReg();
+            auto r_end_addr = getNewVReg();
+            auto r_current_addr = getNewVReg();
+            auto r_temp_val = getNewVReg();
 
             // 定义一系列lambda表达式来简化指令创建
             auto add_instr = [&](RVOpcodes op, unsigned rd, unsigned rs1, unsigned rs2) {
@@ -1226,7 +1237,7 @@ void RISCv64ISel::selectNode(DAGNode* node) {
 
             // --- Step 1: 获取基地址 (此部分逻辑正确，保持不变) ---
             auto base_ptr_node = node->operands[0];
-            auto current_addr_vreg = getNewVReg(gep->getType());
+            auto current_addr_vreg = getNewVReg();
 
             if (auto alloca_base = dynamic_cast<AllocaInst*>(base_ptr_node->value)) {
                 auto frame_addr_instr = std::make_unique<MachineInstr>(RVOpcodes::FRAME_ADDR);
@@ -1268,20 +1279,15 @@ void RISCv64ISel::selectNode(DAGNode* node) {
                 // 如果步长为0（例如对一个void类型或空结构体索引），则不产生任何偏移
                 if (stride != 0) {
                     // --- 为当前索引和步长生成偏移计算指令 ---
-                    auto offset_vreg = getNewVReg(Type::getIntType());
-                    
-                    // 处理索引 - 区分常量与动态值
-                    unsigned index_vreg;
+                    auto offset_vreg = getNewVReg();
+                    auto index_vreg = getVReg(indexValue);
+
+                    // 如果索引是常量，先用 LI 指令加载到虚拟寄存器
                     if (auto const_index = dynamic_cast<ConstantValue*>(indexValue)) {
-                        // 对于常量索引，直接创建新的虚拟寄存器
-                        index_vreg = getNewVReg(Type::getIntType());
                         auto li = std::make_unique<MachineInstr>(RVOpcodes::LI);
                         li->addOperand(std::make_unique<RegOperand>(index_vreg));
                         li->addOperand(std::make_unique<ImmOperand>(const_index->getInt()));
                         CurMBB->addInstruction(std::move(li));
-                    } else {
-                        // 对于动态索引，使用已存在的虚拟寄存器
-                        index_vreg = getVReg(indexValue);
                     }
                     
                     // 优化：如果步长是1，可以直接移动(MV)作为偏移量，无需乘法
@@ -1292,7 +1298,7 @@ void RISCv64ISel::selectNode(DAGNode* node) {
                         CurMBB->addInstruction(std::move(mv));
                     } else {
                         // 步长不为1，需要生成乘法指令
-                        auto size_vreg = getNewVReg(Type::getIntType());
+                        auto size_vreg = getNewVReg();
                         auto li_size = std::make_unique<MachineInstr>(RVOpcodes::LI);
                         li_size->addOperand(std::make_unique<RegOperand>(size_vreg));
                         li_size->addOperand(std::make_unique<ImmOperand>(stride));
@@ -1439,7 +1445,7 @@ std::vector<std::unique_ptr<RISCv64ISel::DAGNode>> RISCv64ISel::build_dag(BasicB
             
             // 依次添加所有索引作为后续的操作数
             for (auto index : gep->getIndices()) {
-                // 从 Use 对象中获取真正的 Value*
+                // [修复] 从 Use 对象中获取真正的 Value*
                 gep_node->operands.push_back(get_operand_node(index->getValue(), value_to_node, nodes_storage));
             }
         } else if (auto load = dynamic_cast<LoadInst*>(inst)) {
@@ -1467,7 +1473,7 @@ std::vector<std::unique_ptr<RISCv64ISel::DAGNode>> RISCv64ISel::build_dag(BasicB
                     }
                 }
             }
-            if (bin->isFPBinary()) { // 假设浮点指令枚举值更大
+            if (bin->getKind() >= Instruction::kFAdd) { // 假设浮点指令枚举值更大
                 auto fbin_node = create_node(DAGNode::FBINARY, bin, value_to_node, nodes_storage);
                 fbin_node->operands.push_back(get_operand_node(bin->getLhs(), value_to_node, nodes_storage));
                 fbin_node->operands.push_back(get_operand_node(bin->getRhs(), value_to_node, nodes_storage));
@@ -1543,7 +1549,7 @@ unsigned RISCv64ISel::getTypeSizeInBytes(Type* type) {
     }
 }
 
-// 打印DAG图以供调试的辅助函数
+// [新] 打印DAG图以供调试的辅助函数
 void RISCv64ISel::print_dag(const std::vector<std::unique_ptr<DAGNode>>& dag, const std::string& bb_name) {
     // 检查是否有DEBUG宏或者全局变量，避免在非调试模式下打印
     // if (!DEBUG) return; 
@@ -1639,8 +1645,4 @@ void RISCv64ISel::print_dag(const std::vector<std::unique_ptr<DAGNode>>& dag, co
     std::cerr << "======================================\n\n";
 }
 
-unsigned int RISCv64ISel::getVRegCounter() const {
-    return vreg_counter;
-}
-
 } // namespace sysy

src/backend/RISCv64/RISCv64LLIR.cpp

@@ -1,122 +1,6 @@
 #include "RISCv64LLIR.h"
 #include <vector>
-#include <iostream> // 用于 std::ostream 和 std::cerr
-#include <string>   // 用于 std::string
 
 namespace sysy {
 
-// 辅助函数：将 PhysicalReg 枚举转换为可读的字符串
-std::string regToString(PhysicalReg reg) {
-    switch (reg) {
-        case PhysicalReg::ZERO: return "x0";  case PhysicalReg::RA: return "ra";
-        case PhysicalReg::SP: return "sp";    case PhysicalReg::GP: return "gp";
-        case PhysicalReg::TP: return "tp";    case PhysicalReg::T0: return "t0";
-        case PhysicalReg::T1: return "t1";    case PhysicalReg::T2: return "t2";
-        case PhysicalReg::S0: return "s0";    case PhysicalReg::S1: return "s1";
-        case PhysicalReg::A0: return "a0";    case PhysicalReg::A1: return "a1";
-        case PhysicalReg::A2: return "a2";    case PhysicalReg::A3: return "a3";
-        case PhysicalReg::A4: return "a4";    case PhysicalReg::A5: return "a5";
-        case PhysicalReg::A6: return "a6";    case PhysicalReg::A7: return "a7";
-        case PhysicalReg::S2: return "s2";    case PhysicalReg::S3: return "s3";
-        case PhysicalReg::S4: return "s4";    case PhysicalReg::S5: return "s5";
-        case PhysicalReg::S6: return "s6";    case PhysicalReg::S7: return "s7";
-        case PhysicalReg::S8: return "s8";    case PhysicalReg::S9: return "s9";
-        case PhysicalReg::S10: return "s10";  case PhysicalReg::S11: return "s11";
-        case PhysicalReg::T3: return "t3";    case PhysicalReg::T4: return "t4";
-        case PhysicalReg::T5: return "t5";    case PhysicalReg::T6: return "t6";
-        case PhysicalReg::F0: return "f0";    case PhysicalReg::F1: return "f1";
-        case PhysicalReg::F2: return "f2";    case PhysicalReg::F3: return "f3";
-        case PhysicalReg::F4: return "f4";    case PhysicalReg::F5: return "f5";
-        case PhysicalReg::F6: return "f6";    case PhysicalReg::F7: return "f7";
-        case PhysicalReg::F8: return "f8";    case PhysicalReg::F9: return "f9";
-        case PhysicalReg::F10: return "f10";  case PhysicalReg::F11: return "f11";
-        case PhysicalReg::F12: return "f12";  case PhysicalReg::F13: return "f13";
-        case PhysicalReg::F14: return "f14";  case PhysicalReg::F15: return "f15";
-        case PhysicalReg::F16: return "f16";  case PhysicalReg::F17: return "f17";
-        case PhysicalReg::F18: return "f18";  case PhysicalReg::F19: return "f19";
-        case PhysicalReg::F20: return "f20";  case PhysicalReg::F21: return "f21";
-        case PhysicalReg::F22: return "f22";  case PhysicalReg::F23: return "f23";
-        case PhysicalReg::F24: return "f24";  case PhysicalReg::F25: return "f25";
-        case PhysicalReg::F26: return "f26";  case PhysicalReg::F27: return "f27";
-        case PhysicalReg::F28: return "f28";  case PhysicalReg::F29: return "f29";
-        case PhysicalReg::F30: return "f30";  case PhysicalReg::F31: return "f31";
-        default: return "UNKNOWN_REG";
-    }
-}
-
-// 打印栈帧信息的完整实现
-void MachineFunction::dumpStackFrameInfo(std::ostream& os) const {
-    const StackFrameInfo& info = frame_info;
-
-    os << "--- Stack Frame Info for function '" << getName() << "' ---\n";
-
-    // 打印尺寸信息
-    os << "  Sizes:\n";
-    os << "    Total Size:          " << info.total_size << " bytes\n";
-    os << "    Locals Size:         " << info.locals_size << " bytes\n";
-    os << "    Spill Size:          " << info.spill_size << " bytes\n";
-    os << "    Callee-Saved Size:   " << info.callee_saved_size << " bytes\n";
-    os << "\n";
-
-    // 打印 Alloca 变量的偏移量
-    os << "  Alloca Offsets (vreg -> offset from FP):\n";
-    if (info.alloca_offsets.empty()) {
-        os << "    (None)\n";
-    } else {
-        for (const auto& pair : info.alloca_offsets) {
-            os << "    %vreg" << pair.first << " -> " << pair.second << "\n";
-        }
-    }
-    os << "\n";
-
-    // 打印溢出变量的偏移量
-    os << "  Spill Offsets (vreg -> offset from FP):\n";
-    if (info.spill_offsets.empty()) {
-        os << "    (None)\n";
-    } else {
-        for (const auto& pair : info.spill_offsets) {
-            os << "    %vreg" << pair.first << " -> " << pair.second << "\n";
-        }
-    }
-    os << "\n";
-
-    // 打印使用的被调用者保存寄存器
-    os << "  Used Callee-Saved Registers:\n";
-    if (info.used_callee_saved_regs.empty()) {
-        os << "    (None)\n";
-    } else {
-        os << "    { ";
-        for (const auto& reg : info.used_callee_saved_regs) {
-            os << regToString(reg) << " ";
-        }
-        os << "}\n";
-    }
-    os << "\n";
-
-    // 打印需要保存/恢复的被调用者保存寄存器 (有序)
-    os << "  Callee-Saved Registers to Store/Restore:\n";
-    if (info.callee_saved_regs_to_store.empty()) {
-        os << "    (None)\n";
-    } else {
-        os << "    [ ";
-        for (const auto& reg : info.callee_saved_regs_to_store) {
-            os << regToString(reg) << " ";
-        }
-        os << "]\n";
-    }
-    os << "\n";
-
-    // 打印最终的寄存器分配结果
-    os << "  Final Register Allocation Map (vreg -> preg):\n";
-    if (info.vreg_to_preg_map.empty()) {
-        os << "    (None)\n";
-    } else {
-        for (const auto& pair : info.vreg_to_preg_map) {
-            os << "    %vreg" << pair.first << " -> " << regToString(pair.second) << "\n";
-        }
-    }
-
-    os << "---------------------------------------------------\n";
-}
-
-}
+}

src/backend/RISCv64/RISCv64LinearScan.cpp

@@ -1,517 +0,0 @@
-#include "RISCv64LinearScan.h"
-#include "RISCv64LLIR.h"
-#include "RISCv64ISel.h"
-#include <iostream>
-#include <set>
-
-extern int DEBUG;
-
-namespace sysy {
-
-RISCv64LinearScan::RISCv64LinearScan(MachineFunction* mfunc)
-    : MFunc(mfunc), 
-      ISel(mfunc->getISel()),
-      vreg_type_map(ISel->getVRegTypeMap()) {
-    
-    // 初始化可用的物理寄存器池，与图着色版本保持一致
-    // 整数寄存器
-    allocable_int_regs = {
-        PhysicalReg::T0, PhysicalReg::T1, PhysicalReg::T2, PhysicalReg::T3, PhysicalReg::T4, /*T5保留作为大立即数加载寄存器*/ PhysicalReg::T6,
-        PhysicalReg::A0, PhysicalReg::A1, PhysicalReg::A2, PhysicalReg::A3, PhysicalReg::A4, PhysicalReg::A5, PhysicalReg::A6, PhysicalReg::A7,
-        PhysicalReg::S1, PhysicalReg::S2, PhysicalReg::S3, PhysicalReg::S4, PhysicalReg::S5, PhysicalReg::S6, PhysicalReg::S7,
-        PhysicalReg::S8, PhysicalReg::S9, PhysicalReg::S10, PhysicalReg::S11,
-    };
-    // 浮点寄存器
-    allocable_fp_regs = {
-        PhysicalReg::F0, PhysicalReg::F1, PhysicalReg::F2, PhysicalReg::F3, PhysicalReg::F4, PhysicalReg::F5, PhysicalReg::F6, PhysicalReg::F7,
-        PhysicalReg::F10, PhysicalReg::F11, PhysicalReg::F12, PhysicalReg::F13, PhysicalReg::F14, PhysicalReg::F15, PhysicalReg::F16, PhysicalReg::F17,
-        PhysicalReg::F8, PhysicalReg::F9, PhysicalReg::F18, PhysicalReg::F19, PhysicalReg::F20, PhysicalReg::F21, PhysicalReg::F22,
-        PhysicalReg::F23, PhysicalReg::F24, PhysicalReg::F25, PhysicalReg::F26, PhysicalReg::F27,
-        PhysicalReg::F28, PhysicalReg::F29, PhysicalReg::F30, PhysicalReg::F31,
-    };
-    // 新增：识别所有通过寄存器传递的参数，并建立vreg到物理寄存器(preg)的映射
-    // 这等同于图着色算法中的“预着色”步骤。
-    if (MFunc->getFunc()) {
-        int int_arg_idx = 0;
-        int fp_arg_idx = 0;
-        for (Argument* arg : MFunc->getFunc()->getArguments()) {
-            unsigned arg_vreg = ISel->getVReg(arg);
-            if (arg->getType()->isFloat()) {
-                if (fp_arg_idx < 8) { // fa0-fa7
-                    auto preg = static_cast<PhysicalReg>(static_cast<int>(PhysicalReg::F10) + fp_arg_idx);
-                    abi_vreg_map[arg_vreg] = preg;
-                    fp_arg_idx++;
-                }
-            } else { // 整数或指针
-                if (int_arg_idx < 8) { // a0-a7
-                    auto preg = static_cast<PhysicalReg>(static_cast<int>(PhysicalReg::A0) + int_arg_idx);
-                    abi_vreg_map[arg_vreg] = preg;
-                    int_arg_idx++;
-                }
-            }
-        }
-    }
-}
-
-void RISCv64LinearScan::run() {
-    if (DEBUG) std::cerr << "===== Running Linear Scan Register Allocation for function: " << MFunc->getName() << " =====\n";
-    
-    bool changed = true;
-    while(changed) {
-        // 1. 准备阶段
-        linearizeBlocks();
-        computeLiveIntervals();
-        
-        // 2. 执行线性扫描
-        changed = linearScan();
-
-        // 3. 如果有溢出，重写代码，然后下一轮重新开始
-        if (changed) {
-            rewriteProgram();
-            if (DEBUG) std::cerr << "--- Spilling detected, re-running linear scan ---\n";
-        }
-    }
-
-    // 4. 将最终分配结果应用到机器指令
-    applyAllocation();
-    // 5. 收集用到的被调用者保存寄存器
-    MFunc->getFrameInfo().vreg_to_preg_map = this->vreg_to_preg_map;
-    collectUsedCalleeSavedRegs();
-
-    if (DEBUG) std::cerr << "===== Finished Linear Scan Register Allocation =====\n\n";
-}
-
-// 步骤 1.1: 对基本块进行线性化，这里我们简单地按现有顺序排列
-void RISCv64LinearScan::linearizeBlocks() {
-    linear_order_blocks.clear();
-    for (auto& mbb : MFunc->getBlocks()) {
-        linear_order_blocks.push_back(mbb.get());
-    }
-}
-
-// RISCv64LinearScan.cpp
-
-void RISCv64LinearScan::computeLiveIntervals() {
-    instr_numbering.clear();
-    live_intervals.clear();
-    unhandled.clear();
-
-    // a. 对所有指令进行线性编号，并记录CALL指令的位置
-    int num = 0;
-    std::set<int> call_locations;
-    for (auto* mbb : linear_order_blocks) {
-        for (auto& instr : mbb->getInstructions()) {
-            instr_numbering[instr.get()] = num;
-            if (instr->getOpcode() == RVOpcodes::CALL) {
-                call_locations.insert(num);
-            }
-            num += 2; // 指令编号间隔为2，方便在溢出重写时插入指令
-        }
-    }
-
-    // b. 遍历所有指令，记录每个vreg首次和末次出现的位置
-    std::map<unsigned, std::pair<int, int>> vreg_ranges; // vreg -> {first_instr_num, last_instr_num}
-
-    for (auto* mbb : linear_order_blocks) {
-        for (auto& instr_ptr : mbb->getInstructions()) {
-            const MachineInstr* instr = instr_ptr.get();
-            int instr_num = instr_numbering.at(instr);
-            std::set<unsigned> use, def;
-            getInstrUseDef(instr, use, def);
-            
-            auto all_vregs = use;
-            all_vregs.insert(def.begin(), def.end());
-
-            for (unsigned vreg : all_vregs) {
-                if (vreg_ranges.find(vreg) == vreg_ranges.end()) {
-                    vreg_ranges[vreg] = {instr_num, instr_num};
-                } else {
-                    vreg_ranges[vreg].second = std::max(vreg_ranges[vreg].second, instr_num);
-                }
-            }
-        }
-    }
-
-    // c. 根据记录的边界，创建LiveInterval对象，并检查是否跨越CALL
-    for (auto const& [vreg, range] : vreg_ranges) {
-        live_intervals.emplace(vreg, LiveInterval(vreg));
-        auto& interval = live_intervals.at(vreg);
-        interval.start = range.first;
-        interval.end = range.second;
-        
-        // 检查此区间是否跨越了任何CALL指令
-        auto it = call_locations.lower_bound(interval.start);
-        if (it != call_locations.end() && *it < interval.end) {
-            interval.crosses_call = true;
-        }
-    }
-
-    // d. 将所有计算出的活跃区间放入 unhandled 列表
-    for (auto& pair : live_intervals) {
-        unhandled.push_back(&pair.second);
-    }
-    std::sort(unhandled.begin(), unhandled.end(), [](const LiveInterval* a, const LiveInterval* b){
-        return a->start < b->start;
-    });
-}
-
-// RISCv64LinearScan.cpp
-
-// 在类的定义中添加一个辅助函数来判断寄存器类型
-bool isCalleeSaved(PhysicalReg preg) {
-    if (preg >= PhysicalReg::S1 && preg <= PhysicalReg::S11) return true;
-    if (preg == PhysicalReg::S0) return true; // s0 通常也作为被调用者保存
-    // 浮点寄存器
-    if (preg >= PhysicalReg::F8 && preg <= PhysicalReg::F9) return true;
-    if (preg >= PhysicalReg::F18 && preg <= PhysicalReg::F27) return true;
-    return false;
-}
-
-// 线性扫描主算法
-bool RISCv64LinearScan::linearScan() {
-    active.clear();
-    spilled_vregs.clear();
-    vreg_to_preg_map.clear();
-
-    // 将寄存器池分为调用者保存和被调用者保存两类
-    std::set<PhysicalReg> free_caller_int_regs, free_callee_int_regs;
-    std::set<PhysicalReg> free_caller_fp_regs, free_callee_fp_regs;
-
-    for (auto preg : allocable_int_regs) {
-        if (isCalleeSaved(preg)) free_callee_int_regs.insert(preg);
-        else free_caller_int_regs.insert(preg);
-    }
-    for (auto preg : allocable_fp_regs) {
-        if (isCalleeSaved(preg)) free_callee_fp_regs.insert(preg);
-        else free_caller_fp_regs.insert(preg);
-    }
-
-    // 预处理ABI参数寄存器
-    vreg_to_preg_map.insert(abi_vreg_map.begin(), abi_vreg_map.end());
-    std::vector<LiveInterval*> normal_unhandled;
-    for(LiveInterval* interval : unhandled) {
-        if(abi_vreg_map.count(interval->vreg)) {
-            active.push_back(interval);
-            PhysicalReg preg = abi_vreg_map.at(interval->vreg);
-            if (isFPVReg(interval->vreg)) {
-                if(isCalleeSaved(preg)) free_callee_fp_regs.erase(preg); else free_caller_fp_regs.erase(preg);
-            } else {
-                if(isCalleeSaved(preg)) free_callee_int_regs.erase(preg); else free_caller_int_regs.erase(preg);
-            }
-        } else {
-            normal_unhandled.push_back(interval);
-        }
-    }
-    unhandled = normal_unhandled;
-    std::sort(active.begin(), active.end(), [](const LiveInterval* a, const LiveInterval* b){ return a->end < b->end; });
-    
-    // 主循环
-    for (LiveInterval* current : unhandled) {
-        // a. 释放active列表中已结束的区间
-        std::vector<LiveInterval*> new_active;
-        for (LiveInterval* active_interval : active) {
-            if (active_interval->end < current->start) {
-                PhysicalReg preg = vreg_to_preg_map.at(active_interval->vreg);
-                if (isFPVReg(active_interval->vreg)) {
-                     if(isCalleeSaved(preg)) free_callee_fp_regs.insert(preg); else free_caller_fp_regs.insert(preg);
-                } else {
-                     if(isCalleeSaved(preg)) free_callee_int_regs.insert(preg); else free_caller_int_regs.insert(preg);
-                }
-            } else {
-                new_active.push_back(active_interval);
-            }
-        }
-        active = new_active;
-
-        // b. 约束化地为当前区间分配寄存器
-        bool is_fp = isFPVReg(current->vreg);
-        auto& free_caller = is_fp ? free_caller_fp_regs : free_caller_int_regs;
-        auto& free_callee = is_fp ? free_callee_fp_regs : free_callee_int_regs;
-
-        PhysicalReg allocated_preg = PhysicalReg::INVALID;
-
-        if (current->crosses_call) {
-            // 跨调用区间：必须使用被调用者保存寄存器
-            if (!free_callee.empty()) {
-                allocated_preg = *free_callee.begin();
-                free_callee.erase(allocated_preg);
-            }
-        } else {
-            // 非跨调用区间：优先使用调用者保存寄存器
-            if (!free_caller.empty()) {
-                allocated_preg = *free_caller.begin();
-                free_caller.erase(allocated_preg);
-            } else if (!free_callee.empty()) {
-                allocated_preg = *free_callee.begin();
-                free_callee.erase(allocated_preg);
-            }
-        }
-
-        if (allocated_preg != PhysicalReg::INVALID) {
-            vreg_to_preg_map[current->vreg] = allocated_preg;
-            active.push_back(current);
-            std::sort(active.begin(), active.end(), [](const LiveInterval* a, const LiveInterval* b){ return a->end < b->end; });
-        } else {
-            // c. 没有可用寄存器，需要溢出
-            spillAtInterval(current);
-        }
-    }
-    return !spilled_vregs.empty();
-}
-
-void RISCv64LinearScan::chooseRegForInterval(LiveInterval* current) {
-    bool is_fp = isFPVReg(current->vreg);
-    auto& free_regs = is_fp ? free_fp_regs : free_int_regs;
-    
-    if (!free_regs.empty()) {
-        // 有可用寄存器
-        PhysicalReg preg = *free_regs.begin();
-        free_regs.erase(free_regs.begin());
-        vreg_to_preg_map[current->vreg] = preg;
-        active.push_back(current);
-        // 保持 active 列表按结束点排序
-        std::sort(active.begin(), active.end(), [](const LiveInterval* a, const LiveInterval* b){
-            return a->end < b->end;
-        });
-    } else {
-        // 没有可用寄存器，需要溢出
-        spillAtInterval(current);
-    }
-}
-
-void RISCv64LinearScan::spillAtInterval(LiveInterval* current) {
-    LiveInterval* spill_candidate = nullptr;
-    // 启发式溢出：
-    // 如果current需要callee-saved，则从active中找一个占用callee-saved且结束最晚的区间比较
-    // 否则，找active中结束最晚的区间
-    // 这里简化处理：总是找active中结束最晚的区间
-    auto last_active = active.back();
-
-    if (last_active->end > current->end) {
-        // 溢出active中的区间
-        spill_candidate = last_active;
-        PhysicalReg preg = vreg_to_preg_map.at(spill_candidate->vreg);
-        vreg_to_preg_map[current->vreg] = preg; // 把换出的寄存器给current
-        // 更新active列表
-        active.pop_back();
-        active.push_back(current);
-        std::sort(active.begin(), active.end(), [](const LiveInterval* a, const LiveInterval* b){ return a->end < b->end; });
-        spilled_vregs.insert(spill_candidate->vreg);
-    } else {
-        // 溢出当前区间
-        spilled_vregs.insert(current->vreg);
-    }
-}
-
-// 步骤 3: 重写程序，插入溢出代码
-void RISCv64LinearScan::rewriteProgram() {
-    StackFrameInfo& frame_info = MFunc->getFrameInfo();
-    int spill_offset = frame_info.locals_size; // 溢出区域接在局部变量之后
-
-    for (unsigned vreg : spilled_vregs) {
-        if (frame_info.spill_offsets.count(vreg)) continue; // 避免重复分配
-        
-        int size = isFPVReg(vreg) ? 4 : (vreg_type_map.at(vreg)->isPointer() ? 8 : 4);
-        spill_offset += size;
-        spill_offset = (spill_offset + 7) & ~7; // 8字节对齐
-        frame_info.spill_offsets[vreg] = -(16 + spill_offset);
-    }
-    frame_info.spill_size = spill_offset - frame_info.locals_size;
-
-    for (auto& mbb : MFunc->getBlocks()) {
-        auto& instrs = mbb->getInstructions();
-        std::vector<std::unique_ptr<MachineInstr>> new_instrs;
-
-        for (auto it = instrs.begin(); it != instrs.end(); ++it) {
-            auto& instr = *it;
-            std::set<unsigned> use_vregs, def_vregs;
-            getInstrUseDef(instr.get(), use_vregs, def_vregs);
-
-            // 建立溢出vreg到新临时vreg的映射
-            std::map<unsigned, unsigned> use_remap;
-            std::map<unsigned, unsigned> def_remap;
-
-            // 1. 为所有溢出的USE创建LOAD指令和映射
-            for (unsigned old_vreg : use_vregs) {
-                if (spilled_vregs.count(old_vreg) && use_remap.find(old_vreg) == use_remap.end()) {
-                    Type* type = vreg_type_map.at(old_vreg);
-                    unsigned new_temp_vreg = ISel->getNewVReg(type);
-                    use_remap[old_vreg] = new_temp_vreg;
-
-                    RVOpcodes load_op = isFPVReg(old_vreg) ? RVOpcodes::FLW : (type->isPointer() ? RVOpcodes::LD : RVOpcodes::LW);
-                    auto load = std::make_unique<MachineInstr>(load_op);
-                    load->addOperand(std::make_unique<RegOperand>(new_temp_vreg));
-                    load->addOperand(std::make_unique<MemOperand>(
-                        std::make_unique<RegOperand>(PhysicalReg::S0),
-                        std::make_unique<ImmOperand>(frame_info.spill_offsets.at(old_vreg))
-                    ));
-                    new_instrs.push_back(std::move(load));
-                }
-            }
-
-            // 2. 为所有溢出的DEF创建映射
-            for (unsigned old_vreg : def_vregs) {
-                if (spilled_vregs.count(old_vreg) && def_remap.find(old_vreg) == def_remap.end()) {
-                    Type* type = vreg_type_map.at(old_vreg);
-                    unsigned new_temp_vreg = ISel->getNewVReg(type);
-                    def_remap[old_vreg] = new_temp_vreg;
-                }
-            }
-            
-            // 3. 基于角色精确地替换原指令中的操作数
-            auto opcode = instr->getOpcode();
-            auto& operands = instr->getOperands();
-
-            auto replace_reg_op = [](RegOperand* reg_op, const std::map<unsigned, unsigned>& remap) {
-                if (reg_op->isVirtual() && remap.count(reg_op->getVRegNum())) {
-                    reg_op->setVRegNum(remap.at(reg_op->getVRegNum()));
-                }
-            };
-            
-            if (op_info.count(opcode)) {
-                const auto& info = op_info.at(opcode);
-                // 替换 Defs
-                for (int idx : info.first) {
-                    if (idx < operands.size() && operands[idx]->getKind() == MachineOperand::KIND_REG) {
-                        replace_reg_op(static_cast<RegOperand*>(operands[idx].get()), def_remap);
-                    }
-                }
-                // 替换 Uses
-                for (int idx : info.second) {
-                     if (idx < operands.size()) {
-                        if (operands[idx]->getKind() == MachineOperand::KIND_REG) {
-                            replace_reg_op(static_cast<RegOperand*>(operands[idx].get()), use_remap);
-                        } else if (operands[idx]->getKind() == MachineOperand::KIND_MEM) {
-                            replace_reg_op(static_cast<MemOperand*>(operands[idx].get())->getBase(), use_remap);
-                        }
-                    }
-                }
-            } else if (opcode == RVOpcodes::CALL) {
-                // 特殊处理 CALL 指令
-                if (!operands.empty() && operands[0]->getKind() == MachineOperand::KIND_REG) {
-                    replace_reg_op(static_cast<RegOperand*>(operands[0].get()), def_remap);
-                }
-                for (size_t i = 1; i < operands.size(); ++i) {
-                    if (operands[i]->getKind() == MachineOperand::KIND_REG) {
-                        replace_reg_op(static_cast<RegOperand*>(operands[i].get()), use_remap);
-                    }
-                }
-            }
-
-            // 4. 将修改后的指令放入新列表
-            new_instrs.push_back(std::move(instr));
-
-            // 5. 为所有溢出的DEF创建STORE指令
-            for(const auto& pair : def_remap) {
-                unsigned old_vreg = pair.first;
-                unsigned new_temp_vreg = pair.second;
-                Type* type = vreg_type_map.at(old_vreg);
-                RVOpcodes store_op = isFPVReg(old_vreg) ? RVOpcodes::FSW : (type->isPointer() ? RVOpcodes::SD : RVOpcodes::SW);
-                auto store = std::make_unique<MachineInstr>(store_op);
-                store->addOperand(std::make_unique<RegOperand>(new_temp_vreg));
-                store->addOperand(std::make_unique<MemOperand>(
-                    std::make_unique<RegOperand>(PhysicalReg::S0),
-                    std::make_unique<ImmOperand>(frame_info.spill_offsets.at(old_vreg))
-                ));
-                new_instrs.push_back(std::move(store));
-            }
-        }
-        instrs = std::move(new_instrs);
-    }
-}
-
-
-// 步骤 4: 应用最终分配结果
-void RISCv64LinearScan::applyAllocation() {
-    for (auto& mbb : MFunc->getBlocks()) {
-        for (auto& instr_ptr : mbb->getInstructions()) {
-            for (auto& op_ptr : instr_ptr->getOperands()) {
-                if (op_ptr->getKind() == MachineOperand::KIND_REG) {
-                    auto reg_op = static_cast<RegOperand*>(op_ptr.get());
-                    if (reg_op->isVirtual()) {
-                        unsigned vreg = reg_op->getVRegNum();
-                        if (vreg_to_preg_map.count(vreg)) {
-                            reg_op->setPReg(vreg_to_preg_map.at(vreg));
-                        } else {
-                            // 如果一个vreg最终没有颜色，这通常意味着它是一个短生命周期的临时变量
-                            // 在溢出重写中产生，但在下一轮分配前就被优化掉了。
-                            // 或者是一个从未被使用的定义。
-                            // 给他一个临时寄存器以防万一。
-                            reg_op->setPReg(PhysicalReg::T5); 
-                        }
-                    }
-                } else if (op_ptr->getKind() == MachineOperand::KIND_MEM) {
-                    auto mem_op = static_cast<MemOperand*>(op_ptr.get());
-                    auto reg_op = mem_op->getBase();
-                    if (reg_op->isVirtual()) {
-                        unsigned vreg = reg_op->getVRegNum();
-                        if (vreg_to_preg_map.count(vreg)) {
-                            reg_op->setPReg(vreg_to_preg_map.at(vreg));
-                        } else {
-                            reg_op->setPReg(PhysicalReg::T5);
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-void RISCv64LinearScan::getInstrUseDef(const MachineInstr* instr, std::set<unsigned>& use, std::set<unsigned>& def) {
-    // 这个函数与图着色版本中的 getInstrUseDef 逻辑完全相同，此处直接复用
-    auto opcode = instr->getOpcode();
-    const auto& operands = instr->getOperands();
-
-    // op_info 的定义已被移到函数外部的命名空间中
-    
-    auto get_vreg_id_if_virtual = [&](const MachineOperand* op, std::set<unsigned>& s) {
-        if (op->getKind() == MachineOperand::KIND_REG) {
-            auto reg_op = static_cast<const RegOperand*>(op);
-            if (reg_op->isVirtual()) s.insert(reg_op->getVRegNum());
-        } else if (op->getKind() == MachineOperand::KIND_MEM) {
-            auto mem_op = static_cast<const MemOperand*>(op);
-            auto reg_op = mem_op->getBase();
-            if (reg_op->isVirtual()) s.insert(reg_op->getVRegNum());
-        }
-    };
-
-    if (op_info.count(opcode)) {
-        const auto& info = op_info.at(opcode);
-        for (int idx : info.first) if (idx < operands.size()) get_vreg_id_if_virtual(operands[idx].get(), def);
-        for (int idx : info.second) if (idx < operands.size()) get_vreg_id_if_virtual(operands[idx].get(), use);
-        // MemOperand 的基址寄存器总是一个 use
-        for (const auto& op : operands) if (op->getKind() == MachineOperand::KIND_MEM) get_vreg_id_if_virtual(op.get(), use);
-    } else if (opcode == RVOpcodes::CALL) {
-        // CALL指令的特殊处理
-        // 第一个操作数（如果有）是def（返回值）
-        if (!operands.empty() && operands[0]->getKind() == MachineOperand::KIND_REG) get_vreg_id_if_virtual(operands[0].get(), def);
-        // 后续的寄存器操作数是use（参数）
-        for (size_t i = 1; i < operands.size(); ++i) if (operands[i]->getKind() == MachineOperand::KIND_REG) get_vreg_id_if_virtual(operands[i].get(), use);
-    }
-}
-
-// 辅助函数: 判断是否为浮点vreg
-bool RISCv64LinearScan::isFPVReg(unsigned vreg) const {
-    return vreg_type_map.count(vreg) && vreg_type_map.at(vreg)->isFloat();
-}
-
-// 辅助函数: 收集被使用的被调用者保存寄存器
-void RISCv64LinearScan::collectUsedCalleeSavedRegs() {
-    StackFrameInfo& frame_info = MFunc->getFrameInfo();
-    frame_info.used_callee_saved_regs.clear();
-
-    const auto& callee_saved_int = getCalleeSavedIntRegs();
-    const auto& callee_saved_fp = getCalleeSavedFpRegs();
-    std::set<PhysicalReg> callee_saved_set(callee_saved_int.begin(), callee_saved_int.end());
-    callee_saved_set.insert(callee_saved_fp.begin(), callee_saved_fp.end());
-    callee_saved_set.insert(PhysicalReg::S0); // s0总是被用作帧指针
-
-    for(const auto& pair : vreg_to_preg_map) {
-        PhysicalReg preg = pair.second;
-        if(callee_saved_set.count(preg)) {
-            frame_info.used_callee_saved_regs.insert(preg);
-        }
-    }
-}
-
-} // namespace sysy

src/include/backend/RISCv64/Handler/EliminateFrameIndices.h

@@ -1,20 +0,0 @@
-#ifndef ELIMINATE_FRAME_INDICES_H
-#define ELIMINATE_FRAME_INDICES_H
-
-#include "RISCv64LLIR.h"
-
-namespace sysy {
-
-class EliminateFrameIndicesPass {
-public:
-    // Pass 的主入口函数
-    void runOnMachineFunction(MachineFunction* mfunc);
-
-private:
-    // 帮助计算类型大小的辅助函数，从原RegAlloc中移出
-    unsigned getTypeSizeInBytes(Type* type);
-};
-
-} // namespace sysy
-
-#endif // ELIMINATE_FRAME_INDICES_H

src/include/backend/RISCv64/Optimize/DivStrengthReduction.h

@@ -1,30 +0,0 @@
-#ifndef RISCV64_DIV_STRENGTH_REDUCTION_H
-#define RISCV64_DIV_STRENGTH_REDUCTION_H
-
-#include "RISCv64LLIR.h"
-#include "Pass.h"
-
-namespace sysy {
-
-/**
- * @class DivStrengthReduction
- * @brief 除法强度削弱优化器
- * * 将除法运算转换为乘法运算，使用magic number算法
- * 适用于除数为常数的情况，可以显著提高性能
- */
-class DivStrengthReduction : public Pass {
-public:
-    static char ID;
-    
-    DivStrengthReduction() : Pass("div-strength-reduction", Granularity::Function, PassKind::Optimization) {}
-    
-    void *getPassID() const override { return &ID; }
-    
-    bool runOnFunction(Function *F, AnalysisManager& AM) override;
-    
-    void runOnMachineFunction(MachineFunction* mfunc);
-};
-
-} // namespace sysy
-
-#endif // RISCV64_DIV_STRENGTH_REDUCTION_H

src/include/backend/RISCv64/RISCv64AsmPrinter.h

@@ -20,8 +20,6 @@ public:
     void setStream(std::ostream& os) { OS = &os; }
     // 辅助函数
     std::string regToString(PhysicalReg reg);
-    std::string formatInstr(const MachineInstr *instr);
-
 private:
     // 打印各个部分
     void printBasicBlock(MachineBasicBlock* mbb, bool debug = false);

src/include/backend/RISCv64/RISCv64Backend.h

@@ -22,9 +22,6 @@ private:
     // 函数级代码生成 (实现新的流水线)
     std::string function_gen(Function* func);
 
-    // 私有辅助函数，用于根据类型计算其占用的字节数。
-    unsigned getTypeSizeInBytes(Type* type);
-    
     Module* module;
 };
 

src/include/backend/RISCv64/RISCv64ISel.h

@@ -3,12 +3,6 @@
 
 #include "RISCv64LLIR.h"
 
-// Forward declarations
-namespace sysy {
-    class GlobalValue;
-    class Value;
-}
-
 extern int DEBUG;
 extern int DEEPDEBUG;
 
@@ -22,8 +16,8 @@ public:
 
     // 公开接口，以便后续模块（如RegAlloc）可以查询或创建vreg
     unsigned getVReg(Value* val);
-    unsigned getNewVReg(Type* type);
-    unsigned getVRegCounter() const; 
+    unsigned getNewVReg() { return vreg_counter++; }
+    unsigned getNewVReg(Type* type); 
     // 获取 vreg_map 的公共接口
     const std::map<Value*, unsigned>& getVRegMap() const { return vreg_map; }
     const std::map<unsigned, Value*>& getVRegValueMap() const { return vreg_to_value_map; }

src/include/backend/RISCv64/RISCv64LLIR.h

@@ -3,7 +3,6 @@
 
 #include "IR.h" // 确保包含了您自己的IR头文件
 #include <string>
-#include <iostream>
 #include <vector>
 #include <memory>
 #include <cstdint>
@@ -39,16 +38,14 @@ enum class PhysicalReg {
 
     // 用于内部表示物理寄存器在干扰图中的节点ID（一个简单的特殊ID，确保不与vreg_counter冲突）
     // 假设 vreg_counter 不会达到这么大的值
-    PHYS_REG_START_ID = 1000000, 
+    PHYS_REG_START_ID = 100000, 
     PHYS_REG_END_ID = PHYS_REG_START_ID + 320, // 预留足够的空间
-
-    INVALID, ///< 无效寄存器标记
 };
 
 // RISC-V 指令操作码枚举
 enum class RVOpcodes {
     // 算术指令
-    ADD, ADDI, ADDW, ADDIW, SUB, SUBW, MUL, MULW, MULH, DIV, DIVW, REM, REMW,
+    ADD, ADDI, ADDW, ADDIW, SUB, SUBW, MUL, MULW, DIV, DIVW, REM, REMW,
     // 逻辑指令
     XOR, XORI, OR, ORI, AND, ANDI,
     // 移位指令
@@ -88,7 +85,6 @@ enum class RVOpcodes {
     // 浮点转换
     FCVT_S_W, // fcvt.s.w rd, rs1 (有符号整数 -> 单精度浮点)
     FCVT_W_S, // fcvt.w.s rd, rs1 (单精度浮点 -> 有符号整数)
-    FCVT_W_S_RTZ, // fcvt.w.s rd, rs1, rtz (使用向零截断模式)
 
     // 浮点传送/移动
     FMV_S,    // fmv.s rd, rs1 (浮点寄存器之间)
@@ -199,11 +195,6 @@ public:
         preg = new_preg;
         is_virtual = false;
     }
-    
-    void setVRegNum(unsigned new_vreg_num) {
-        vreg_num = new_vreg_num;
-        is_virtual = true; // 确保设置vreg时，操作数状态正确
-    }
 private:
     unsigned vreg_num = 0;
     PhysicalReg preg = PhysicalReg::ZERO;
@@ -283,15 +274,14 @@ private:
 // 栈帧信息
 struct StackFrameInfo {
     int locals_size = 0; // 仅为AllocaInst分配的大小
-    int locals_end_offset = 0; // 记录局部变量分配结束后的偏移量(相对于s0，为负)
     int spill_size = 0; // 仅为溢出分配的大小
     int total_size = 0; // 总大小
     int callee_saved_size = 0; // 保存寄存器的大小
     std::map<unsigned, int> alloca_offsets; // <AllocaInst的vreg, 栈偏移>
     std::map<unsigned, int> spill_offsets;  // <溢出vreg, 栈偏移>
     std::set<PhysicalReg> used_callee_saved_regs; // 使用的保存寄存器
-    std::map<unsigned, PhysicalReg> vreg_to_preg_map; // RegAlloc最终的分配结果
-    std::vector<PhysicalReg> callee_saved_regs_to_store; // 已排序的、需要存取的被调用者保存寄存器
+    std::map<unsigned, PhysicalReg> vreg_to_preg_map;
+    std::vector<PhysicalReg> callee_saved_regs; // 用于存储需要保存的被调用者保存寄存器列表
 };
 
 // 机器函数
@@ -305,7 +295,7 @@ public:
     StackFrameInfo& getFrameInfo() { return frame_info; }
     const std::vector<std::unique_ptr<MachineBasicBlock>>& getBlocks() const { return blocks; }
     std::vector<std::unique_ptr<MachineBasicBlock>>& getBlocks() { return blocks; }
-    void dumpStackFrameInfo(std::ostream& os = std::cerr) const;
+
     void addBlock(std::unique_ptr<MachineBasicBlock> block) {
         blocks.push_back(std::move(block));
     }

src/include/backend/RISCv64/RISCv64LinearScan.h

@@ -1,104 +0,0 @@
-#ifndef RISCV64_LINEARSCAN_H
-#define RISCV64_LINEARSCAN_H
-
-#include "RISCv64LLIR.h"
-#include "RISCv64ISel.h"
-#include <vector>
-#include <map>
-#include <set>
-#include <algorithm>
-
-namespace sysy {
-
-// 前向声明
-class MachineBasicBlock;
-class MachineFunction;
-class RISCv64ISel;
-
-/**
- * @brief 表示一个虚拟寄存器的活跃区间。
- * 包含起始和结束指令编号。为了简化，我们不处理有“洞”的区间。
- */
-struct LiveInterval {
-    unsigned vreg = 0;
-    int start = -1;
-    int end = -1;
-    bool crosses_call = false;
-    
-    LiveInterval(unsigned vreg) : vreg(vreg) {}
-
-    // 用于排序，按起始点从小到大
-    bool operator<(const LiveInterval& other) const {
-        return start < other.start;
-    }
-};
-
-class RISCv64LinearScan {
-public:
-    RISCv64LinearScan(MachineFunction* mfunc);
-    void run();
-
-private:
-    // --- 核心算法流程 ---
-    void linearizeBlocks();
-    void computeLiveIntervals();
-    bool linearScan();
-    void rewriteProgram();
-    void applyAllocation();
-    void chooseRegForInterval(LiveInterval* current);
-    void spillAtInterval(LiveInterval* current);
-    
-    // --- 辅助函数 ---
-    void getInstrUseDef(const MachineInstr* instr, std::set<unsigned>& use, std::set<unsigned>& def);
-    bool isFPVReg(unsigned vreg) const;
-    void collectUsedCalleeSavedRegs();
-
-    MachineFunction* MFunc;
-    RISCv64ISel* ISel;
-
-    // --- 线性扫描数据结构 ---
-    std::vector<MachineBasicBlock*> linear_order_blocks;
-    std::map<const MachineInstr*, int> instr_numbering;
-    std::map<unsigned, LiveInterval> live_intervals;
-    
-    std::vector<LiveInterval*> unhandled;
-    std::vector<LiveInterval*> active; // 活跃且已分配物理寄存器的区间
-    
-    std::set<unsigned> spilled_vregs; // 记录在本轮被决定溢出的vreg
-
-    // --- 寄存器池和分配结果 ---
-    std::vector<PhysicalReg> allocable_int_regs;
-    std::vector<PhysicalReg> allocable_fp_regs;
-    std::set<PhysicalReg> free_int_regs;
-    std::set<PhysicalReg> free_fp_regs;
-    std::map<unsigned, PhysicalReg> vreg_to_preg_map;
-    std::map<unsigned, PhysicalReg> abi_vreg_map;
-    
-    const std::map<unsigned, Type*>& vreg_type_map;
-};
-
-static const std::map<RVOpcodes, std::pair<std::vector<int>, std::vector<int>>> op_info = {
-    {RVOpcodes::ADD, {{0}, {1, 2}}}, {RVOpcodes::SUB, {{0}, {1, 2}}}, {RVOpcodes::MUL, {{0}, {1, 2}}},
-    {RVOpcodes::DIV, {{0}, {1, 2}}}, {RVOpcodes::REM, {{0}, {1, 2}}}, {RVOpcodes::ADDW, {{0}, {1, 2}}},
-    {RVOpcodes::SUBW, {{0}, {1, 2}}}, {RVOpcodes::MULW, {{0}, {1, 2}}}, {RVOpcodes::DIVW, {{0}, {1, 2}}},
-    {RVOpcodes::REMW, {{0}, {1, 2}}}, {RVOpcodes::SLT, {{0}, {1, 2}}}, {RVOpcodes::SLTU, {{0}, {1, 2}}},
-    {RVOpcodes::ADDI, {{0}, {1}}}, {RVOpcodes::ADDIW, {{0}, {1}}}, {RVOpcodes::XORI, {{0}, {1}}},
-    {RVOpcodes::SLTI, {{0}, {1}}}, {RVOpcodes::SLTIU, {{0}, {1}}}, {RVOpcodes::LB, {{0}, {}}},
-    {RVOpcodes::LH, {{0}, {}}}, {RVOpcodes::LW, {{0}, {}}}, {RVOpcodes::LD, {{0}, {}}},
-    {RVOpcodes::LBU, {{0}, {}}}, {RVOpcodes::LHU, {{0}, {}}}, {RVOpcodes::LWU, {{0}, {}}},
-    {RVOpcodes::FLW, {{0}, {}}}, {RVOpcodes::FLD, {{0}, {}}}, {RVOpcodes::SB, {{}, {0, 1}}},
-    {RVOpcodes::SH, {{}, {0, 1}}}, {RVOpcodes::SW, {{}, {0, 1}}}, {RVOpcodes::SD, {{}, {0, 1}}},
-    {RVOpcodes::FSW, {{}, {0, 1}}}, {RVOpcodes::FSD, {{}, {0, 1}}}, {RVOpcodes::BEQ, {{}, {0, 1}}},
-    {RVOpcodes::BNE, {{}, {0, 1}}}, {RVOpcodes::BLT, {{}, {0, 1}}}, {RVOpcodes::BGE, {{}, {0, 1}}},
-    {RVOpcodes::JALR, {{0}, {1}}}, {RVOpcodes::LI, {{0}, {}}}, {RVOpcodes::LA, {{0}, {}}},
-    {RVOpcodes::MV, {{0}, {1}}}, {RVOpcodes::SEQZ, {{0}, {1}}}, {RVOpcodes::SNEZ, {{0}, {1}}},
-    {RVOpcodes::RET, {{}, {}}}, {RVOpcodes::FADD_S, {{0}, {1, 2}}}, {RVOpcodes::FSUB_S, {{0}, {1, 2}}},
-    {RVOpcodes::FMUL_S, {{0}, {1, 2}}}, {RVOpcodes::FDIV_S, {{0}, {1, 2}}}, {RVOpcodes::FEQ_S, {{0}, {1, 2}}},
-    {RVOpcodes::FLT_S, {{0}, {1, 2}}}, {RVOpcodes::FLE_S, {{0}, {1, 2}}}, {RVOpcodes::FCVT_S_W, {{0}, {1}}},
-    {RVOpcodes::FCVT_W_S, {{0}, {1}}}, {RVOpcodes::FMV_S, {{0}, {1}}}, {RVOpcodes::FMV_W_X, {{0}, {1}}},
-    {RVOpcodes::FMV_X_W, {{0}, {1}}}, {RVOpcodes::FNEG_S, {{0}, {1}}}
-};
-
-} // namespace sysy
-
-#endif // RISCV64_LINEARSCAN_H

src/include/backend/RISCv64/RISCv64Passes.h

@@ -8,10 +8,7 @@
 #include "CalleeSavedHandler.h"
 #include "LegalizeImmediates.h"
 #include "PrologueEpilogueInsertion.h"
-#include "EliminateFrameIndices.h"
 #include "Pass.h"
-#include "DivStrengthReduction.h"
-
 
 namespace sysy {
 

src/include/backend/RISCv64/RISCv64RegAlloc.h

@@ -3,15 +3,9 @@
 
 #include "RISCv64LLIR.h"
 #include "RISCv64ISel.h" // 包含 RISCv64ISel.h 以访问 ISel 和 Value 类型
-#include <set>
-#include <vector>
-#include <map>
-#include <stack>
 
 extern int DEBUG;
 extern int DEEPDEBUG;
-extern int DEBUGLENGTH; // 用于限制调试输出的长度
-extern int DEEPERDEBUG; // 用于更深层次的调试输出
 
 namespace sysy {
 
@@ -23,98 +17,58 @@ public:
     void run();
 
 private:
-    // 类型定义，与Python版本对应
-    using VRegSet = std::set<unsigned>;
-    using InterferenceGraph = std::map<unsigned, VRegSet>;
-    using VRegStack = std::vector<unsigned>; // 使用vector模拟栈，方便遍历
-    using MoveList = std::map<unsigned, std::set<const MachineInstr*>>;
-    using AliasMap = std::map<unsigned, unsigned>;
-    using ColorMap = std::map<unsigned, PhysicalReg>;
-    using VRegMoveSet = std::set<const MachineInstr*>;
+    using LiveSet = std::set<unsigned>; // 活跃虚拟寄存器集合
+    using InterferenceGraph = std::map<unsigned, std::set<unsigned>>;
 
-    // --- 核心算法流程 ---
-    void initialize();
-    void build();
-    void makeWorklist();
-    void simplify();
-    void coalesce();
-    void freeze();
-    void selectSpill();
-    void assignColors();
-    void rewriteProgram();
-    bool doAllocation();
-    void applyColoring();
-
-    void dumpState(const std::string &stage);
-
-    void precolorByCallingConvention();
-
-    // --- 辅助函数 ---
-    void getInstrUseDef(const MachineInstr* instr, VRegSet& use, VRegSet& def);
-    void getInstrUseDef_Liveness(const MachineInstr *instr, VRegSet &use, VRegSet &def);
-    void addEdge(unsigned u, unsigned v);
-    VRegSet adjacent(unsigned n);
-    VRegMoveSet nodeMoves(unsigned n);
-    bool moveRelated(unsigned n);
-    void decrementDegree(unsigned m);
-    void enableMoves(const VRegSet& nodes);
-    unsigned getAlias(unsigned n);
-    void addWorklist(unsigned u);
-    bool briggsHeuristic(unsigned u, unsigned v);
-    bool georgeHeuristic(unsigned u, unsigned v);
-    void combine(unsigned u, unsigned v);
-    void freezeMoves(unsigned u);
-    void collectUsedCalleeSavedRegs();
-    bool isFPVReg(unsigned vreg) const;
-    std::string regToString(PhysicalReg reg);
-    std::string regIdToString(unsigned id);
-
-    // --- 活跃性分析 ---
+    // 栈帧管理
+    void eliminateFrameIndices();
+    
+    // 活跃性分析
     void analyzeLiveness();
 
-    MachineFunction* MFunc;
-    RISCv64ISel* ISel;
+    // 构建干扰图
+    void buildInterferenceGraph();
 
-    // --- 算法数据结构 ---
-    // 寄存器池
+    // 图着色分配寄存器
+    void colorGraph();
+
+    // 重写函数，替换vreg并插入溢出代码
+    void rewriteFunction();
+    
+    // 辅助函数，获取指令的Use/Def集合
+    void getInstrUseDef(MachineInstr* instr, LiveSet& use, LiveSet& def);
+
+    // 辅助函数，处理调用约定
+    void handleCallingConvention();
+
+    MachineFunction* MFunc;
+    
+    // 活跃性分析结果
+    std::map<const MachineInstr*, LiveSet> live_in_map;
+    std::map<const MachineInstr*, LiveSet> live_out_map;
+
+    // 干扰图
+    InterferenceGraph interference_graph;
+
+    // 图着色结果
+    std::map<unsigned, PhysicalReg> color_map; // vreg -> preg
+    std::set<unsigned> spilled_vregs;         // 被溢出的vreg集合
+
+    // 可用的物理寄存器池
     std::vector<PhysicalReg> allocable_int_regs;
     std::vector<PhysicalReg> allocable_fp_regs;
-    int K_int; // 整数寄存器数量
-    int K_fp;  // 浮点寄存器数量
 
-    // 节点集合
-    VRegSet precolored; // 预着色的节点 (物理寄存器)
-    VRegSet initial;    // 初始的、所有待处理的虚拟寄存器节点
-    VRegSet simplifyWorklist;
-    VRegSet freezeWorklist;
-    VRegSet spillWorklist;
-    VRegSet spilledNodes;
-    VRegSet coalescedNodes;
-    VRegSet coloredNodes;
-    VRegStack selectStack;
-
-    // Move指令相关
-    std::set<const MachineInstr*> coalescedMoves;
-    std::set<const MachineInstr*> constrainedMoves;
-    std::set<const MachineInstr*> frozenMoves;
-    std::set<const MachineInstr*> worklistMoves;
-    std::set<const MachineInstr*> activeMoves;
-
-    // 数据结构
-    InterferenceGraph adjSet;
-    std::map<unsigned, VRegSet> adjList; // 邻接表
-    std::map<unsigned, int> degree;
-    MoveList moveList;
-    AliasMap alias;
-    ColorMap color_map;
-
-    // 活跃性分析结果
-    std::map<const MachineInstr*, VRegSet> live_in_map;
-    std::map<const MachineInstr*, VRegSet> live_out_map;
+    // 存储vreg到IR Value*的反向映射
+    // 这个map将在run()函数开始时被填充，并在rewriteFunction()中使用。
+    std::map<unsigned, Value*> vreg_to_value_map;
+    std::map<PhysicalReg, unsigned> preg_to_vreg_id_map; // 物理寄存器到特殊vreg ID的映射
+    
+    // 用于计算类型大小的辅助函数
+    unsigned getTypeSizeInBytes(Type* type);
+
+    // 辅助函数，用于打印集合
+    static void printLiveSet(const LiveSet& s, const std::string& name, std::ostream& os);
     
-    // VReg -> Value* 和 VReg -> Type* 的映射
-    const std::map<unsigned, Value*>& vreg_to_value_map;
-    const std::map<unsigned, Type*>& vreg_type_map;
 };
 
 } // namespace sysy

src/include/midend/IR.h

@@ -202,7 +202,6 @@ class Use {
 
  public:
   unsigned getIndex() const { return index; }   ///< 返回value在User操作数中的位置
-  void setIndex(int newIndex) { index = newIndex; }  ///< 设置value在User操作数中的位置
   User* getUser() const { return user; }       ///< 返回使用者
   Value* getValue() const { return value; }    ///< 返回被使用的值
   void setValue(Value *newValue) { value = newValue; }  ///< 将被使用的值设置为newValue
@@ -230,14 +229,7 @@ class Value {
   std::list<std::shared_ptr<Use>>& getUses() { return uses; }   ///< 获取使用关系列表
   void addUse(const std::shared_ptr<Use> &use) { uses.push_back(use); }  ///< 添加使用关系
   void replaceAllUsesWith(Value *value);  ///< 将原来使用该value的使用者全变为使用给定参数value并修改相应use关系
-  void removeUse(const std::shared_ptr<Use> &use) { 
-    assert(use != nullptr && "Use cannot be null");
-    assert(use->getValue() == this && "Use being removed does NOT point to this Value!");
-    auto it = std::find(uses.begin(), uses.end(), use);
-    assert(it != uses.end() && "Use not found in Value's uses");
-    uses.remove(use); 
-  }  ///< 删除使用关系use
-  void removeAllUses();
+  void removeUse(const std::shared_ptr<Use> &use) { uses.remove(use); }  ///< 删除使用关系use
 };
 
 /**
@@ -522,15 +514,12 @@ public:
   explicit BasicBlock(Function *parent, const std::string &name = "")
       : Value(Type::getLabelType(), name), parent(parent) {}
   ~BasicBlock() override {
-    // for (auto pre : predecessors) {
-    //   pre->removeSuccessor(this);
-    // }
-    // for (auto suc : successors) {
-    //   suc->removePredecessor(this);
-    // }
-    // 这些关系应该在 BasicBlock 被从 Function 中移除时，
-    // 由负责 CFG 优化的 Pass (例如 SCCP 的 RemoveDeadBlock) 显式地清理。
-    // 析构函数只负责清理 BasicBlock 自身拥有的资源（例如，指令列表）。
+    for (auto pre : predecessors) {
+      pre->removeSuccessor(this);
+    }
+    for (auto suc : successors) {
+      suc->removePredecessor(this);
+    }
   }
   
 public:
@@ -584,9 +573,7 @@ public:
     if (iter != predecessors.end()) {
       predecessors.erase(iter);
     } else {
-      // 如果没有找到前驱块，可能是因为它已经被移除或不存在
-      // 这可能是一个错误情况，或者是因为在CFG优化过程中已经处理
-      // assert(false && "Predecessor block not found in BasicBlock");
+      assert(false);
     }
   }
   void removeSuccessor(BasicBlock *block) {
@@ -594,9 +581,7 @@ public:
     if (iter != successors.end()) {
       successors.erase(iter);
     } else {
-      // 如果没有找到后继块，可能是因为它已经被移除或不存在
-      // 这可能是一个错误情况，或者是因为在CFG优化过程中已经处理
-      // assert(false && "Successor block not found in BasicBlock");
+      assert(false);
     }
   }
   void replacePredecessor(BasicBlock *oldBlock, BasicBlock *newBlock) {
@@ -614,7 +599,7 @@ public:
     prev->addSuccessor(next);
     next->addPredecessor(prev);
   }
-  iterator removeInst(iterator pos) { return instructions.erase(pos); }
+  void removeInst(iterator pos) { instructions.erase(pos); }
   void removeInst(Instruction *inst) {
     auto pos = std::find_if(instructions.begin(), instructions.end(),
                             [inst](const std::unique_ptr<Instruction> &i) { return i.get() == inst; });
@@ -650,7 +635,11 @@ class User : public Value {
     operands.emplace_back(std::make_shared<Use>(operands.size(), this, value));
     value->addUse(operands.back());
   }  ///< 增加操作数
-  void removeOperand(unsigned index);
+  void removeOperand(unsigned index) {
+    auto value = getOperand(index);
+    value->removeUse(operands[index]);
+    operands.erase(operands.begin() + index);
+  }  ///< 移除操作数
   template <typename ContainerT>
   void addOperands(const ContainerT &newoperands) {
     for (auto value : newoperands) {
@@ -706,19 +695,19 @@ class Instruction : public User {
     kCondBr = 0x1UL << 30,
     kBr = 0x1UL << 31,
     kReturn = 0x1UL << 32,
-    kUnreachable = 0x1UL << 33,
     // mem op
-    kAlloca = 0x1UL << 34,
-    kLoad = 0x1UL << 35,
-    kStore = 0x1UL << 36,
-    kGetElementPtr = 0x1UL << 37,
-    kMemset = 0x1UL << 38,
+    kAlloca = 0x1UL << 33,
+    kLoad = 0x1UL << 34,
+    kStore = 0x1UL << 35,
+    kGetElementPtr = 0x1UL << 36,
+    kMemset = 0x1UL << 37,
+    // kGetSubArray = 0x1UL << 38,
+    // Constant Kind removed as Constants are now Values, not Instructions.
+    // kConstant = 0x1UL << 37, // Conflicts with kMemset if kept as is
     // phi
     kPhi = 0x1UL << 39,
     kBitItoF = 0x1UL << 40,
     kBitFtoI = 0x1UL << 41,
-    kSRA = 0x1UL << 42,
-    kMulh = 0x1UL << 43
   };
 
 protected:
@@ -815,12 +804,6 @@ public:
         return "Memset";
       case kPhi:
         return "Phi";
-      case kBitItoF:
-        return "BitItoF";
-      case kBitFtoI:
-        return "BitFtoI";
-      case kSRA:
-        return "SRA";
       default:
         return "Unknown";
     }
@@ -832,15 +815,11 @@ public:
 
   bool isBinary() const {
     static constexpr uint64_t BinaryOpMask =
-        (kAdd | kSub | kMul | kDiv | kRem | kAnd | kOr | kSRA | kMulh) |
-        (kICmpEQ | kICmpNE | kICmpLT | kICmpGT | kICmpLE | kICmpGE);
-    return kind & BinaryOpMask;
-  }
-  bool isFPBinary() const {
-    static constexpr uint64_t FPBinaryOpMask =
+        (kAdd | kSub | kMul | kDiv | kRem | kAnd | kOr) |
+        (kICmpEQ | kICmpNE | kICmpLT | kICmpGT | kICmpLE | kICmpGE) |
         (kFAdd | kFSub | kFMul | kFDiv) |
         (kFCmpEQ | kFCmpNE | kFCmpLT | kFCmpGT | kFCmpLE | kFCmpGE);
-    return kind & FPBinaryOpMask;
+    return kind & BinaryOpMask;
   }
   bool isUnary() const {
     static constexpr uint64_t UnaryOpMask = 
@@ -853,7 +832,7 @@ public:
     return kind & MemoryOpMask;
   }
   bool isTerminator() const {
-    static constexpr uint64_t TerminatorOpMask = kCondBr | kBr | kReturn | kUnreachable;
+    static constexpr uint64_t TerminatorOpMask = kCondBr | kBr | kReturn;
     return kind & TerminatorOpMask;
   }
   bool isCmp() const {
@@ -873,7 +852,6 @@ public:
   }
   bool isUnconditional() const { return kind == kBr; }
   bool isConditional() const { return kind == kCondBr; }
-  bool isCondBr() const { return kind == kCondBr; }
   bool isPhi() const { return kind == kPhi; }
   bool isAlloca() const { return kind == kAlloca; }
   bool isLoad() const { return kind == kLoad; }
@@ -882,7 +860,6 @@ public:
   bool isMemset() const { return kind == kMemset; }
   bool isCall() const { return kind == kCall; }
   bool isReturn() const { return kind == kReturn; }
-  bool isUnreachable() const { return kind == kUnreachable; }
   bool isDefine() const {
     static constexpr uint64_t DefineOpMask = kAlloca | kStore | kPhi;
     return (kind & DefineOpMask) != 0U;
@@ -908,54 +885,37 @@ class PhiInst : public Instruction {
           const std::string &name = "")
       : Instruction(Kind::kPhi, type, parent, name), vsize(rhs.size()) {
     assert(rhs.size() == Blocks.size() && "PhiInst: rhs and Blocks must have the same size");
-    for(size_t i = 0; i < vsize; ++i) {
+    for(size_t i = 0; i < rhs.size(); ++i) {
       addOperand(rhs[i]);
-      addOperand(Blocks[i]);
       blk2val[Blocks[i]] = rhs[i];
     }
   }
 
  public:
+  Value* getValue(unsigned k) const {return getOperand(2 * k);}  ///< 获取位置为k的值
+  BasicBlock* getBlock(unsigned k) const {return dynamic_cast<BasicBlock*>(getOperand(2 * k + 1));}
+
+  auto& getincomings() const {return blk2val;}  ///< 获取所有的基本块和对应的值
+
+  Value* getvalfromBlk(BasicBlock* blk);
+  BasicBlock* getBlkfromVal(Value* val);
+
   unsigned getNumIncomingValues() const { return vsize; }  ///< 获取传入值的数量
-  Value *getIncomingValue(unsigned Idx) const { return getOperand(Idx * 2); }  ///< 获取指定位置的传入值
-  BasicBlock *getIncomingBlock(unsigned Idx) const {return dynamic_cast<BasicBlock *>(getOperand(Idx * 2 + 1)); }  ///< 获取指定位置的传入基本块
-
-  Value* getValfromBlk(BasicBlock* block);
-  BasicBlock* getBlkfromVal(Value* value);
-
   void addIncoming(Value *value, BasicBlock *block) {
-    assert(value && block && "PhiInst: value and block cannot be null");
+    assert(value && block && "PhiInst: value and block must not be null");
     addOperand(value);
     addOperand(block);
     blk2val[block] = value;
     vsize++;
   }  ///< 添加传入值和对应的基本块
-  void removeIncoming(unsigned Idx) {
-    assert(Idx < vsize && "PhiInst: Index out of bounds");
-    auto blk = getIncomingBlock(Idx);
-    removeOperand(Idx * 2 + 1);  // Remove block
-    removeOperand(Idx * 2);  // Remove value
-    blk2val.erase(blk);
-    vsize--;
-  }  ///< 移除指定位置的传入值和对应的基本块
-  // 移除指定的传入值或基本块
-  void removeIncomingValue(Value *value);
-  void removeIncomingBlock(BasicBlock *block);
-  // 设置指定位置的传入值或基本块
-  void setIncomingValue(unsigned Idx, Value *value);
-  void setIncomingBlock(unsigned Idx, BasicBlock *block);
-  // 替换指定位置的传入值或基本块（原理是删除再添加）保留旧块或者旧值
-  void replaceIncomingValue(Value *oldValue, Value *newValue);
-  void replaceIncomingBlock(BasicBlock *oldBlock, BasicBlock *newBlock);
-  // 替换指定位置的传入值或基本块（原理是删除再添加）
-  void replaceIncomingValue(Value *oldValue, Value *newValue, BasicBlock *newBlock);
-  void replaceIncomingBlock(BasicBlock *oldBlock, BasicBlock *newBlock, Value *newValue);
-  void refreshMap() {
-    blk2val.clear();
-    for (unsigned i = 0; i < vsize; ++i) {
-      blk2val[getIncomingBlock(i)] = getIncomingValue(i);
-    }
-  }  ///< 刷新块到值的映射关系
+
+  void delValue(Value* val);
+  void delBlk(BasicBlock* blk);
+
+  void replaceBlk(BasicBlock* newBlk, unsigned k);
+  void replaceold2new(BasicBlock* oldBlk, BasicBlock* newBlk);
+  void refreshB2VMap();
+
   auto getValues() { return make_range(std::next(operand_begin()), operand_end()); }
 };
 
@@ -1099,10 +1059,12 @@ class UncondBrInst : public Instruction {
   friend class Function;
 
 protected:
-  UncondBrInst(BasicBlock *block,
+  UncondBrInst(BasicBlock *block, std::vector<Value *> args,
                BasicBlock *parent = nullptr)
       : Instruction(kBr, Type::getVoidType(), parent, "") {
+    // assert(block->getNumArguments() == args.size());
     addOperand(block);
+    addOperands(args);
   }
 
 public:
@@ -1110,16 +1072,6 @@ public:
   auto getArguments() const {
     return make_range(std::next(operand_begin()), operand_end());
   }
-  std::vector<BasicBlock *> getSuccessors() const {
-    std::vector<BasicBlock *> succs;
-    // 假设无条件分支的目标块是它的第一个操作数
-    if (getNumOperands() > 0) {
-      if (auto target_bb = dynamic_cast<BasicBlock *>(getOperand(0))) {
-        succs.push_back(target_bb);
-      }
-    }
-    return succs;
-  }
 
 }; // class UncondBrInst
 
@@ -1131,12 +1083,17 @@ class CondBrInst : public Instruction {
   friend class Function;
   
 protected:
-  CondBrInst(Value *condition, BasicBlock *thenBlock, BasicBlock *elseBlock, 
-              BasicBlock *parent = nullptr)
+  CondBrInst(Value *condition, BasicBlock *thenBlock, BasicBlock *elseBlock,
+             const std::vector<Value *> &thenArgs,
+             const std::vector<Value *> &elseArgs, BasicBlock *parent = nullptr)
       : Instruction(kCondBr, Type::getVoidType(), parent, "") {
+    // assert(thenBlock->getNumArguments() == thenArgs.size() and
+    //        elseBlock->getNumArguments() == elseArgs.size());
     addOperand(condition);
     addOperand(thenBlock);
     addOperand(elseBlock);
+    addOperands(thenArgs);
+    addOperands(elseArgs);
   }
 public:
   Value* getCondition() const { return getOperand(0); }
@@ -1146,39 +1103,29 @@ public:
   BasicBlock* getElseBlock() const {
     return dynamic_cast<BasicBlock *>(getOperand(2));
   }
-  std::vector<BasicBlock *> getSuccessors() const {
-    std::vector<BasicBlock *> succs;
-    // 假设条件分支的真实块是第二个操作数，假块是第三个操作数
-    // 操作数通常是：[0] 条件值, [1] TrueTargetBlock, [2] FalseTargetBlock
-    if (getNumOperands() > 2) {
-      if (auto true_bb = getThenBlock()) {
-        succs.push_back(true_bb);
-      }
-      if (auto false_bb = getElseBlock()) {
-        succs.push_back(false_bb);
-      }
-    }
-    return succs;
-  }
+  // auto getThenArguments() const {
+  //   auto begin = std::next(operand_begin(), 3);
+  //   // auto end = std::next(begin, getThenBlock()->getNumArguments());
+  //   return make_range(begin, end);
+  // }
+  // auto getElseArguments() const {
+  //   auto begin =
+  //       std::next(operand_begin(), 3 + getThenBlock()->getNumArguments());
+  //   auto end = operand_end();
+  //   return make_range(begin, end);
+  // }
 
 }; // class CondBrInst
 
-class UnreachableInst : public Instruction {
-public:
-  // 构造函数：设置指令类型为 kUnreachable
-  explicit UnreachableInst(const std::string& name, BasicBlock *parent = nullptr)
-      : Instruction(kUnreachable, Type::getVoidType(), parent, "") {}
-
-};
-
 //! Allocate memory for stack variables, used for non-global variable declartion
 class AllocaInst : public Instruction {
   friend class IRBuilder;
   friend class Function;
 protected:
-  AllocaInst(Type *type,
+  AllocaInst(Type *type, const std::vector<Value *> &dims = {},
              BasicBlock *parent = nullptr, const std::string &name = "")
       : Instruction(kAlloca, type, parent, name) {
+    addOperands(dims);
   }
 
 public:
@@ -1186,6 +1133,9 @@ public:
   Type* getAllocatedType() const {
     return getType()->as<PointerType>()->getBaseType();
   }  ///< 获取分配的类型
+  int getNumDims() const { return getNumOperands(); }
+  auto getDims() const { return getOperands(); }
+  Value* getDim(int index) { return getOperand(index); }
 
 }; // class AllocaInst
 
@@ -1232,15 +1182,21 @@ class LoadInst : public Instruction {
   friend class Function;
 
 protected:
-  LoadInst(Value *pointer,
+  LoadInst(Value *pointer, const std::vector<Value *> &indices = {},
            BasicBlock *parent = nullptr, const std::string &name = "")
       : Instruction(kLoad, pointer->getType()->as<PointerType>()->getBaseType(),
                     parent, name) {
     addOperand(pointer);
+    addOperands(indices);
   }
 
 public:
+  int getNumIndices() const { return getNumOperands() - 1; }
   Value* getPointer() const { return getOperand(0); }
+  auto getIndices() const {
+    return make_range(std::next(operand_begin()), operand_end());
+  }
+  Value* getIndex(int index) const { return getOperand(index + 1); }
   
 }; // class LoadInst
 
@@ -1251,15 +1207,22 @@ class StoreInst : public Instruction {
 
 protected:
   StoreInst(Value *value, Value *pointer,
+            const std::vector<Value *> &indices = {},
             BasicBlock *parent = nullptr, const std::string &name = "")
       : Instruction(kStore, Type::getVoidType(), parent, name) {
     addOperand(value);
     addOperand(pointer);
+    addOperands(indices);
   }
 
 public:
+  int getNumIndices() const { return getNumOperands() - 2; }
   Value* getValue() const { return getOperand(0); }
   Value* getPointer() const { return getOperand(1); }
+  auto getIndices() const {
+    return make_range(std::next(operand_begin(), 2), operand_end());
+  }
+  Value* getIndex(int index) const { return getOperand(index + 2); }
 
 }; // class StoreInst
 
@@ -1398,18 +1361,20 @@ protected:
 
 protected:
   GlobalValue(Module *parent, Type *type, const std::string &name,
+              const std::vector<Value *> &dims = {}, 
               ValueCounter init = {})
       : Value(type, name), parent(parent) {
     assert(type->isPointer());
+    // addOperands(dims); 
     // 维度信息已经被记录到Type中，dim只是为了方便初始化
-    numDims = 0;
+    numDims = dims.size();
     if (init.size() == 0) {
       unsigned num = 1;
-      auto arrayType = type->as<ArrayType>();
-      while (arrayType) {
-        numDims++;
-        num *= arrayType->getNumElements();
-        arrayType = arrayType->getElementType()->as<ArrayType>();
+      for (unsigned i = 0; i < numDims; i++) {
+        // Assume dims elements are ConstantInteger and cast appropriately
+        auto dim_val = dynamic_cast<ConstantInteger*>(dims[i]);
+        assert(dim_val && "GlobalValue dims must be constant integers");
+        num *= dim_val->getInt();
       }
       if (dynamic_cast<PointerType *>(type)->getBaseType() == Type::getFloatType()) {
         init.push_back(ConstantFloating::get(0.0F), num); // Use new constant factory
@@ -1421,6 +1386,9 @@ protected:
   }
 
 public:
+  // unsigned getNumDims() const  { return numDims; }                     ///< 获取维度数量
+  // Value* getDim(unsigned index) const { return getOperand(index); }  ///< 获取位置为index的维度
+  // auto getDims() const { return getOperands(); }                              ///< 获取维度列表
   unsigned getNumIndices() const {
     return numDims;
   } ///< 获取维度数量
@@ -1462,19 +1430,13 @@ class ConstantVariable : public Value {
   ValueCounter initValues;  ///< 值
 
  protected:
-  ConstantVariable(Module *parent, Type *type, const std::string &name, const ValueCounter &init)
+  ConstantVariable(Module *parent, Type *type, const std::string &name, const ValueCounter &init,
+                   const std::vector<Value *> &dims = {})
       : Value(type, name), parent(parent) {
     assert(type->isPointer());
-    // numDims = dims.size();
-    numDims = 0;
-    if(type->as<PointerType>()->getBaseType()->isArray()) {
-      auto arrayType = type->as<ArrayType>();
-      while (arrayType) {
-        numDims++;
-        arrayType = arrayType->getElementType()->as<ArrayType>();
-      }
-    }
+    numDims = dims.size();
     initValues = init;
+    // addOperands(dims); 同GlobalValue，维度信息已经被记录到Type中，dim只是为了方便初始化
   }
 
  public:
@@ -1506,6 +1468,9 @@ class ConstantVariable : public Value {
 
     return getByIndex(index);
   }                                                        ///< 通过多维索引indices获取初始值
+  // unsigned getNumDims() const { return numDims; }  ///< 获取维度数量
+  // Value* getDim(unsigned index) const { return getOperand(index); }  ///< 获取位置为index的维度
+  // auto getDims() const { return getOperands(); }                              ///< 获取维度列表
   const ValueCounter& getInitValues() const { return initValues; }                           ///< 获取初始值
 };
 
@@ -1564,12 +1529,13 @@ class Module {
     return result.first->second.get();
   }  ///< 创建外部函数
   ///< 变量创建伴随着符号表的更新
-  GlobalValue* createGlobalValue(const std::string &name, Type *type, const ValueCounter &init = {}) {
+  GlobalValue* createGlobalValue(const std::string &name, Type *type, const std::vector<Value *> &dims = {},
+                         const ValueCounter &init = {}) {
     bool isFinished = variableTable.isCurNodeNull();
     if (isFinished) {
       variableTable.enterGlobalScope();
     }
-    auto result = variableTable.addVariable(name, new GlobalValue(this, type, name, init));
+    auto result = variableTable.addVariable(name, new GlobalValue(this, type, name, dims, init));
     if (isFinished) {
       variableTable.leaveScope();
     }
@@ -1578,8 +1544,9 @@ class Module {
     }
     return dynamic_cast<GlobalValue *>(result);
   }  ///< 创建全局变量
-  ConstantVariable* createConstVar(const std::string &name, Type *type, const ValueCounter &init) {
-    auto result = variableTable.addVariable(name, new ConstantVariable(this, type, name, init));
+  ConstantVariable* createConstVar(const std::string &name, Type *type, const ValueCounter &init,
+                      const std::vector<Value *> &dims = {}) {
+    auto result = variableTable.addVariable(name, new ConstantVariable(this, type, name, init, dims));
     if (result == nullptr) {
       return nullptr;
     }

src/include/midend/IRBuilder.h

@@ -217,12 +217,6 @@ class IRBuilder {
   BinaryInst * createOrInst(Value *lhs, Value *rhs, const std::string &name = "") {
     return createBinaryInst(Instruction::kOr, Type::getIntType(), lhs, rhs, name);
   }  ///< 创建按位或指令
-  BinaryInst * createSRAInst(Value *lhs, Value *rhs, const std::string &name = "") {
-    return createBinaryInst(Instruction::kSRA, Type::getIntType(), lhs, rhs, name);
-  }  ///< 创建算术右移指令
-  BinaryInst * createMulhInst(Value *lhs, Value *rhs, const std::string &name = "") {
-    return createBinaryInst(Instruction::kMulh, Type::getIntType(), lhs, rhs, name);
-  }  ///< 创建高位乘法指令
   CallInst * createCallInst(Function *callee, const std::vector<Value *> &args, const std::string &name = "") {
     std::string newName;
     if (name.empty() && callee->getReturnType() != Type::getVoidType()) {
@@ -245,30 +239,31 @@ class IRBuilder {
     block->getInstructions().emplace(position, inst);
     return inst;
   }  ///< 创建return指令
-  UncondBrInst * createUncondBrInst(BasicBlock *thenBlock) {
-    auto inst = new UncondBrInst(thenBlock, block);
+  UncondBrInst * createUncondBrInst(BasicBlock *thenBlock, const std::vector<Value *> &args) {
+    auto inst = new UncondBrInst(thenBlock, args, block);
     assert(inst);
     block->getInstructions().emplace(position, inst);
     return inst;
   }  ///< 创建无条件指令
-  CondBrInst * createCondBrInst(Value *condition, BasicBlock *thenBlock, BasicBlock *elseBlock) {
-    auto inst = new CondBrInst(condition, thenBlock, elseBlock, block);
+  CondBrInst * createCondBrInst(Value *condition, BasicBlock *thenBlock, BasicBlock *elseBlock,
+                        const std::vector<Value *> &thenArgs, const std::vector<Value *> &elseArgs) {
+    auto inst = new CondBrInst(condition, thenBlock, elseBlock, thenArgs, elseArgs, block);
     assert(inst);
     block->getInstructions().emplace(position, inst);
     return inst;
   }  ///< 创建条件跳转指令
-  UnreachableInst * createUnreachableInst(const std::string &name = "") {
-    auto inst = new UnreachableInst(name, block);
-    assert(inst);
-    block->getInstructions().emplace(position, inst);
-    return inst;
-  }  ///< 创建不可达指令
-  AllocaInst * createAllocaInst(Type *type, const std::string &name = "") {
-    auto inst = new AllocaInst(type, block, name);
+  AllocaInst * createAllocaInst(Type *type, const std::vector<Value *> &dims = {}, const std::string &name = "") {
+    auto inst = new AllocaInst(type, dims, block, name);
     assert(inst);
     block->getInstructions().emplace(position, inst);
     return inst;
   }  ///< 创建分配指令
+  AllocaInst * createAllocaInstWithoutInsert(Type *type, const std::vector<Value *> &dims = {}, BasicBlock *parent = nullptr,
+                                     const std::string &name = "") {
+    auto inst = new AllocaInst(type, dims, parent, name);
+    assert(inst);
+    return inst;
+  }  ///< 创建不插入指令列表的分配指令[仅用于phi指令]
   LoadInst * createLoadInst(Value *pointer, const std::vector<Value *> &indices = {}, const std::string &name = "") {
     std::string newName;
     if (name.empty()) {
@@ -280,7 +275,7 @@ class IRBuilder {
       newName = name;
     }
 
-    auto inst = new LoadInst(pointer, block, newName);
+    auto inst = new LoadInst(pointer, indices, block, newName);
     assert(inst);
     block->getInstructions().emplace(position, inst);
     return inst;
@@ -291,8 +286,9 @@ class IRBuilder {
     block->getInstructions().emplace(position, inst);
     return inst;
   }  ///< 创建memset指令
-  StoreInst * createStoreInst(Value *value, Value *pointer, const std::string &name = "") {
-    auto inst = new StoreInst(value, pointer, block, name);
+  StoreInst * createStoreInst(Value *value, Value *pointer, const std::vector<Value *> &indices = {},
+                       const std::string &name = "") {
+    auto inst = new StoreInst(value, pointer, indices, block, name);
     assert(inst);
     block->getInstructions().emplace(position, inst);
     return inst;
@@ -312,6 +308,24 @@ class IRBuilder {
     block->getInstructions().emplace(block->begin(), inst);
     return inst;
   }  ///< 创建Phi指令
+  // GetElementPtrInst* createGetElementPtrInst(Value *basePointer,
+  //                                const std::vector<Value *> &indices = {},
+  //                                const std::string &name = "") {
+  //   std::string newName;
+  //   if (name.empty()) {
+  //     std::stringstream ss;
+  //     ss << tmpIndex;
+  //     newName = ss.str();
+  //     tmpIndex++;
+  //   } else {
+  //     newName = name;
+  //   }
+
+  //   auto inst = new GetElementPtrInst(basePointer, indices, block, newName);
+  //   assert(inst);
+  //   block->getInstructions().emplace(position, inst);
+  //   return inst;
+  // }
   /**
      * @brief 根据 LLVM 设计模式创建 GEP 指令。
      * 它会自动推断返回类型，无需手动指定。

src/include/midend/Pass/Analysis/Dom.h

@@ -6,82 +6,30 @@
 #include <set>
 #include <vector>
 #include <algorithm>
-#include <functional>
 
 namespace sysy {
 
-// 支配树分析结果类
+// 支配树分析结果类 (保持不变)
 class DominatorTree : public AnalysisResultBase {
 public:
     DominatorTree(Function* F);
-    // 获取指定基本块的所有支配者
     const std::set<BasicBlock*>* getDominators(BasicBlock* BB) const;
-    // 获取指定基本块的即时支配者 (Immediate Dominator)
-    BasicBlock* getImmediateDominator(BasicBlock* BB) const;  
-    // 获取指定基本块的支配边界 (Dominance Frontier)
-    const std::set<BasicBlock*>* getDominanceFrontier(BasicBlock* BB) const;   
-    // 获取指定基本块在支配树中的子节点
+    BasicBlock* getImmediateDominator(BasicBlock* BB) const;
+    const std::set<BasicBlock*>* getDominanceFrontier(BasicBlock* BB) const;
     const std::set<BasicBlock*>* getDominatorTreeChildren(BasicBlock* BB) const;
-    // 额外的 Getter：获取所有支配者、即时支配者和支配边界的完整映射（可选，主要用于调试或特定场景）
     const std::map<BasicBlock*, std::set<BasicBlock*>>& getDominatorsMap() const { return Dominators; }
     const std::map<BasicBlock*, BasicBlock*>& getIDomsMap() const { return IDoms; }
     const std::map<BasicBlock*, std::set<BasicBlock*>>& getDominanceFrontiersMap() const { return DominanceFrontiers; }
-
-    // 计算所有基本块的支配者集合
     void computeDominators(Function* F);
-    // 计算所有基本块的即时支配者（内部使用 Lengauer-Tarjan 算法）
-    void computeIDoms(Function* F); 
-    // 计算所有基本块的支配边界
+    void computeIDoms(Function* F);
     void computeDominanceFrontiers(Function* F);
-    // 计算支配树的结构（即每个节点的直接子节点）
     void computeDominatorTreeChildren(Function* F);
 private:
-    // 与该支配树关联的函数
     Function* AssociatedFunction;
-    std::map<BasicBlock*, std::set<BasicBlock*>> Dominators;       // 每个基本块的支配者集合
-    std::map<BasicBlock*, BasicBlock*> IDoms;                      // 每个基本块的即时支配者
-    std::map<BasicBlock*, std::set<BasicBlock*>> DominanceFrontiers; // 每个基本块的支配边界
-    std::map<BasicBlock*, std::set<BasicBlock*>> DominatorTreeChildren; // 支配树中每个基本块的子节点
-
-    // ==========================================================
-    // Lengauer-Tarjan 算法内部所需的数据结构和辅助函数
-    // 这些成员是私有的，以封装 LT 算法的复杂性并避免命名空间污染
-    // ==========================================================
-
-    // DFS 遍历相关：
-    std::map<BasicBlock*, int> dfnum_map;            // 存储每个基本块的 DFS 编号
-    std::vector<BasicBlock*> vertex_vec;             // 通过 DFS 编号反向查找对应的基本块指针
-    std::map<BasicBlock*, BasicBlock*> parent_map;   // 存储 DFS 树中每个基本块的父节点
-    int df_counter;                                  // DFS 计数器，也代表 DFS 遍历的总节点数 (N)
-
-    // 半支配者 (Semi-dominator) 相关：
-    std::map<BasicBlock*, BasicBlock*> sdom_map;     // 存储每个基本块的半支配者
-    std::map<BasicBlock*, BasicBlock*> idom_map;     // 存储每个基本块的即时支配者 (IDom)
-    std::map<BasicBlock*, std::vector<BasicBlock*>> bucket_map; // 桶结构，用于存储具有相同半支配者的节点，以延迟 IDom 计算
-
-    // 并查集 (Union-Find) 相关（用于 evalAndCompress 函数）：
-    std::map<BasicBlock*, BasicBlock*> ancestor_map; // 并查集中的父节点（用于路径压缩）
-    std::map<BasicBlock*, BasicBlock*> label_map;    // 并查集中，每个集合的代表节点（或其路径上 sdom 最小的节点）
-
-    // ==========================================================
-    // 辅助计算函数 (私有)
-    // ==========================================================
-
-    // 计算基本块的逆后序遍历 (Reverse Post Order, RPO) 顺序
-    // RPO 用于优化支配者计算和 LT 算法的效率
-    std::vector<BasicBlock*> computeReversePostOrder(Function* F);
-
-    // Lengauer-Tarjan 算法特定的辅助 DFS 函数
-    // 用于初始化 dfnum_map, vertex_vec, parent_map
-    void dfs_lt_helper(BasicBlock* u);                 
-    
-    // 结合了并查集的 Find 操作和 LT 算法的 Eval 操作
-    // 用于在路径压缩时更新 label，找到路径上 sdom 最小的节点
-    BasicBlock* evalAndCompress_lt_helper(BasicBlock* i); 
-    
-    // 并查集的 Link 操作
-    // 将 v_child 挂载到 u_parent 的并查集树下
-    void link_lt_helper(BasicBlock* u_parent, BasicBlock* v_child); 
+    std::map<BasicBlock*, std::set<BasicBlock*>> Dominators;
+    std::map<BasicBlock*, BasicBlock*> IDoms;
+    std::map<BasicBlock*, std::set<BasicBlock*>> DominanceFrontiers;
+    std::map<BasicBlock*, std::set<BasicBlock*>> DominatorTreeChildren;
 };
 
 

src/include/midend/Pass/Optimize/BuildCFG.h

@@ -1,20 +0,0 @@
-#pragma once
-
-#include "IR.h"
-#include "Pass.h"
-#include <queue>
-#include <set>
-
-namespace sysy {
-
-class BuildCFG : public OptimizationPass {
-public:
-  static void *ID;
-  BuildCFG() : OptimizationPass("BuildCFG", Granularity::Function) {}
-  bool runOnFunction(Function *F, AnalysisManager &AM) override;
-  void getAnalysisUsage(std::set<void *> &analysisDependencies, std::set<void *> &analysisInvalidations) const override;
-  void *getPassID() const override { return &ID; }
-
-};
-
-} // namespace sysy

src/include/midend/Pass/Optimize/ConstPropagation.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Pass.h"
+
+namespace sysy {
+
+class ConstPropagation : public OptimizationPass {
+public:
+    ConstPropagation() : OptimizationPass("ConstPropagation", Granularity::Function) {}
+    bool runOnFunction(Function *F, AnalysisManager& AM) override;
+    static char ID;
+};
+
+} // namespace sysy

src/include/midend/Pass/Optimize/LargeArrayToGlobal.h

@@ -1,24 +0,0 @@
-#pragma once
-
-#include "../Pass.h"
-
-namespace sysy {
-
-class LargeArrayToGlobalPass : public OptimizationPass {
-public:
-    static void *ID;
-
-    LargeArrayToGlobalPass() : OptimizationPass("LargeArrayToGlobal", Granularity::Module) {}
-
-    bool runOnModule(Module *M, AnalysisManager &AM) override;
-    void *getPassID() const override {
-        return &ID;
-    }
-
-private:
-    unsigned calculateTypeSize(Type *type);
-    void convertAllocaToGlobal(AllocaInst *alloca, Function *F, Module *M);
-    std::string generateUniqueGlobalName(AllocaInst *alloca, Function *F);
-};
-
-} // namespace sysy

src/include/midend/Pass/Optimize/Mem2Reg.h

@@ -75,7 +75,11 @@ private:
     // --------------------------------------------------------------------
 
     // 对支配树进行深度优先遍历，重命名变量并替换 load/store 指令
-    void renameVariables(BasicBlock* currentBB);
+    // alloca: 当前正在处理的 AllocaInst
+    // currentBB: 当前正在遍历的基本块
+    // dt: 支配树分析结果
+    // valueStack: 存储当前 AllocaInst 在当前路径上可见的 SSA 值栈
+    void renameVariables(AllocaInst* alloca, BasicBlock* currentBB);
 
     // --------------------------------------------------------------------
     // 阶段4: 清理

src/include/midend/Pass/Optimize/SCCP.h

@@ -1,139 +1,196 @@
 #pragma once
 
 #include "IR.h"
-#include "Pass.h"
-#include "SysYIROptUtils.h"
-#include <cassert>
-#include <iostream>
-#include <map>
-#include <queue>
-#include <set>
-#include <unordered_set>
-#include <vector>
-#include <variant>
-#include <functional>
 
 namespace sysy {
 
-// 定义三值格 (Three-valued Lattice) 的状态
-enum class LatticeVal {
-  Top,      // ⊤ (未知 / 未初始化)
-  Constant, // c (常量)
-  Bottom    // ⊥ (不确定 / 变化 / 未定义)
+// 稀疏条件常量传播类
+// Sparse Conditional Constant Propagation
+/*
+伪代码
+function SCCP_Optimization(Module):
+    for each Function in Module:
+        changed = true
+        while changed:
+            changed = false
+            // 阶段1: 常量传播与折叠
+            changed |= PropagateConstants(Function)
+            // 阶段2: 控制流简化
+            changed |= SimplifyControlFlow(Function)
+        end while
+    end for
+
+function PropagateConstants(Function):
+    // 初始化
+    executableBlocks = {entryBlock}
+    valueState = map<Value, State> // 值->状态映射
+    instWorkList = Queue()
+    edgeWorkList = Queue()
+    
+    // 初始化工作列表
+    for each inst in entryBlock:
+        instWorkList.push(inst)
+    
+    // 迭代处理
+    while !instWorkList.empty() || !edgeWorkList.empty():
+        // 处理指令工作列表
+        while !instWorkList.empty():
+            inst = instWorkList.pop()
+            // 如果指令是可执行基本块中的
+            if executableBlocks.contains(inst.parent):
+                ProcessInstruction(inst)
+        
+        // 处理边工作列表
+        while !edgeWorkList.empty():
+            edge = edgeWorkList.pop()
+            ProcessEdge(edge)
+    
+    // 应用常量替换
+    for each inst in Function:
+        if valueState[inst] == CONSTANT:
+            ReplaceWithConstant(inst, valueState[inst].constant)
+            changed = true
+    
+    return changed
+
+function ProcessInstruction(Instruction inst):
+    switch inst.type:
+        //二元操作
+        case BINARY_OP:
+            lhs = GetValueState(inst.operands[0])
+            rhs = GetValueState(inst.operands[1])
+            if lhs == CONSTANT && rhs == CONSTANT:
+                newState = ComputeConstant(inst.op, lhs.value, rhs.value)
+                UpdateState(inst, newState)
+            else if lhs == BOTTOM || rhs == BOTTOM:
+                UpdateState(inst, BOTTOM)
+        //phi
+        case PHI:
+            mergedState = ⊤
+            for each incoming in inst.incomings:
+            // 检查每个输入的状态
+                if executableBlocks.contains(incoming.block):
+                    incomingState = GetValueState(incoming.value)
+                    mergedState = Meet(mergedState, incomingState)
+            UpdateState(inst, mergedState)
+        // 条件分支
+        case COND_BRANCH:
+            cond = GetValueState(inst.condition)
+            if cond == CONSTANT:
+                // 判断条件分支
+                if cond.value == true:
+                    AddEdgeToWorkList(inst.parent, inst.trueTarget)
+                else:
+                    AddEdgeToWorkList(inst.parent, inst.falseTarget)
+            else if cond == BOTTOM:
+                AddEdgeToWorkList(inst.parent, inst.trueTarget)
+                AddEdgeToWorkList(inst.parent, inst.falseTarget)
+        
+        case UNCOND_BRANCH:
+            AddEdgeToWorkList(inst.parent, inst.target)
+        
+        // 其他指令处理...
+
+function ProcessEdge(Edge edge):
+    fromBB, toBB = edge
+    if !executableBlocks.contains(toBB):
+        executableBlocks.add(toBB)
+        for each inst in toBB:
+            if inst is PHI:
+                instWorkList.push(inst)
+            else:
+                instWorkList.push(inst) // 非PHI指令
+    
+    // 更新PHI节点的输入
+    for each phi in toBB.phis:
+        instWorkList.push(phi)
+
+function SimplifyControlFlow(Function):
+    changed = false
+    // 标记可达基本块
+    ReachableBBs = FindReachableBlocks(Function.entry)
+    
+    // 删除不可达块
+    for each bb in Function.blocks:
+        if !ReachableBBs.contains(bb):
+            RemoveDeadBlock(bb)
+            changed = true
+    
+    // 简化条件分支
+    for each bb in Function.blocks:
+        terminator = bb.terminator
+        if terminator is COND_BRANCH:
+            cond = GetValueState(terminator.condition)
+            if cond == CONSTANT:
+                SimplifyBranch(terminator, cond.value)
+                changed = true
+    
+    return changed
+
+function RemoveDeadBlock(BasicBlock bb):
+    // 1. 更新前驱块的分支指令
+    for each pred in bb.predecessors:
+        UpdateTerminator(pred, bb)
+    
+    // 2. 更新后继块的PHI节点
+    for each succ in bb.successors:
+        RemovePhiIncoming(succ, bb)
+    
+    // 3. 删除块内所有指令
+    for each inst in bb.instructions:
+        inst.remove()
+    
+    // 4. 从函数中移除基本块
+    Function.removeBlock(bb)
+
+function Meet(State a, State b):
+    if a == ⊤: return b
+    if b == ⊤: return a
+    if a == ⊥ || b == ⊥: return ⊥
+    if a.value == b.value: return a
+    return ⊥
+
+function UpdateState(Value v, State newState):
+    oldState = valueState.get(v, ⊤)
+    if newState != oldState:
+        valueState[v] = newState
+        for each user in v.users:
+            if user is Instruction:
+                instWorkList.push(user)
+
+*/
+
+enum class LatticeValue {
+  Top,       // ⊤ (Unknown)
+  Constant,  // c (Constant)
+  Bottom     // ⊥ (Undefined / Varying)
 };
+// LatticeValue: 用于表示值的状态，Top表示未知，Constant表示常量，Bottom表示未定义或变化的值。
+// 这里的LatticeValue用于跟踪每个SSA值（变量、指令结果）的状态，
+// 以便在SCCP过程中进行常量传播和控制流简化。
 
-// 新增枚举来区分常量的实际类型
-enum class ValueType {
-  Integer,
-  Float,
-  Unknown // 用于 Top 和 Bottom 状态
-};
+//TODO: 下列数据结构考虑集成到类中，避免重命名问题
+static std::set<Instruction *> Worklist;
+static std::unordered_set<BasicBlock*> Executable_Blocks;
+static std::queue<std::pair<BasicBlock *, BasicBlock *> > Executable_Edges;
+static std::map<Value*, LatticeValue> valueState;
 
-// 用于表示 SSA 值的具体状态（包含格值和常量值）
-struct SSAPValue {
-  LatticeVal state;
-  std::variant<int, float> constantVal; // 使用 std::variant 存储 int 或 float
-  ValueType constant_type; // 记录常量是整数还是浮点数
-
-  // 默认构造函数，初始化为 Top
-  SSAPValue() : state(LatticeVal::Top), constantVal(0), constant_type(ValueType::Unknown) {}
-  // 构造函数，用于创建 Bottom 状态
-  SSAPValue(LatticeVal s) : state(s), constantVal(0), constant_type(ValueType::Unknown) {
-    assert((s == LatticeVal::Top || s == LatticeVal::Bottom) && "SSAPValue(LatticeVal) only for Top/Bottom");
-  }
-  // 构造函数，用于创建 int Constant 状态
-  SSAPValue(int c) : state(LatticeVal::Constant), constantVal(c), constant_type(ValueType::Integer) {}
-  // 构造函数，用于创建 float Constant 状态
-  SSAPValue(float c) : state(LatticeVal::Constant), constantVal(c), constant_type(ValueType::Float) {}
-
-  // 比较操作符，用于判断状态是否改变
-  bool operator==(const SSAPValue &other) const {
-    if (state != other.state)
-      return false;
-    if (state == LatticeVal::Constant) {
-        if (constant_type != other.constant_type) return false; // 类型必须匹配
-        return constantVal == other.constantVal; // std::variant 会比较内部值
-    }
-    return true; // Top == Top, Bottom == Bottom
-  }
-  bool operator!=(const SSAPValue &other) const { return !(*this == other); }
-};
-
-// SCCP 上下文类，持有每个函数运行时的状态
-class SCCPContext {
+class SCCP {
 private:
-  IRBuilder *builder; // IR 构建器，用于插入指令和创建常量
+  Module *pModule;
 
-  // 工作列表
-  // 存储需要重新评估的指令
-  std::queue<Instruction *> instWorkList;
-  // 存储需要重新评估的控制流边 (pair: from_block, to_block)
-  std::queue<std::pair<BasicBlock *, BasicBlock *>> edgeWorkList;
+public:
+  SCCP(Module *pMoudle) : pModule(pMoudle) {}
 
-  // 格值映射：SSA Value 到其当前状态
-  std::map<Value *, SSAPValue> valueState;
-  // 可执行基本块集合
-  std::unordered_set<BasicBlock *> executableBlocks;
-  // 追踪已访问的CFG边，防止重复添加，使用 SysYIROptUtils::PairHash
-  std::unordered_set<std::pair<BasicBlock*, BasicBlock*>, SysYIROptUtils::PairHash> visitedCFGEdges;
-
-  // 辅助函数：格操作 Meet
-  SSAPValue Meet(const SSAPValue &a, const SSAPValue &b);
-  // 辅助函数：获取值的当前状态，如果不存在则默认为 Top
-  SSAPValue GetValueState(Value *v);
-  // 辅助函数：更新值的状态，如果状态改变，将所有用户加入指令工作列表
-  void UpdateState(Value *v, SSAPValue newState);
-  // 辅助函数：将边加入边工作列表，并更新可执行块
-  void AddEdgeToWorkList(BasicBlock *fromBB, BasicBlock *toBB);
-  // 辅助函数：标记一个块为可执行
-  void MarkBlockExecutable(BasicBlock* block);
-
-  // 辅助函数：对二元操作进行常量折叠
-  SSAPValue ComputeConstant(BinaryInst *binaryinst, SSAPValue lhsVal, SSAPValue rhsVal);
-  // 辅助函数：对一元操作进行常量折叠
-  SSAPValue ComputeConstant(UnaryInst *unaryInst, SSAPValue operandVal);
-
-  // 主要优化阶段
-  // 阶段1: 常量传播与折叠
-  bool PropagateConstants(Function *func);
-  // 阶段2: 控制流简化
-  bool SimplifyControlFlow(Function *func);
-
-  // 辅助函数：处理单条指令
+  void run();
+  bool PropagateConstants(Function *function);
+  bool SimplifyControlFlow(Function *function);
   void ProcessInstruction(Instruction *inst);
-  // 辅助函数：处理单条控制流边
   void ProcessEdge(const std::pair<BasicBlock *, BasicBlock *> &edge);
-
-  // 控制流简化辅助函数
-  // 查找所有可达的基本块 (基于常量条件)
-  std::unordered_set<BasicBlock *> FindReachableBlocks(Function *func);
-  // 移除死块
-  void RemoveDeadBlock(BasicBlock *bb, Function *func);
-  // 简化分支（将条件分支替换为无条件分支）
-  void SimplifyBranch(CondBrInst*brInst, bool condVal); // 保持 BranchInst
-  // 更新前驱块的终结指令（当一个后继块被移除时）
-  void UpdateTerminator(BasicBlock *predBB, BasicBlock *removedSucc);
-  // 移除 Phi 节点的入边（当其前驱块被移除时）
-  void RemovePhiIncoming(BasicBlock *phiParentBB, BasicBlock *removedPred);
-
-public:
-  SCCPContext(IRBuilder *builder) : builder(builder) {}
-
-  // 运行 SCCP 优化
-  void run(Function *func, AnalysisManager &AM);
+  void RemoveDeadBlock(BasicBlock *bb);
+  void UpdateState(Value *v, LatticeValue newState);
+  LatticeValue Meet(LatticeValue a, LatticeValue b);
+  LatticeValue GetValueState(Value *v);
 };
 
-// SCCP 优化遍类，继承自 OptimizationPass
-class SCCP : public OptimizationPass {
-private:
-  IRBuilder *builder; // IR 构建器，作为 Pass 的成员，传入 Context
-
-public:
-  SCCP(IRBuilder *builder) : OptimizationPass("SCCP", Granularity::Function), builder(builder) {}
-  static void *ID;
-  bool runOnFunction(Function *F, AnalysisManager &AM) override;
-  void getAnalysisUsage(std::set<void *> &analysisDependencies, std::set<void *> &analysisInvalidations) const override;
-  void *getPassID() const override { return &ID; }
-};
-
-} // namespace sysy
+}  // namespace sysy

src/include/midend/Pass/Optimize/SysYIROptUtils.h

@@ -2,7 +2,6 @@
 
 #include "IR.h"
 
-extern int DEBUG;
 namespace sysy {
 
 // 优化工具类，包含一些通用的优化方法
@@ -11,80 +10,12 @@ namespace sysy {
 class SysYIROptUtils{
 
 public:
-  struct PairHash {
-      template <class T1, class T2>
-      std::size_t operator () (const std::pair<T1, T2>& p) const {
-          auto h1 = std::hash<T1>{}(p.first);
-          auto h2 = std::hash<T2>{}(p.second);
-
-          // 简单的组合哈希值，可以更复杂以减少冲突
-          // 使用 boost::hash_combine 的简化版本
-          return h1 ^ (h2 << 1); 
-      }
-  };
-
-  static void RemoveUserOperandUses(User *user) {
-    if (!user) {
-        return;
+  // 仅仅删除use关系
+  static void usedelete(Instruction *instr) {
+    for (auto &use : instr->getOperands()) {
+      Value* val = use->getValue();
+      val->removeUse(use);
     }
-
-    // 遍历 User 的 operands 列表。
-    // 由于 operands 是 protected 成员，我们需要一个临时方法来访问它，
-    // 或者在 User 类中添加一个 friend 声明。
-    // 假设 User 内部有一个像 getOperands() 这样的公共方法返回 operands 的引用，
-    // 或者将 SysYIROptUtils 声明为 User 的 friend。
-    // 为了示例，我将假设可以直接访问 user->operands 或通过一个getter。
-    // 如果无法直接访问，请在 IR.h 的 User 类中添加：
-    // public: const std::vector<std::shared_ptr<Use>>& getOperands() const { return operands; }
-
-    // 迭代 copies of shared_ptr to avoid issues if removeUse modifies the list
-    // (though remove should handle it, iterating a copy is safer or reverse iteration).
-    // Since we'll clear the vector at the end, iterating forward is fine.
-    for (const auto& use_ptr : user->getOperands()) { // 假设 getOperands() 可用
-        if (use_ptr) {
-            Value *val = use_ptr->getValue(); // 获取 Use 指向的 Value (如 AllocaInst)
-            if (val) {
-                val->removeUse(use_ptr); // 通知 Value 从其 uses 列表中移除此 Use 关系
-            }
-        }
-    }
-  }
-  static void usedelete(Instruction *inst) {
-    assert(inst && "Instruction to delete cannot be null.");
-    BasicBlock *parentBlock = inst->getParent();
-    assert(parentBlock && "Instruction must have a parent BasicBlock to be deleted.");
-
-    // 步骤1: 处理所有使用者，将他们从使用 inst 变为使用 UndefinedValue
-    // 这将清理 inst 作为 Value 时的 uses 列表
-    if (!inst->getUses().empty()) {
-        inst->replaceAllUsesWith(UndefinedValue::get(inst->getType()));
-    }
-
-    // 步骤2: 清理 inst 作为 User 时的操作数关系
-    // 通知 inst 所使用的所有 Value (如 AllocaInst)，移除对应的 Use 关系。
-    // 这里的 inst 实际上是一个 User*，所以可以安全地向下转型。
-    RemoveUserOperandUses(static_cast<User*>(inst));
-
-    // 步骤3: 物理删除指令
-    // 这会导致 Instruction 对象的 unique_ptr 销毁，从而调用其析构函数链。
-    parentBlock->removeInst(inst);
-} 
-
-  static BasicBlock::iterator usedelete(BasicBlock::iterator inst_it) {
-    Instruction *inst_to_delete = inst_it->get();
-    BasicBlock *parentBlock = inst_to_delete->getParent();
-    assert(parentBlock && "Instruction must have a parent BasicBlock for iterator deletion.");
-
-    // 步骤1: 处理所有使用者
-    if (!inst_to_delete->getUses().empty()) {
-        inst_to_delete->replaceAllUsesWith(UndefinedValue::get(inst_to_delete->getType()));
-    }
-
-    // 步骤2: 清理操作数关系
-    RemoveUserOperandUses(static_cast<User*>(inst_to_delete));
-
-    // 步骤3: 物理删除指令并返回下一个迭代器
-    return parentBlock->removeInst(inst_it);
   }
 
   // 判断是否是全局变量
@@ -95,17 +26,7 @@ public:
   // 判断是否是数组
   static bool isArr(Value *val) {
     auto aval = dynamic_cast<AllocaInst *>(val);
-    // 如果是 AllocaInst 且通过Type::isArray()判断为数组类型
-    return aval && aval->getType()->as<PointerType>()->getBaseType()->isArray();
-  }
-  // 判断是否是指向数组的指针
-  static bool isArrPointer(Value *val) {
-    auto aval = dynamic_cast<AllocaInst *>(val);
-    // 如果是 AllocaInst 且通过Type::isPointer()判断为指针;
-    auto baseType = aval->getType()->as<PointerType>()->getBaseType();
-    // 在sysy中，函数的数组参数会退化成指针
-    // 所以当AllocaInst的basetype是PointerType时（一维数组）或者是指向ArrayType的PointerType（多位数组）时，返回true
-    return aval && (baseType->isPointer() || baseType->as<PointerType>()->getBaseType()->isArray());
+  return aval != nullptr && aval->getNumDims() != 0;
   }
 };
 

src/include/midend/Pass/Pass.h

@@ -279,7 +279,7 @@ private:
   IRBuilder *pBuilder;
 
 public:
-  PassManager() = delete;
+  PassManager() = default;
   ~PassManager() = default;
 
   PassManager(Module *module, IRBuilder *builder) : pmodule(module) ,pBuilder(builder), analysisManager(module) {}

src/include/midend/SysYIRGenerator.h

@@ -86,60 +86,7 @@ private:
     case LPAREN: case RPAREN: return 0; // Parentheses have lowest precedence for stack logic
     default: return -1; // Unknown operator
     }
-  };
-
-  struct ExpKey {
-    BinaryOp op;  ///< 操作符
-    Value *left;  ///< 左操作数
-    Value *right; ///< 右操作数
-    ExpKey(BinaryOp op, Value *left, Value *right) : op(op), left(left), right(right) {}
-
-    bool operator<(const ExpKey &other) const {
-      if (op != other.op)
-        return op < other.op; ///< 比较操作符
-      if (left != other.left)
-        return left < other.left; ///< 比较左操作
-      return right < other.right; ///< 比较右操作数
-    } ///< 重载小于运算符用于比较ExpKey
-  };
-
-  struct UnExpKey {
-    BinaryOp op;    ///< 一元操作符
-    Value *operand; ///< 操作数
-    UnExpKey(BinaryOp op, Value *operand) : op(op), operand(operand) {}
-
-    bool operator<(const UnExpKey &other) const {
-      if (op != other.op)
-        return op < other.op;         ///< 比较操作符
-      return operand < other.operand; ///< 比较操作数
-    } ///< 重载小于运算符用于比较UnExpKey
-  };
-
-  struct GEPKey {
-    Value *basePointer;
-    std::vector<Value *> indices;
-
-    // 为 std::map 定义比较运算符，使得 GEPKey 可以作为键
-    bool operator<(const GEPKey &other) const {
-      if (basePointer != other.basePointer) {
-        return basePointer < other.basePointer;
-      }
-      // 逐个比较索引，确保顺序一致
-      if (indices.size() != other.indices.size()) {
-        return indices.size() < other.indices.size();
-      }
-      for (size_t i = 0; i < indices.size(); ++i) {
-        if (indices[i] != other.indices[i]) {
-          return indices[i] < other.indices[i];
-        }
-      }
-      return false; // 如果 basePointer 和所有索引都相同，则认为相等
-    }
-  };
-  std::map<GEPKey, Value*> availableGEPs; ///< 用于存储 GEP 的缓存
-  std::map<ExpKey, Value*> availableBinaryExpressions;
-  std::map<UnExpKey, Value*> availableUnaryExpressions;
-  std::map<Value*, Value*> availableLoads;
+  }
 
 public:
   SysYIRGenerator() = default;
@@ -220,15 +167,6 @@ public:
   Value* computeExp(SysYParser::ExpContext *ctx, Type* targetType = nullptr);
   Value* computeAddExp(SysYParser::AddExpContext *ctx, Type* targetType = nullptr);
   void compute();
-
-  // 参数是发生 store 操作的目标地址/变量的 Value*
-  void invalidateExpressionsOnStore(Value* storedAddress);
-
-  // 清除因函数调用而失效的表达式缓存（保守策略）
-  void invalidateExpressionsOnCall();
-
-  // 在进入新的基本块时清空所有表达式缓存
-  void enterNewBasicBlock();
 public:
   // 获取GEP指令的地址
   Value* getGEPAddressInst(Value* basePointer, const std::vector<Value*>& indices);

src/midend/CMakeLists.txt

@@ -10,9 +10,7 @@ add_library(midend_lib STATIC
     Pass/Optimize/Mem2Reg.cpp
     Pass/Optimize/Reg2Mem.cpp
     Pass/Optimize/SysYIRCFGOpt.cpp
-    Pass/Optimize/SCCP.cpp
-    Pass/Optimize/BuildCFG.cpp
-    Pass/Optimize/LargeArrayToGlobal.cpp
+    Pass/Optimize/ConstPropagation.cpp
 )
 
 # 包含中端模块所需的头文件路径

src/midend/IR.cpp

@@ -118,46 +118,14 @@ ArrayType *ArrayType::get(Type *elementType, unsigned numElements) {
   return result.first->get();
 }
 
-// void Value::replaceAllUsesWith(Value *value) {
-//   for (auto &use : uses) {
-//     auto user = use->getUser();
-//     assert(user && "Use's user cannot be null");
-//     user->setOperand(use->getIndex(), value);
-//   }
-//   uses.clear();
-// }
 void Value::replaceAllUsesWith(Value *value) {
-  // 1. 创建 uses 列表的副本进行迭代。
-  //    这样做是为了避免在迭代过程中，由于 setOperand 间接调用 removeUse 或 addUse
-  //    导致原列表被修改，从而引发迭代器失效问题。
-  std::list<std::shared_ptr<Use>> uses_copy = uses; 
-
-  for (auto &use_ptr : uses_copy) { // 遍历副本
-    // 2. 检查 shared_ptr<Use> 本身是否为空。这是最常见的崩溃原因之一。
-    if (use_ptr == nullptr) {
-      std::cerr << "Warning: Encountered a null std::shared_ptr<Use> in Value::uses list. Skipping this entry." << std::endl;
-      // 在一个健康的 IR 中，这种情况不应该发生。如果经常出现，说明你的 Use 创建或管理有问题。
-      continue; // 跳过空的智能指针
-    }
-    
-    // 3. 检查 Use 对象内部的 User* 是否为空。
-    User* user_val = use_ptr->getUser(); 
-    if (user_val == nullptr) {
-      std::cerr << "Warning: Use object (" << use_ptr.get() << ") has a null User* in replaceAllUsesWith. Skipping this entry. This indicates IR corruption." << std::endl;
-      // 同样，在一个健康的 IR 中，Use 对象的 User* 不应该为空。
-      continue; // 跳过用户指针为空的 Use 对象
-    }
-    
-    // 如果走到这里，use_ptr 和 user_val 都是有效的，可以安全调用 setOperand
-    user_val->setOperand(use_ptr->getIndex(), value);
+  for (auto &use : uses) {
+    use->getUser()->setOperand(use->getIndex(), value);
   }
-
-  // 4. 处理完所有 use 之后，清空原始的 uses 列表。
-  //    replaceAllUsesWith 的目的就是将所有使用关系从当前 Value 转移走，
-  //    所以最后清空列表是正确的。
-  uses.clear(); 
+  uses.clear();
 }
 
+
 // Implementations for static members
 
 std::unordered_map<ConstantValueKey, ConstantValue*, ConstantValueHash, ConstantValueEqual> ConstantValue::mConstantPool;
@@ -214,45 +182,373 @@ auto Function::getCalleesWithNoExternalAndSelf() -> std::set<Function *> {
   }
   return result;
 }
+// 函数克隆，后续函数级优化（内联等）需要用到
+Function * Function::clone(const std::string &suffix) const  {
+  std::stringstream ss;
+  std::map<BasicBlock *, BasicBlock *> oldNewBlockMap;
+  IRBuilder builder;
+  auto newFunction = new Function(parent, type, name);
+  newFunction->getEntryBlock()->setName(blocks.front()->getName());
+  oldNewBlockMap.emplace(blocks.front().get(), newFunction->getEntryBlock());
+  auto oldBlockListIter = std::next(blocks.begin());
+  while (oldBlockListIter != blocks.end()) {
+    auto newBlock = newFunction->addBasicBlock(oldBlockListIter->get()->getName());
+    oldNewBlockMap.emplace(oldBlockListIter->get(), newBlock);
+    oldBlockListIter++;
+  }
 
-void Value::removeAllUses() {
-  while (!uses.empty()) {
-    auto use = uses.back();
-    uses.pop_back();
-    if (use && use->getUser()) {
-      auto user = use->getUser();
-      int index = use->getIndex();
-      user->removeOperand(index); ///< 从User中移除该操作数
-    } else {
-      // 如果use或user为null，输出警告信息
-      assert(use != nullptr && "Use cannot be null");
-      assert(use->getUser() != nullptr && "Use's user cannot be null");
+  for (const auto &oldNewBlockItem : oldNewBlockMap) {
+    auto oldBlock = oldNewBlockItem.first;
+    auto newBlock = oldNewBlockItem.second;
+    for (const auto &oldPred : oldBlock->getPredecessors()) {
+      newBlock->addPredecessor(oldNewBlockMap.at(oldPred));
+    }
+    for (const auto &oldSucc : oldBlock->getSuccessors()) {
+      newBlock->addSuccessor(oldNewBlockMap.at(oldSucc));
     }
   }
-  uses.clear();
-}
 
+  std::map<Value *, Value *> oldNewValueMap;
+  std::map<Value *, bool> isAddedToCreate;
+  std::map<Value *, bool> isCreated;
+  std::queue<Value *> toCreate;
+
+  for (const auto &oldBlock : blocks) {
+    for (const auto &inst : oldBlock->getInstructions()) {
+      isAddedToCreate.emplace(inst.get(), false);
+      isCreated.emplace(inst.get(), false);
+    }
+  }
+  for (const auto &oldBlock : blocks) {
+    for (const auto &inst : oldBlock->getInstructions()) {
+      for (const auto &valueUse : inst->getOperands()) {
+        auto value = valueUse->getValue();
+        if (oldNewValueMap.find(value) == oldNewValueMap.end()) {
+          auto oldAllocInst = dynamic_cast<AllocaInst *>(value);
+          if (oldAllocInst != nullptr) {
+            std::vector<Value *> dims;
+            for (const auto &dim : oldAllocInst->getDims()) {
+              dims.emplace_back(dim->getValue());
+            }
+            ss << oldAllocInst->getName() << suffix;
+            auto newAllocInst =
+                new AllocaInst(oldAllocInst->getType(), dims, oldNewBlockMap.at(oldAllocInst->getParent()), ss.str());
+            ss.str("");
+            oldNewValueMap.emplace(oldAllocInst, newAllocInst);
+            if (isAddedToCreate.find(oldAllocInst) == isAddedToCreate.end()) {
+              isAddedToCreate.emplace(oldAllocInst, true);
+            } else {
+              isAddedToCreate.at(oldAllocInst) = true;
+            }
+            if (isCreated.find(oldAllocInst) == isCreated.end()) {
+              isCreated.emplace(oldAllocInst, true);
+            } else {
+              isCreated.at(oldAllocInst) = true;
+            }
+          }
+        }
+      }
+      if (inst->getKind() == Instruction::kAlloca) {
+        if (oldNewValueMap.find(inst.get()) == oldNewValueMap.end()) {
+          auto oldAllocInst = dynamic_cast<AllocaInst *>(inst.get());
+          std::vector<Value *> dims;
+          for (const auto &dim : oldAllocInst->getDims()) {
+            dims.emplace_back(dim->getValue());
+          }
+          ss << oldAllocInst->getName() << suffix;
+          auto newAllocInst =
+              new AllocaInst(oldAllocInst->getType(), dims, oldNewBlockMap.at(oldAllocInst->getParent()), ss.str());
+          ss.str("");
+          oldNewValueMap.emplace(oldAllocInst, newAllocInst);
+          if (isAddedToCreate.find(oldAllocInst) == isAddedToCreate.end()) {
+            isAddedToCreate.emplace(oldAllocInst, true);
+          } else {
+            isAddedToCreate.at(oldAllocInst) = true;
+          }
+          if (isCreated.find(oldAllocInst) == isCreated.end()) {
+            isCreated.emplace(oldAllocInst, true);
+          } else {
+            isCreated.at(oldAllocInst) = true;
+          }
+        }
+      }
+    }
+  }
+  for (const auto &oldBlock : blocks) {
+    for (const auto &inst : oldBlock->getInstructions()) {
+      for (const auto &valueUse : inst->getOperands()) {
+        auto value = valueUse->getValue();
+        if (oldNewValueMap.find(value) == oldNewValueMap.end()) {
+          auto globalValue = dynamic_cast<GlobalValue *>(value);
+          auto constVariable = dynamic_cast<ConstantVariable *>(value);
+          auto constantValue = dynamic_cast<ConstantValue *>(value);
+          auto functionValue = dynamic_cast<Function *>(value);
+          if (globalValue != nullptr || constantValue != nullptr || constVariable != nullptr ||
+              functionValue != nullptr) {
+            if (functionValue == this) {
+              oldNewValueMap.emplace(value, newFunction);
+            } else {
+              oldNewValueMap.emplace(value, value);
+            }
+            isCreated.emplace(value, true);
+            isAddedToCreate.emplace(value, true);
+          }
+        }
+      }
+    }
+  }
+  for (const auto &oldBlock : blocks) {
+    for (const auto &inst : oldBlock->getInstructions()) {
+      if (inst->getKind() != Instruction::kAlloca) {
+        bool isReady = true;
+        for (const auto &use : inst->getOperands()) {
+          auto value = use->getValue();
+          if (dynamic_cast<BasicBlock *>(value) == nullptr && !isCreated.at(value)) {
+            isReady = false;
+            break;
+          }
+        }
+        if (isReady) {
+          toCreate.push(inst.get());
+          isAddedToCreate.at(inst.get()) = true;
+        }
+      }
+    }
+  }
+
+  while (!toCreate.empty()) {
+    auto inst = dynamic_cast<Instruction *>(toCreate.front());
+    toCreate.pop();
+
+    bool isReady = true;
+    for (const auto &valueUse : inst->getOperands()) {
+      auto value = dynamic_cast<Instruction *>(valueUse->getValue());
+      if (value != nullptr && !isCreated.at(value)) {
+        isReady = false;
+        break;
+      }
+    }
+
+    if (!isReady) {
+      toCreate.push(inst);
+      continue;
+    }
+    isCreated.at(inst) = true;
+    switch (inst->getKind()) {
+      case Instruction::kAdd:
+      case Instruction::kSub:
+      case Instruction::kMul:
+      case Instruction::kDiv:
+      case Instruction::kRem:
+      case Instruction::kICmpEQ:
+      case Instruction::kICmpNE:
+      case Instruction::kICmpLT:
+      case Instruction::kICmpGT:
+      case Instruction::kICmpLE:
+      case Instruction::kICmpGE:
+      case Instruction::kAnd:
+      case Instruction::kOr:
+      case Instruction::kFAdd:
+      case Instruction::kFSub:
+      case Instruction::kFMul:
+      case Instruction::kFDiv:
+      case Instruction::kFCmpEQ:
+      case Instruction::kFCmpNE:
+      case Instruction::kFCmpLT:
+      case Instruction::kFCmpGT:
+      case Instruction::kFCmpLE:
+      case Instruction::kFCmpGE: {
+        auto oldBinaryInst = dynamic_cast<BinaryInst *>(inst);
+        auto lhs = oldBinaryInst->getLhs();
+        auto rhs = oldBinaryInst->getRhs();
+        Value *newLhs;
+        Value *newRhs;
+        newLhs = oldNewValueMap[lhs];
+        newRhs = oldNewValueMap[rhs];
+        ss << oldBinaryInst->getName() << suffix;
+        auto newBinaryInst = new BinaryInst(oldBinaryInst->getKind(), oldBinaryInst->getType(), newLhs, newRhs,
+                                            oldNewBlockMap.at(oldBinaryInst->getParent()), ss.str());
+        ss.str("");
+        oldNewValueMap.emplace(oldBinaryInst, newBinaryInst);
+        break;
+      }
+
+      case Instruction::kNeg:
+      case Instruction::kNot:
+      case Instruction::kFNeg:
+      case Instruction::kFNot:
+      case Instruction::kItoF:
+      case Instruction::kFtoI: {
+        auto oldUnaryInst = dynamic_cast<UnaryInst *>(inst);
+        auto hs = oldUnaryInst->getOperand();
+        Value *newHs;
+        newHs = oldNewValueMap.at(hs);
+        ss << oldUnaryInst->getName() << suffix;
+        auto newUnaryInst = new UnaryInst(oldUnaryInst->getKind(), oldUnaryInst->getType(), newHs,
+                                          oldNewBlockMap.at(oldUnaryInst->getParent()), ss.str());
+        ss.str("");
+        oldNewValueMap.emplace(oldUnaryInst, newUnaryInst);
+        break;
+      }
+
+      case Instruction::kCall: {
+        auto oldCallInst = dynamic_cast<CallInst *>(inst);
+        std::vector<Value *> newArgumnts;
+        for (const auto &arg : oldCallInst->getArguments()) {
+          newArgumnts.emplace_back(oldNewValueMap.at(arg->getValue()));
+        }
+
+        ss << oldCallInst->getName() << suffix;
+        CallInst *newCallInst;
+        newCallInst =
+            new CallInst(oldCallInst->getCallee(), newArgumnts, oldNewBlockMap.at(oldCallInst->getParent()), ss.str());
+        ss.str("");
+        // if (oldCallInst->getCallee() != this) {
+        //   newCallInst = new CallInst(oldCallInst->getCallee(), newArgumnts,
+        //   oldNewBlockMap.at(oldCallInst->getParent()),
+        //                              oldCallInst->getName());
+        // } else {
+        //   newCallInst = new CallInst(newFunction, newArgumnts, oldNewBlockMap.at(oldCallInst->getParent()),
+        //                              oldCallInst->getName());
+        // }
+
+        oldNewValueMap.emplace(oldCallInst, newCallInst);
+        break;
+      }
+
+      case Instruction::kCondBr: {
+        auto oldCondBrInst = dynamic_cast<CondBrInst *>(inst);
+        auto oldCond = oldCondBrInst->getCondition();
+        Value *newCond;
+        newCond = oldNewValueMap.at(oldCond);
+        auto newCondBrInst = new CondBrInst(newCond, oldNewBlockMap.at(oldCondBrInst->getThenBlock()),
+                                            oldNewBlockMap.at(oldCondBrInst->getElseBlock()), {}, {},
+                                            oldNewBlockMap.at(oldCondBrInst->getParent()));
+        oldNewValueMap.emplace(oldCondBrInst, newCondBrInst);
+        break;
+      }
+
+      case Instruction::kBr: {
+        auto oldBrInst = dynamic_cast<UncondBrInst *>(inst);
+        auto newBrInst =
+            new UncondBrInst(oldNewBlockMap.at(oldBrInst->getBlock()), {}, oldNewBlockMap.at(oldBrInst->getParent()));
+        oldNewValueMap.emplace(oldBrInst, newBrInst);
+        break;
+      }
+
+      case Instruction::kReturn: {
+        auto oldReturnInst = dynamic_cast<ReturnInst *>(inst);
+        auto oldRval = oldReturnInst->getReturnValue();
+        Value *newRval = nullptr;
+        if (oldRval != nullptr) {
+          newRval = oldNewValueMap.at(oldRval);
+        }
+        auto newReturnInst =
+            new ReturnInst(newRval, oldNewBlockMap.at(oldReturnInst->getParent()), oldReturnInst->getName());
+        oldNewValueMap.emplace(oldReturnInst, newReturnInst);
+        break;
+      }
+
+      case Instruction::kAlloca: {
+        assert(false);
+      }
+
+      case Instruction::kLoad: {
+        auto oldLoadInst = dynamic_cast<LoadInst *>(inst);
+        auto oldPointer = oldLoadInst->getPointer();
+        Value *newPointer;
+        newPointer = oldNewValueMap.at(oldPointer);
+
+        std::vector<Value *> newIndices;
+        for (const auto &index : oldLoadInst->getIndices()) {
+          newIndices.emplace_back(oldNewValueMap.at(index->getValue()));
+        }
+        ss << oldLoadInst->getName() << suffix;
+        auto newLoadInst = new LoadInst(newPointer, newIndices, oldNewBlockMap.at(oldLoadInst->getParent()), ss.str());
+        ss.str("");
+        oldNewValueMap.emplace(oldLoadInst, newLoadInst);
+        break;
+      }
+
+      case Instruction::kStore: {
+        auto oldStoreInst = dynamic_cast<StoreInst *>(inst);
+        auto oldPointer = oldStoreInst->getPointer();
+        auto oldValue = oldStoreInst->getValue();
+        Value *newPointer;
+        Value *newValue;
+        std::vector<Value *> newIndices;
+        newPointer = oldNewValueMap.at(oldPointer);
+        newValue = oldNewValueMap.at(oldValue);
+        for (const auto &index : oldStoreInst->getIndices()) {
+          newIndices.emplace_back(oldNewValueMap.at(index->getValue()));
+        }
+        auto newStoreInst = new StoreInst(newValue, newPointer, newIndices,
+                                          oldNewBlockMap.at(oldStoreInst->getParent()), oldStoreInst->getName());
+        oldNewValueMap.emplace(oldStoreInst, newStoreInst);
+        break;
+      }
+
+      // TODO：复制GEP指令
+
+      case Instruction::kMemset: {
+        auto oldMemsetInst = dynamic_cast<MemsetInst *>(inst);
+        auto oldPointer = oldMemsetInst->getPointer();
+        auto oldValue = oldMemsetInst->getValue();
+        Value *newPointer;
+        Value *newValue;
+        newPointer = oldNewValueMap.at(oldPointer);
+        newValue = oldNewValueMap.at(oldValue);
+
+        auto newMemsetInst = new MemsetInst(newPointer, oldMemsetInst->getBegin(), oldMemsetInst->getSize(), newValue,
+                                            oldNewBlockMap.at(oldMemsetInst->getParent()), oldMemsetInst->getName());
+        oldNewValueMap.emplace(oldMemsetInst, newMemsetInst);
+        break;
+      }
+
+      case Instruction::kInvalid:
+      case Instruction::kPhi: {
+        break;
+      }
+
+      default:
+        assert(false);
+    }
+    for (const auto &userUse : inst->getUses()) {
+      auto user = userUse->getUser();
+      if (!isAddedToCreate.at(user)) {
+        toCreate.push(user);
+        isAddedToCreate.at(user) = true;
+      }
+    }
+  }
+
+  for (const auto &oldBlock : blocks) {
+    auto newBlock = oldNewBlockMap.at(oldBlock.get());
+    builder.setPosition(newBlock, newBlock->end());
+    for (const auto &inst : oldBlock->getInstructions()) {
+      builder.insertInst(dynamic_cast<Instruction *>(oldNewValueMap.at(inst.get())));
+    }
+  }
+
+  // for (const auto &param : blocks.front()->getArguments()) {
+  //   newFunction->getEntryBlock()->insertArgument(dynamic_cast<AllocaInst *>(oldNewValueMap.at(param)));
+  // }
+  for (const auto &arg : arguments) {
+    auto newArg = dynamic_cast<Argument *>(oldNewValueMap.at(arg));
+    if (newArg != nullptr) {
+      newFunction->insertArgument(newArg);
+    }
+  }
+
+  return newFunction;
+}
 /**
  * 设置操作数
  */
-void User::setOperand(unsigned index, Value *newvalue) {
-  if (index >= operands.size()) {
-    std::cerr << "index=" << index << ", but mOperands max size=" << operands.size() << std::endl;
-    assert(index < operands.size());
-  }
-  std::shared_ptr<Use> olduse = operands[index];
-  Value *oldValue = olduse->getValue();
-  if (oldValue != newvalue) {
-    // 如果新值和旧值不同，先移除旧值的使用关系
-    oldValue->removeUse(olduse);
-    // 设置新的操作数
-    operands[index] = std::make_shared<Use>(index, this, newvalue);
-    newvalue->addUse(operands[index]);
-  }
-  else {
-    // 如果新值和旧值相同，直接更新use的索引
-    operands[index]->setValue(newvalue);
-  }
+void User::setOperand(unsigned index, Value *value) {
+  assert(index < getNumOperands());
+  operands[index]->setValue(value);
+  value->addUse(operands[index]);
 }
 /**
  * 替换操作数
@@ -265,128 +561,81 @@ void User::replaceOperand(unsigned index, Value *value) {
   value->addUse(use);
 }
 
-/**
- * 移除操作数
- */
-void User::removeOperand(unsigned index) {
-  assert(index < getNumOperands() && "Index out of range in removeOperand");
-  std::shared_ptr<Use> useToRemove = operands.at(index);
-  Value *valueToRemove = useToRemove->getValue();
-  if(valueToRemove) {
-    if(valueToRemove == this) {
-      std::cerr << "Cannot remove operand that is the same as the User itself." << std::endl;
-    }
-    valueToRemove->removeUse(useToRemove);
-  }
-  operands.erase(operands.begin() + index);
-  unsigned newIndex = 0;
-  for(auto it = operands.begin(); it != operands.end(); ++it, ++newIndex) {
-    (*it)->setIndex(newIndex);  // 更新剩余操作数的索引
-  }
-}
-
-
 /**
  * phi相关函数
  */
 
-Value* PhiInst::getValfromBlk(BasicBlock* blk) {
-  refreshMap();
+ Value* PhiInst::getvalfromBlk(BasicBlock* blk){
+  refreshB2VMap();
   if( blk2val.find(blk) != blk2val.end()) {
     return blk2val.at(blk);
   }
   return nullptr;
 }
 
-BasicBlock* PhiInst::getBlkfromVal(Value* val) {
+BasicBlock* PhiInst::getBlkfromVal(Value* val){
   // 返回第一个值对应的基本块
   for(unsigned i = 0; i < vsize; i++) {
-    if(getIncomingValue(i) == val) {
-      return getIncomingBlock(i);
+    if(getValue(i) == val) {
+      return getBlock(i);
     }
   }
   return nullptr;
 }
 
-void PhiInst::removeIncomingValue(Value* val){
+void PhiInst::delValue(Value* val){
   //根据value删除对应的基本块和值
   unsigned i = 0;
   BasicBlock* blk = getBlkfromVal(val);
-  if(blk == nullptr) {
-    return; // 如果val没有对应的基本块，直接返回
-  }
   for(i = 0; i < vsize; i++) {
-    if(getIncomingValue(i) == val) {
+    if(getValue(i) == val) {
       break;
     }
   }
-  removeIncoming(i);
+  removeOperand(2 * i + 1); // 删除blk
+  removeOperand(2 * i); // 删除val
+  vsize--;
+  blk2val.erase(blk); // 删除blk2val映射
 }
 
-void PhiInst::removeIncomingBlock(BasicBlock* blk){
+void PhiInst::delBlk(BasicBlock* blk){
   //根据Blk删除对应的基本块和值
   unsigned i = 0;
-  Value* val = getValfromBlk(blk);
-  if(val == nullptr) {
-    return; // 如果blk没有对应的值，直接返回
-  }
+  Value* val = getvalfromBlk(blk);
   for(i = 0; i < vsize; i++) {
-    if(getIncomingBlock(i) == blk) {
+    if(getBlock(i) == blk) {
       break;
     }
   }
-  removeIncoming(i);
+  removeOperand(2 * i + 1); // 删除blk
+  removeOperand(2 * i); // 删除val
+  vsize--;
+  blk2val.erase(blk); // 删除blk2val映射
 }
 
-void PhiInst::setIncomingValue(unsigned k, Value* val) {
-  assert(k < vsize && "PhiInst: index out of range");
-  assert(val != nullptr && "PhiInst: value cannot be null");
-  refreshMap();
-  blk2val.erase(getIncomingBlock(k));
-  setOperand(2 * k, val);
-  blk2val[getIncomingBlock(k)] = val;
+void PhiInst::replaceBlk(BasicBlock* newBlk, unsigned k){
+  refreshB2VMap();
+  Value* val = blk2val.at(getBlock(k));
+  // 替换基本块
+  setOperand(2 * k + 1, newBlk);
+  // 替换blk2val映射
+  blk2val.erase(getBlock(k));
+  blk2val.emplace(newBlk, val);
 }
 
-void PhiInst::setIncomingBlock(unsigned k, BasicBlock* blk) {
-  assert(k < vsize && "PhiInst: index out of range");
-  assert(blk != nullptr && "PhiInst: block cannot be null");
-  refreshMap();
-  auto oldVal = getIncomingValue(k);
-  blk2val.erase(getIncomingBlock(k));
-  setOperand(2 * k + 1, blk);
-  blk2val[blk] = oldVal;
-}
-
-void PhiInst::replaceIncomingValue(Value* newVal, Value* oldVal) {
-  refreshMap();
-  assert(blk2val.find(getBlkfromVal(oldVal)) != blk2val.end() && "PhiInst: oldVal not found in blk2val");
-  auto blk = getBlkfromVal(oldVal);
-  removeIncomingValue(oldVal);
-  addIncoming(newVal, blk);
-}
-
-void PhiInst::replaceIncomingBlock(BasicBlock* newBlk, BasicBlock* oldBlk) {
-  refreshMap();
-  assert(blk2val.find(oldBlk) != blk2val.end() && "PhiInst: oldBlk not found in blk2val");
-  auto val = blk2val[oldBlk];
-  removeIncomingBlock(oldBlk);
+void PhiInst::replaceold2new(BasicBlock* oldBlk, BasicBlock* newBlk){
+  refreshB2VMap();
+  Value* val = blk2val.at(oldBlk);
+  // 替换基本块
+  delBlk(oldBlk);
   addIncoming(val, newBlk);
 }
 
-void PhiInst::replaceIncomingValue(Value *oldValue, Value *newValue, BasicBlock *newBlock) {
-  refreshMap();
-  assert(blk2val.find(getBlkfromVal(oldValue)) != blk2val.end() && "PhiInst: oldValue not found in blk2val");
-  auto oldBlock = getBlkfromVal(oldValue);
-  removeIncomingValue(oldValue);
-  addIncoming(newValue, newBlock);
-}
-
-void PhiInst::replaceIncomingBlock(BasicBlock *oldBlock, BasicBlock *newBlock, Value *newValue) {
-  refreshMap();
-  assert(blk2val.find(oldBlock) != blk2val.end() && "PhiInst: oldBlock not found in blk2val");
-  auto oldValue = blk2val[oldBlock];
-  removeIncomingBlock(oldBlock);
-  addIncoming(newValue, newBlock);
+void PhiInst::refreshB2VMap(){
+  blk2val.clear();
+  for(unsigned i = 0; i < vsize; i++) {
+    blk2val.emplace(getBlock(i), getValue(i));
+  }
 }
 
 CallInst::CallInst(Function *callee, const std::vector<Value *> &args, BasicBlock *parent, const std::string &name)

src/midend/Pass/Analysis/Dom.cpp

@@ -1,30 +1,19 @@
 #include "Dom.h"
-#include <algorithm> // for std::set_intersection, std::reverse
-#include <iostream>  // for debug output
-#include <limits>    // for std::numeric_limits
+#include <limits> // for std::numeric_limits
 #include <queue>
-#include <functional> // for std::function
-#include <map>
-#include <vector>
-#include <set>
 
 namespace sysy {
 
-// ==============================================================
-// DominatorTreeAnalysisPass 的静态ID
-// ==============================================================
+// 初始化 支配树静态 ID
 void *DominatorTreeAnalysisPass::ID = (void *)&DominatorTreeAnalysisPass::ID;
-
 // ==============================================================
 // DominatorTree 结果类的实现
 // ==============================================================
 
-// 构造函数：初始化关联函数，但不进行计算
 DominatorTree::DominatorTree(Function *F) : AssociatedFunction(F) {
-  // 构造时不需要计算，在分析遍运行里计算并填充
+  // 构造时可以不计算，在分析遍运行里计算并填充
 }
 
-// Getter 方法 (保持不变)
 const std::set<BasicBlock *> *DominatorTree::getDominators(BasicBlock *BB) const {
   auto it = Dominators.find(BB);
   if (it != Dominators.end()) {
@@ -49,437 +38,164 @@ const std::set<BasicBlock *> *DominatorTree::getDominanceFrontier(BasicBlock *BB
   return nullptr;
 }
 
-const std::set<BasicBlock *> *DominatorTree::getDominatorTreeChildren(BasicBlock *BB) const {
-  auto it = DominatorTreeChildren.find(BB);
-  if (it != DominatorTreeChildren.end()) {
-    return &(it->second);
-  }
-  return nullptr;
-}
-
-// 辅助函数：打印 BasicBlock 集合 (保持不变)
-void printBBSet(const std::string &prefix, const std::set<BasicBlock *> &s) {
-  if (!DEBUG)
-    return;
-  std::cout << prefix << "{";
-  bool first = true;
-  for (const auto &bb : s) {
-    if (!first)
-      std::cout << ", ";
-    std::cout << bb->getName();
-    first = false;
-  }
-  std::cout << "}" << std::endl;
-}
-
-// 辅助函数：计算逆后序遍历 (RPO) - 保持不变
-std::vector<BasicBlock*> DominatorTree::computeReversePostOrder(Function* F) {
-    std::vector<BasicBlock*> postOrder;
-    std::set<BasicBlock*> visited;
-    
-    std::function<void(BasicBlock*)> dfs_rpo =
-        [&](BasicBlock* bb) {
-        visited.insert(bb);
-        for (BasicBlock* succ : bb->getSuccessors()) {
-            if (visited.find(succ) == visited.end()) {
-                dfs_rpo(succ);
-            }
-        }
-        postOrder.push_back(bb);
-    };
-
-    dfs_rpo(F->getEntryBlock());
-    std::reverse(postOrder.begin(), postOrder.end());
-    
-    if (DEBUG) {
-        std::cout << "--- Computed RPO: ";
-        for (BasicBlock* bb : postOrder) {
-            std::cout << bb->getName() << " ";
-        }
-        std::cout << "---" << std::endl;
+const std::set<BasicBlock*>* DominatorTree::getDominatorTreeChildren(BasicBlock* BB) const {
+    auto it = DominatorTreeChildren.find(BB);
+    if (it != DominatorTreeChildren.end()) {
+        return &(it->second);
     }
-    return postOrder;
+    return nullptr;
 }
 
-// computeDominators 方法 (保持不变，因为它它是独立于IDom算法的)
 void DominatorTree::computeDominators(Function *F) {
-  if (DEBUG)
-    std::cout << "--- Computing Dominators ---" << std::endl;
-
+  // 经典的迭代算法计算支配者集合
+  // TODO: 可以替换为更高效的算法，如 Lengauer-Tarjan 算法
   BasicBlock *entryBlock = F->getEntryBlock();
-  std::vector<BasicBlock*> bbs_rpo = computeReversePostOrder(F);
 
-  for (BasicBlock *bb : bbs_rpo) {
+  for (const auto &bb_ptr : F->getBasicBlocks()) {
+    BasicBlock *bb = bb_ptr.get();
     if (bb == entryBlock) {
-      Dominators[bb].clear();
       Dominators[bb].insert(bb);
-      if (DEBUG) std::cout << "Init Dominators[" << bb->getName() << "]: {" << bb->getName() << "}" << std::endl;
     } else {
-      Dominators[bb].clear();
-      for (BasicBlock *all_bb : bbs_rpo) {
-        Dominators[bb].insert(all_bb);
-      }
-      if (DEBUG) {
-        std::cout << "Init Dominators[" << bb->getName() << "]: ";
-        printBBSet("", Dominators[bb]);
+      for (const auto &all_bb_ptr : F->getBasicBlocks()) {
+        Dominators[bb].insert(all_bb_ptr.get());
       }
     }
   }
 
   bool changed = true;
-  int iteration = 0;
   while (changed) {
     changed = false;
-    iteration++;
-    if (DEBUG) std::cout << "Iteration " << iteration << std::endl;
-
-    for (BasicBlock *bb : bbs_rpo) {
-      if (bb == entryBlock) continue;
+    for (const auto &bb_ptr : F->getBasicBlocks()) {
+      BasicBlock *bb = bb_ptr.get();
+      if (bb == entryBlock)
+        continue;
 
       std::set<BasicBlock *> newDom;
-      bool firstPredProcessed = false;
-
+      bool firstPred = true;
       for (BasicBlock *pred : bb->getPredecessors()) {
-        if(DEBUG){
-          std::cout << "  Processing predecessor: " << pred->getName() << std::endl;
-        }
-          if (!firstPredProcessed) {
-              newDom = Dominators[pred];
-              firstPredProcessed = true;
+        if (Dominators.count(pred)) {
+          if (firstPred) {
+            newDom = Dominators[pred];
+            firstPred = false;
           } else {
-              std::set<BasicBlock *> intersection;
-              std::set_intersection(newDom.begin(), newDom.end(), Dominators[pred].begin(), Dominators[pred].end(),
-                                     std::inserter(intersection, intersection.begin()));
-              newDom = intersection;
+            std::set<BasicBlock *> intersection;
+            std::set_intersection(newDom.begin(), newDom.end(), Dominators[pred].begin(), Dominators[pred].end(),
+                                  std::inserter(intersection, intersection.begin()));
+            newDom = intersection;
           }
+        }
       }
       newDom.insert(bb);
 
       if (newDom != Dominators[bb]) {
-        if (DEBUG) {
-          std::cout << "  Dominators[" << bb->getName() << "] changed from ";
-          printBBSet("", Dominators[bb]);
-          std::cout << "  to ";
-          printBBSet("", newDom);
-        }
         Dominators[bb] = newDom;
         changed = true;
       }
     }
   }
-  if (DEBUG)
-    std::cout << "--- Dominators Computation Finished ---" << std::endl;
 }
 
-// ==============================================================
-// Lengauer-Tarjan 算法辅助数据结构和函数 (私有成员)
-// ==============================================================
-
-// DFS 遍历，填充 dfnum_map, vertex_vec, parent_map
-// 对应用户代码的 dfs 函数
-void DominatorTree::dfs_lt_helper(BasicBlock* u) {
-    dfnum_map[u] = df_counter;
-    if (df_counter >= vertex_vec.size()) { // 动态调整大小
-        vertex_vec.resize(df_counter + 1);
-    }
-    vertex_vec[df_counter] = u;
-    if (DEBUG) std::cout << "  DFS: Visiting " << u->getName() << ", dfnum = " << df_counter << std::endl;
-    df_counter++;
-
-    for (BasicBlock* v : u->getSuccessors()) {
-        if (dfnum_map.find(v) == dfnum_map.end()) { // 如果 v 未访问过
-            parent_map[v] = u;
-            if (DEBUG) std::cout << "    DFS: Setting parent[" << v->getName() << "] = " << u->getName() << std::endl;
-            dfs_lt_helper(v);
-        }
-    }
-}
-
-// 并查集：找到集合的代表，并进行路径压缩
-// 同时更新 label，确保 label[i] 总是指向其祖先链中 sdom_map 最小的节点
-// 对应用户代码的 find 函数，也包含了 eval 的逻辑
-BasicBlock* DominatorTree::evalAndCompress_lt_helper(BasicBlock* i) {
-    if (DEBUG) std::cout << "    Eval: Processing " << i->getName() << std::endl;
-    // 如果 i 是根 (ancestor_map[i] == nullptr)
-    if (ancestor_map.find(i) == ancestor_map.end() || ancestor_map[i] == nullptr) {
-        if (DEBUG) std::cout << "      Eval: " << i->getName() << " is root, returning itself." << std::endl;
-        return i; // 根节点自身就是路径上sdom最小的，因为它没有祖先
-    }
-    
-    // 如果 i 的祖先不是根，则递归查找并进行路径压缩
-    BasicBlock* root_ancestor = evalAndCompress_lt_helper(ancestor_map[i]);
-    
-    // 路径压缩时，根据 sdom_map 比较并更新 label_map
-    // 确保 label_map[i] 存储的是 i 到 root_ancestor 路径上 sdom_map 最小的节点
-    // 注意：这里的 ancestor_map[i] 已经被递归调用压缩过一次了，所以是root_ancestor的旧路径
-    // 应该比较的是 label_map[ancestor_map[i]] 和 label_map[i]
-    if (sdom_map.count(label_map[ancestor_map[i]]) && // 确保 label_map[ancestor_map[i]] 存在 sdom
-        sdom_map.count(label_map[i]) &&                // 确保 label_map[i] 存在 sdom
-        dfnum_map[sdom_map[label_map[ancestor_map[i]]]] < dfnum_map[sdom_map[label_map[i]]]) {
-        if (DEBUG) std::cout << "      Eval: Updating label for " << i->getName() << " from " 
-                              << label_map[i]->getName() << " to " << label_map[ancestor_map[i]]->getName() << std::endl;
-        label_map[i] = label_map[ancestor_map[i]];
-    }
-    
-    ancestor_map[i] = root_ancestor; // 执行路径压缩：将 i 直接指向其所属集合的根
-    if (DEBUG) std::cout << "      Eval: Path compression for " << i->getName() << ", new ancestor = " 
-                          << (root_ancestor ? root_ancestor->getName() : "nullptr") << std::endl;
-    
-    return label_map[i]; // <-- **将这里改为返回 label_map[i]**
-}
-
-// Link 函数：将 v 加入 u 的 DFS 树子树中 (实际上是并查集操作)
-// 对应用户代码的 fa[u] = fth[u];
-void DominatorTree::link_lt_helper(BasicBlock* u_parent, BasicBlock* v_child) {
-    ancestor_map[v_child] = u_parent; // 设置并查集父节点
-    label_map[v_child] = v_child;     // 初始化 label 为自身
-    if (DEBUG) std::cout << "  Link: " << v_child->getName() << " linked to " << u_parent->getName() << std::endl;
-}
-
-// ==============================================================
-// Lengauer-Tarjan 算法实现 computeIDoms
-// ==============================================================
 void DominatorTree::computeIDoms(Function *F) {
-    if (DEBUG) std::cout << "--- Computing Immediate Dominators (IDoms) using Lengauer-Tarjan ---" << std::endl;
+  // 采用与之前类似的简化实现。TODO:Lengauer-Tarjan等算法。
+  BasicBlock *entryBlock = F->getEntryBlock();
+  IDoms[entryBlock] = nullptr;
 
-    BasicBlock *entryBlock = F->getEntryBlock();
+  for (const auto &bb_ptr : F->getBasicBlocks()) {
+    BasicBlock *bb = bb_ptr.get();
+    if (bb == entryBlock)
+      continue;
 
-    // 1. 初始化所有 LT 相关的数据结构
-    dfnum_map.clear();
-    vertex_vec.clear();
-    parent_map.clear();
-    sdom_map.clear();
-    idom_map.clear();
-    bucket_map.clear();
-    ancestor_map.clear();
-    label_map.clear();
-    df_counter = 0; // DFS 计数器从 0 开始
+    BasicBlock *currentIDom = nullptr;
+    const std::set<BasicBlock *> *domsOfBB = getDominators(bb);
+    if (!domsOfBB)
+      continue;
 
-    // 预分配 vertex_vec 的大小，避免频繁resize
-    vertex_vec.resize(F->getBasicBlocks().size() + 1); 
-    // 在 DFS 遍历之前，先为所有基本块初始化 sdom 和 label
-    // 这是 Lengauer-Tarjan 算法的要求，确保所有节点在 Phase 2 开始前都在 map 中
-    for (auto &bb_ptr : F->getBasicBlocks()) {
-        BasicBlock* bb = bb_ptr.get();
-        sdom_map[bb] = bb; // sdom(bb) 初始化为 bb 自身
-        label_map[bb] = bb; // label(bb) 初始化为 bb 自身 (用于 Union-Find 的路径压缩)
+    for (BasicBlock *D : *domsOfBB) {
+      if (D == bb)
+        continue;
+
+      bool isCandidateIDom = true;
+      for (BasicBlock *candidate : *domsOfBB) {
+        if (candidate == bb || candidate == D)
+          continue;
+        const std::set<BasicBlock *> *domsOfCandidate = getDominators(candidate);
+        if (domsOfCandidate && domsOfCandidate->count(D) == 0 && domsOfBB->count(candidate)) {
+          isCandidateIDom = false;
+          break;
+        }
+      }
+      if (isCandidateIDom) {
+        currentIDom = D;
+        break;
+      }
     }
-    // 确保入口块也被正确初始化（如果它不在 F->getBasicBlocks() 的正常迭代中）
-    sdom_map[entryBlock] = entryBlock;
-    label_map[entryBlock] = entryBlock;
-    // Phase 1: DFS 遍历并预处理
-    // 对应用户代码的 dfs(st)
-    dfs_lt_helper(entryBlock);
-    idom_map[entryBlock] = nullptr; // 入口块没有即时支配者
-    if (DEBUG) std::cout << "  IDom[" << entryBlock->getName() << "] = nullptr" << std::endl;
-
-    if (DEBUG) std::cout << "  Sdom[" << entryBlock->getName() << "] = " << entryBlock->getName() << std::endl;
-    
-    // 初始化并查集的祖先和 label
-    for (auto const& [bb_key, dfn_val] : dfnum_map) {
-        ancestor_map[bb_key] = nullptr; // 初始为独立集合的根
-        label_map[bb_key] = bb_key;   // 初始 label 为自身
-    }
-
-    if (DEBUG) {
-        std::cout << "  --- DFS Phase Complete ---" << std::endl;
-        std::cout << "  dfnum_map:" << std::endl;
-        for (auto const& [bb, dfn] : dfnum_map) {
-            std::cout << "    " << bb->getName() << " -> " << dfn << std::endl;
-        }
-        std::cout << "  vertex_vec (by dfnum):" << std::endl;
-        for (size_t k = 0; k < df_counter; ++k) {
-            if (vertex_vec[k]) std::cout << "    [" << k << "] -> " << vertex_vec[k]->getName() << std::endl;
-        }
-        std::cout << "  parent_map:" << std::endl;
-        for (auto const& [child, parent] : parent_map) {
-            std::cout << "    " << child->getName() << " -> " << (parent ? parent->getName() : "nullptr") << std::endl;
-        }
-        std::cout << "  ------------------------" << std::endl;
-    }
-
-
-    // Phase 2: 计算半支配者 (sdom)
-    // 对应用户代码的 for (int i = dfc; i >= 2; --i) 循环的上半部分
-    // 按照 DFS 编号递减的顺序遍历所有节点 (除了 entryBlock，它的 DFS 编号是 0)
-    if (DEBUG) std::cout << "--- Phase 2: Computing Semi-Dominators (sdom) ---" << std::endl;
-    for (int i = df_counter - 1; i >= 1; --i) { // 从 DFS 编号最大的节点开始，到 1
-        BasicBlock* w = vertex_vec[i]; // 当前处理的节点
-        if (DEBUG) std::cout << "  Processing node w: " << w->getName() << " (dfnum=" << i << ")" << std::endl;
-
-
-        // 对于 w 的每个前驱 v
-        for (BasicBlock* v : w->getPredecessors()) {
-            if (DEBUG) std::cout << "    Considering predecessor v: " << v->getName() << std::endl;
-            // 如果前驱 v 未被 DFS 访问过 (即不在 dfnum_map 中)，则跳过
-            if (dfnum_map.find(v) == dfnum_map.end()) {
-                if (DEBUG) std::cout << "      Predecessor " << v->getName() << " not in DFS tree, skipping." << std::endl;
-                continue; 
-            }
-
-            // 调用 evalAndCompress 来找到 v 在其 DFS 树祖先链上具有最小 sdom 的节点
-            BasicBlock* u_with_min_sdom_on_path = evalAndCompress_lt_helper(v);
-            if (DEBUG) std::cout << "      Eval(" << v->getName() << ") returned " 
-                                  << u_with_min_sdom_on_path->getName() << std::endl;
-            if (DEBUG && sdom_map.count(u_with_min_sdom_on_path) && sdom_map.count(w)) {
-                std::cout << "      Comparing sdom: dfnum[" << sdom_map[u_with_min_sdom_on_path]->getName() << "] (" << dfnum_map[sdom_map[u_with_min_sdom_on_path]] 
-                          << ") vs dfnum[" << sdom_map[w]->getName() << "] (" << dfnum_map[sdom_map[w]] << ")" << std::endl;
-            }
-            // 比较 sdom(u) 和 sdom(w)
-            if (sdom_map.count(u_with_min_sdom_on_path) && sdom_map.count(w) &&
-                dfnum_map[sdom_map[u_with_min_sdom_on_path]] < dfnum_map[sdom_map[w]]) {
-                if (DEBUG) std::cout << "      Updating sdom[" << w->getName() << "] from " 
-                                      << sdom_map[w]->getName() << " to " 
-                                      << sdom_map[u_with_min_sdom_on_path]->getName() << std::endl;
-                sdom_map[w] = sdom_map[u_with_min_sdom_on_path]; // 更新 sdom(w)
-                if (DEBUG) std::cout << "      Sdom update applied. New sdom[" << w->getName() << "] = " << sdom_map[w]->getName() << std::endl;
-            }
-        }
-        
-        // 将 w 加入 sdom(w) 对应的桶中
-        bucket_map[sdom_map[w]].push_back(w);
-        if (DEBUG) std::cout << "    Adding " << w->getName() << " to bucket of sdom(" << w->getName() << "): " 
-                              << sdom_map[w]->getName() << std::endl;
-
-        // 将 w 的父节点加入并查集 (link 操作)
-        if (parent_map.count(w) && parent_map[w] != nullptr) {
-            link_lt_helper(parent_map[w], w);
-        }
-        
-        // Phase 3-part 1: 处理 parent[w] 的桶中所有节点，确定部分 idom
-        if (parent_map.count(w) && parent_map[w] != nullptr) {
-            BasicBlock* p = parent_map[w]; // p 是 w 的父节点
-            if (DEBUG) std::cout << "    Processing bucket for parent " << p->getName() << std::endl;
-
-            // 注意：这里需要复制桶的内容，因为原始桶在循环中会被clear
-            std::vector<BasicBlock*> nodes_in_p_bucket_copy = bucket_map[p];
-            for (BasicBlock* y : nodes_in_p_bucket_copy) {
-                if (DEBUG) std::cout << "      Processing node y from bucket: " << y->getName() << std::endl;
-                // 找到 y 在其 DFS 树祖先链上具有最小 sdom 的节点
-                BasicBlock* u = evalAndCompress_lt_helper(y);
-                if (DEBUG) std::cout << "        Eval(" << y->getName() << ") returned " << u->getName() << std::endl;
-                
-                // 确定 idom(y)
-                // if sdom(eval(y)) == sdom(parent(w)), then idom(y) = parent(w)
-                // else idom(y) = eval(y)
-                if (sdom_map.count(u) && sdom_map.count(p) &&
-                    dfnum_map[sdom_map[u]] < dfnum_map[sdom_map[p]]) {
-                    idom_map[y] = u; // 确定的 idom
-                    if (DEBUG) std::cout << "        IDom[" << y->getName() << "] set to " << u->getName() << std::endl;
-                } else {
-                    idom_map[y] = p; // p 是 y 的 idom
-                    if (DEBUG) std::cout << "        IDom[" << y->getName() << "] set to " << p->getName() << std::endl;
-                }
-            }
-            bucket_map[p].clear(); // 清空桶，防止重复处理
-            if (DEBUG) std::cout << "    Cleared bucket for parent " << p->getName() << std::endl;
-        }
-    }
-
-    // Phase 3-part 2: 最终确定 idom (处理那些 idom != sdom 的节点)
-    if (DEBUG) std::cout << "--- Phase 3: Finalizing Immediate Dominators (idom) ---" << std::endl;
-    for (int i = 1; i < df_counter; ++i) { // 从 DFS 编号最小的节点 (除了 entryBlock) 开始
-        BasicBlock* w = vertex_vec[i];
-        if (DEBUG) std::cout << "  Finalizing node w: " << w->getName() << std::endl;
-        if (idom_map.count(w) && sdom_map.count(w) && idom_map[w] != sdom_map[w]) {
-            // idom[w] 的 idom 是其真正的 idom
-            if (DEBUG) std::cout << "    idom[" << w->getName() << "] (" << idom_map[w]->getName() 
-                                  << ") != sdom[" << w->getName() << "] (" << sdom_map[w]->getName() << ")" << std::endl;
-            if (idom_map.count(idom_map[w])) {
-                idom_map[w] = idom_map[idom_map[w]];
-                if (DEBUG) std::cout << "    Updating idom[" << w->getName() << "] to idom(idom(w)): " 
-                                      << idom_map[w]->getName() << std::endl;
-            } else {
-                 if (DEBUG) std::cout << "    Warning: idom(idom(" << w->getName() << ")) not found, leaving idom[" << w->getName() << "] as is." << std::endl;
-            }
-        }
-        if (DEBUG) {
-            std::cout << "  Final IDom[" << w->getName() << "] = " << (idom_map[w] ? idom_map[w]->getName() : "nullptr") << std::endl;
-        }
-    }
-
-    // 将计算结果从 idom_map 存储到 DominatorTree 的成员变量 IDoms 中
-    IDoms = idom_map; 
-
-    if (DEBUG) std::cout << "--- Immediate Dominators Computation Finished ---" << std::endl;
+    IDoms[bb] = currentIDom;
+  }
 }
 
-// ==============================================================
-// computeDominanceFrontiers 和 computeDominatorTreeChildren (保持不变)
-// ==============================================================
-
 void DominatorTree::computeDominanceFrontiers(Function *F) {
-  if (DEBUG)
-    std::cout << "--- Computing Dominance Frontiers ---" << std::endl;
-
+  // 经典的支配边界计算算法
   for (const auto &bb_ptr_X : F->getBasicBlocks()) {
     BasicBlock *X = bb_ptr_X.get();
     DominanceFrontiers[X].clear();
 
+    for (BasicBlock *Y : X->getSuccessors()) {
+      const std::set<BasicBlock *> *domsOfY = getDominators(Y);
+      if (domsOfY && domsOfY->find(X) == domsOfY->end()) {
+        DominanceFrontiers[X].insert(Y);
+      }
+    }
+
+    const std::set<BasicBlock *> *domsOfX = getDominators(X);
+    if (!domsOfX)
+      continue;
     for (const auto &bb_ptr_Z : F->getBasicBlocks()) {
       BasicBlock *Z = bb_ptr_Z.get();
-      const std::set<BasicBlock *> *domsOfZ = getDominators(Z);
-
-      if (!domsOfZ || domsOfZ->find(X) == domsOfZ->end()) { // Z 不被 X 支配
+      if (Z == X)
         continue;
-      }
+      const std::set<BasicBlock *> *domsOfZ = getDominators(Z);
+      if (domsOfZ && domsOfZ->count(X) && Z != X) {
 
-      for (BasicBlock *Y : Z->getSuccessors()) {
-        const std::set<BasicBlock *> *domsOfY = getDominators(Y);
-        // 如果 Y == X，或者 Y 不被 X 严格支配 (即 Y 不被 X 支配)
-        if (Y == X || (domsOfY && domsOfY->find(X) == domsOfY->end())) {
-          DominanceFrontiers[X].insert(Y);
+        for (BasicBlock *Y : Z->getSuccessors()) {
+          const std::set<BasicBlock *> *domsOfY = getDominators(Y);
+          if (domsOfY && domsOfY->find(X) == domsOfY->end()) {
+            DominanceFrontiers[X].insert(Y);
+          }
         }
       }
     }
-    if (DEBUG) {
-      std::cout << "  DF(" << X->getName() << "): ";
-      printBBSet("", DominanceFrontiers[X]);
-    }
   }
-  if (DEBUG)
-    std::cout << "--- Dominance Frontiers Computation Finished ---" << std::endl;
 }
 
 void DominatorTree::computeDominatorTreeChildren(Function *F) {
-  if (DEBUG)
-    std::cout << "--- Computing Dominator Tree Children ---" << std::endl;
-  // 首先清空，确保重新计算时是空的
-  for (auto &bb_ptr : F->getBasicBlocks()) {
-    DominatorTreeChildren[bb_ptr.get()].clear();
-  }
-
   for (auto &bb_ptr : F->getBasicBlocks()) {
     BasicBlock *B = bb_ptr.get();
-    BasicBlock *A = getImmediateDominator(B); // A 是 B 的即时支配者
-
-    if (A) { // 如果 B 有即时支配者 A (即 B 不是入口块)
-      DominatorTreeChildren[A].insert(B);
-      if (DEBUG) {
-        std::cout << "  " << B->getName() << " is child of " << A->getName() << std::endl;
+    auto it = getImmediateDominator(B);
+    if (it != nullptr) {
+      BasicBlock *A = it;
+      if (A) {
+        DominatorTreeChildren[A].insert(B);
       }
     }
   }
-  if (DEBUG)
-    std::cout << "--- Dominator Tree Children Computation Finished ---" << std::endl;
 }
 
 // ==============================================================
-// DominatorTreeAnalysisPass 的实现 (保持不变)
+// DominatorTreeAnalysisPass 的实现
 // ==============================================================
 
-bool DominatorTreeAnalysisPass::runOnFunction(Function *F, AnalysisManager &AM) {
-  // 每次运行时清空旧数据，确保重新计算
-  CurrentDominatorTree = std::make_unique<DominatorTree>(F);
 
+bool DominatorTreeAnalysisPass::runOnFunction(Function* F, AnalysisManager &AM) {
+  CurrentDominatorTree = std::make_unique<DominatorTree>(F);
   CurrentDominatorTree->computeDominators(F);
-  CurrentDominatorTree->computeIDoms(F); // 修正后的LT算法
+  CurrentDominatorTree->computeIDoms(F);
   CurrentDominatorTree->computeDominanceFrontiers(F);
   CurrentDominatorTree->computeDominatorTreeChildren(F);
   return false;
 }
 
 std::unique_ptr<AnalysisResultBase> DominatorTreeAnalysisPass::getResult() {
+  // 返回计算好的 DominatorTree 实例，所有权转移给 AnalysisManager
   return std::move(CurrentDominatorTree);
 }
 

src/midend/Pass/Optimize/BuildCFG.cpp

@@ -1,79 +0,0 @@
-#include "BuildCFG.h"
-#include "Dom.h"
-#include "Liveness.h"
-#include <iostream>
-#include <queue>
-#include <set>
-
-namespace sysy {
-
-void *BuildCFG::ID = (void *)&BuildCFG::ID; // 定义唯一的 Pass ID
-
-// 声明Pass的分析使用
-void BuildCFG::getAnalysisUsage(std::set<void *> &analysisDependencies, std::set<void *> &analysisInvalidations) const {
-  // BuildCFG不依赖其他分析
-  // analysisDependencies.insert(&DominatorTreeAnalysisPass::ID); // 错误的例子
-
-  // BuildCFG会使所有依赖于CFG的分析结果失效，所以它必须声明这些失效
-  analysisInvalidations.insert(&DominatorTreeAnalysisPass::ID);
-  analysisInvalidations.insert(&LivenessAnalysisPass::ID);
-}
-
-bool BuildCFG::runOnFunction(Function *F, AnalysisManager &AM) {
-  if (DEBUG) {
-    std::cout << "Running BuildCFG pass on function: " << F->getName() << std::endl;
-  }
-
-  bool changed = false;
-
-  // 1. 清空所有基本块的前驱和后继列表
-  for (auto &bb : F->getBasicBlocks()) {
-    bb->clearPredecessors();
-    bb->clearSuccessors();
-  }
-
-  // 2. 遍历每个基本块，重建CFG
-  for (auto &bb : F->getBasicBlocks()) {
-    // 获取基本块的最后一条指令
-    auto &inst = *bb->terminator();
-    Instruction *termInst = inst.get();
-    // 确保基本块有终结指令
-    if (!termInst) {
-      continue;
-    }
-
-    // 根据终结指令类型，建立前驱后继关系
-    if (termInst->isBranch()) {
-      // 无条件跳转
-      if (termInst->isUnconditional()) {
-        auto brInst = dynamic_cast<UncondBrInst *>(termInst);
-        BasicBlock *succ = dynamic_cast<BasicBlock *>(brInst->getBlock());
-        assert(succ && "Branch instruction's target must be a BasicBlock");
-        bb->addSuccessor(succ);
-        succ->addPredecessor(bb.get());
-        changed = true;
-
-        // 条件跳转
-      } else if (termInst->isConditional()) {
-        auto brInst = dynamic_cast<CondBrInst *>(termInst);
-        BasicBlock *trueSucc = dynamic_cast<BasicBlock *>(brInst->getThenBlock());
-        BasicBlock *falseSucc = dynamic_cast<BasicBlock *>(brInst->getElseBlock());
-
-        assert(trueSucc && falseSucc && "Branch instruction's targets must be BasicBlocks");
-
-        bb->addSuccessor(trueSucc);
-        trueSucc->addPredecessor(bb.get());
-        bb->addSuccessor(falseSucc);
-        falseSucc->addPredecessor(bb.get());
-        changed = true;
-      }
-    } else if (auto retInst = dynamic_cast<ReturnInst *>(termInst)) {
-      // RetInst没有后继，无需处理
-      // ...
-    }
-  }
-
-  return changed;
-}
-
-} // namespace sysy

src/midend/Pass/Optimize/ConstPropagation.cpp

@@ -0,0 +1,241 @@
+#include "Pass/Optimize/ConstPropagation.h"
+#include "IR.h"
+#include "Pass.h"
+#include <climits>
+#include <cmath>
+
+namespace sysy {
+
+char ConstPropagation::ID = 0;
+
+bool ConstPropagation::runOnFunction(Function *func, AnalysisManager &am) {
+    bool changed = false;
+    bool localChanged = true;
+    
+    while (localChanged) {
+        localChanged = false;
+        
+        for (auto &bb : func->getBasicBlocks()) {
+            for (auto instIter = bb->getInstructions().begin(); 
+                 instIter != bb->getInstructions().end();) {
+                auto &inst = *instIter;
+                bool shouldAdvanceIter = true;
+                
+                // 处理二元运算指令
+                if (auto *binaryInst = dynamic_cast<BinaryInst *>(inst.get())) {
+                    auto *lhs = binaryInst->getLhs();
+                    auto *rhs = binaryInst->getRhs();
+
+                    auto *lhsConst = dynamic_cast<ConstantValue *>(lhs);
+                    auto *rhsConst = dynamic_cast<ConstantValue *>(rhs);
+
+                    if (lhsConst && rhsConst) {
+                        ConstantValue *newConst = nullptr;
+                        
+                        try {
+                            if (lhs->isInt() && rhs->isInt()) {
+                                int l = lhsConst->getInt();
+                                int r = rhsConst->getInt();
+                                int result;
+                                bool validOperation = true;
+                                
+                                switch (binaryInst->getKind()) {
+                                    case Instruction::kAdd:
+                                        // 检查加法溢出
+                                        if ((r > 0 && l > INT_MAX - r) || (r < 0 && l < INT_MIN - r)) {
+                                            validOperation = false;
+                                        } else {
+                                            result = l + r;
+                                        }
+                                        break;
+                                    case Instruction::kSub:
+                                        // 检查减法溢出
+                                        if ((r < 0 && l > INT_MAX + r) || (r > 0 && l < INT_MIN + r)) {
+                                            validOperation = false;
+                                        } else {
+                                            result = l - r;
+                                        }
+                                        break;
+                                    case Instruction::kMul:
+                                        // 检查乘法溢出
+                                        if (l != 0 && r != 0 && 
+                                            (std::abs(l) > INT_MAX / std::abs(r))) {
+                                            validOperation = false;
+                                        } else {
+                                            result = l * r;
+                                        }
+                                        break;
+                                    case Instruction::kDiv: 
+                                        if (r == 0) {
+                                            validOperation = false;
+                                        } else {
+                                            result = l / r;
+                                        }
+                                        break;
+                                    case Instruction::kRem: 
+                                        if (r == 0) {
+                                            validOperation = false;
+                                        } else {
+                                            result = l % r;
+                                        }
+                                        break;
+                                    case Instruction::kICmpEQ: result = (l == r) ? 1 : 0; break;
+                                    case Instruction::kICmpNE: result = (l != r) ? 1 : 0; break;
+                                    case Instruction::kICmpLT: result = (l < r) ? 1 : 0; break;
+                                    case Instruction::kICmpGT: result = (l > r) ? 1 : 0; break;
+                                    case Instruction::kICmpLE: result = (l <= r) ? 1 : 0; break;
+                                    case Instruction::kICmpGE: result = (l >= r) ? 1 : 0; break;
+                                    case Instruction::kAnd: result = (l && r) ? 1 : 0; break;
+                                    case Instruction::kOr: result = (l || r) ? 1 : 0; break;
+                                    default: 
+                                        validOperation = false;
+                                }
+                                
+                                if (validOperation) {
+                                    if (binaryInst->isCmp() || binaryInst->getKind() == Instruction::kAnd || 
+                                        binaryInst->getKind() == Instruction::kOr) {
+                                        newConst = ConstantInteger::get(Type::getIntType(), result);
+                                    } else {
+                                        newConst = ConstantInteger::get(result);
+                                    }
+                                }
+                            } else if (lhs->isFloat() && rhs->isFloat()) {
+                                float l = lhsConst->getFloat();
+                                float r = rhsConst->getFloat();
+                                bool validOperation = true;
+                                
+                                switch (binaryInst->getKind()) {
+                                    case Instruction::kFAdd: {
+                                        float result = l + r;
+                                        if (std::isfinite(result)) {
+                                            newConst = ConstantFloating::get(result);
+                                        } else {
+                                            validOperation = false;
+                                        }
+                                        break;
+                                    }
+                                    case Instruction::kFSub: {
+                                        float result = l - r;
+                                        if (std::isfinite(result)) {
+                                            newConst = ConstantFloating::get(result);
+                                        } else {
+                                            validOperation = false;
+                                        }
+                                        break;
+                                    }
+                                    case Instruction::kFMul: {
+                                        float result = l * r;
+                                        if (std::isfinite(result)) {
+                                            newConst = ConstantFloating::get(result);
+                                        } else {
+                                            validOperation = false;
+                                        }
+                                        break;
+                                    }
+                                    case Instruction::kFDiv: {
+                                        if (std::abs(r) < std::numeric_limits<float>::epsilon()) {
+                                            validOperation = false;
+                                        } else {
+                                            float result = l / r;
+                                            if (std::isfinite(result)) {
+                                                newConst = ConstantFloating::get(result);
+                                            } else {
+                                                validOperation = false;
+                                            }
+                                        }
+                                        break;
+                                    }
+                                    case Instruction::kFCmpEQ: 
+                                        newConst = ConstantInteger::get(Type::getIntType(), (l == r) ? 1 : 0);
+                                        break;
+                                    case Instruction::kFCmpNE: 
+                                        newConst = ConstantInteger::get(Type::getIntType(), (l != r) ? 1 : 0);
+                                        break;
+                                    case Instruction::kFCmpLT: 
+                                        newConst = ConstantInteger::get(Type::getIntType(), (l < r) ? 1 : 0);
+                                        break;
+                                    case Instruction::kFCmpGT: 
+                                        newConst = ConstantInteger::get(Type::getIntType(), (l > r) ? 1 : 0);
+                                        break;
+                                    case Instruction::kFCmpLE: 
+                                        newConst = ConstantInteger::get(Type::getIntType(), (l <= r) ? 1 : 0);
+                                        break;
+                                    case Instruction::kFCmpGE: 
+                                        newConst = ConstantInteger::get(Type::getIntType(), (l >= r) ? 1 : 0);
+                                        break;
+                                    default: 
+                                        validOperation = false;
+                                }
+                            }
+                        } catch (...) {
+                            // 捕获可能的异常，跳过优化
+                            newConst = nullptr;
+                        }
+
+                        if (newConst) {
+                            binaryInst->replaceAllUsesWith(newConst);
+                            instIter = bb->getInstructions().erase(instIter);
+                            shouldAdvanceIter = false;
+                            localChanged = true;
+                        }
+                    }
+                }
+                // 处理一元运算指令
+                else if (auto *unaryInst = dynamic_cast<UnaryInst *>(inst.get())) {
+                    auto *operand = unaryInst->getOperand();
+                    auto *operandConst = dynamic_cast<ConstantValue *>(operand);
+
+                    if (operandConst) {
+                        ConstantValue *newConst = nullptr;
+                        
+                        if (operand->isInt()) {
+                            int val = operandConst->getInt();
+                            
+                            switch (unaryInst->getKind()) {
+                                case Instruction::kNeg: 
+                                    if (val != INT_MIN) { // 避免溢出
+                                        newConst = ConstantInteger::get(-val);
+                                    }
+                                    break;
+                                case Instruction::kNot: 
+                                    newConst = ConstantInteger::get(Type::getIntType(), (!val) ? 1 : 0);
+                                    break;
+                                default: 
+                                    break;
+                            }
+                        } else if (operand->isFloat()) {
+                            float val = operandConst->getFloat();
+                            
+                            switch (unaryInst->getKind()) {
+                                case Instruction::kFNeg: 
+                                    newConst = ConstantFloating::get(-val);
+                                    break;
+                                default: 
+                                    break;
+                            }
+                        }
+
+                        if (newConst) {
+                            unaryInst->replaceAllUsesWith(newConst);
+                            instIter = bb->getInstructions().erase(instIter);
+                            shouldAdvanceIter = false;
+                            localChanged = true;
+                        }
+                    }
+                }
+                
+                if (shouldAdvanceIter) {
+                    ++instIter;
+                }
+            }
+        }
+        
+        if (localChanged) {
+            changed = true;
+        }
+    }
+    
+    return changed;
+}
+
+} // namespace sysy

src/midend/Pass/Optimize/DCE.cpp

@@ -51,8 +51,10 @@ void DCEContext::run(Function *func, AnalysisManager *AM, bool &changed) {
       // 如果指令不在活跃集合中，则删除它。
       // 分支和返回指令由 isAlive 处理，并会被保留。
       if (alive_insts.count(currentInst) == 0) {
-        instIter =  SysYIROptUtils::usedelete(instIter); // 删除后返回下一个迭代器
+        // 删除指令，保留用户风格的 SysYIROptUtils::usedelete 和 erase
         changed = true; // 标记 IR 已被修改
+        SysYIROptUtils::usedelete(currentInst);
+        instIter = basicBlock->getInstructions().erase(instIter); // 删除后返回下一个迭代器
       } else {
         ++instIter; // 指令活跃，移动到下一个
       }

src/midend/Pass/Optimize/LargeArrayToGlobal.cpp

@@ -1,143 +0,0 @@
-#include "../../include/midend/Pass/Optimize/LargeArrayToGlobal.h"
-#include "../../IR.h"
-#include <unordered_map>
-#include <sstream>
-#include <string>
-
-namespace sysy {
-
-// Helper function to convert type to string
-static std::string typeToString(Type *type) {
-    if (!type) return "null";
-    
-    switch (type->getKind()) {
-        case Type::kInt:
-            return "int";
-        case Type::kFloat:
-            return "float";
-        case Type::kPointer:
-            return "ptr";
-        case Type::kArray: {
-            auto *arrayType = type->as<ArrayType>();
-            return "[" + std::to_string(arrayType->getNumElements()) + " x " + 
-                   typeToString(arrayType->getElementType()) + "]";
-        }
-        default:
-            return "unknown";
-    }
-}
-
-void *LargeArrayToGlobalPass::ID = &LargeArrayToGlobalPass::ID;
-
-bool LargeArrayToGlobalPass::runOnModule(Module *M, AnalysisManager &AM) {
-        bool changed = false;
-        
-        if (!M) {
-            return false;
-        }
-
-        // Collect all alloca instructions from all functions
-        std::vector<std::pair<AllocaInst*, Function*>> allocasToConvert;
-        
-        for (auto &funcPair : M->getFunctions()) {
-            Function *F = funcPair.second.get();
-            if (!F || F->getBasicBlocks().begin() == F->getBasicBlocks().end()) {
-                continue;
-            }
-            
-            for (auto &BB : F->getBasicBlocks()) {
-                for (auto &inst : BB->getInstructions()) {
-                    if (auto *alloca = dynamic_cast<AllocaInst*>(inst.get())) {
-                        Type *allocatedType = alloca->getAllocatedType();
-                        
-                        // Calculate the size of the allocated type
-                        unsigned size = calculateTypeSize(allocatedType);
-                        
-                        // Debug: print size information
-                        std::cout << "LargeArrayToGlobalPass: Found alloca with size " << size 
-                                  << " for type " << typeToString(allocatedType) << std::endl;
-                        
-                        // Convert arrays of 1KB (1024 bytes) or larger to global variables
-                        if (size >= 1024) {
-                            std::cout << "LargeArrayToGlobalPass: Converting array of size " << size << " to global" << std::endl;
-                            allocasToConvert.emplace_back(alloca, F);
-                        }
-                    }
-                }
-            }
-        }
-
-        // Convert the collected alloca instructions to global variables
-        for (auto [alloca, F] : allocasToConvert) {
-            convertAllocaToGlobal(alloca, F, M);
-            changed = true;
-        }
-
-return changed;
-    }
-
-unsigned LargeArrayToGlobalPass::calculateTypeSize(Type *type) {
-    if (!type) return 0;
-
-    switch (type->getKind()) {
-        case Type::kInt:
-        case Type::kFloat:
-            return 4;
-        case Type::kPointer:
-            return 8;
-        case Type::kArray: {
-            auto *arrayType = type->as<ArrayType>();
-            return arrayType->getNumElements() * calculateTypeSize(arrayType->getElementType());
-        }
-        default:
-            return 0;
-    }
-}
-
-void LargeArrayToGlobalPass::convertAllocaToGlobal(AllocaInst *alloca, Function *F, Module *M) {
-    Type *allocatedType = alloca->getAllocatedType();
-    
-    // Create a unique name for the global variable
-    std::string globalName = generateUniqueGlobalName(alloca, F);
-    
-    // Create the global variable - GlobalValue expects pointer type
-    Type *pointerType = Type::getPointerType(allocatedType);
-    GlobalValue *globalVar = M->createGlobalValue(globalName, pointerType);
-    
-    if (!globalVar) {
-        return;
-    }
-    
-    // Replace all uses of the alloca with the global variable
-    alloca->replaceAllUsesWith(globalVar);
-    
-    // Remove the alloca instruction from its basic block
-    for (auto &BB : F->getBasicBlocks()) {
-        auto &instructions = BB->getInstructions();
-        for (auto it = instructions.begin(); it != instructions.end(); ++it) {
-            if (it->get() == alloca) {
-                instructions.erase(it);
-                break;
-            }
-        }
-    }
-}
-
-std::string LargeArrayToGlobalPass::generateUniqueGlobalName(AllocaInst *alloca, Function *F) {
-    std::string baseName = alloca->getName();
-    if (baseName.empty()) {
-        baseName = "array";
-    }
-    
-    // Ensure uniqueness by appending function name and counter
-    static std::unordered_map<std::string, int> nameCounter;
-    std::string key = F->getName() + "." + baseName;
-    
-    int counter = nameCounter[key]++;
-    std::ostringstream oss;
-    oss << key << "." << counter;
-    
-    return oss.str();
-}
-
-} // namespace sysy

src/midend/Pass/Optimize/Mem2Reg.cpp

@@ -60,7 +60,7 @@ void Mem2RegContext::run(Function *func, AnalysisManager *AM) {
   }
 
   // 从入口基本块开始，对支配树进行 DFS 遍历，进行变量重命名
-  renameVariables(func->getEntryBlock()); // 第一个参数 alloca 在这里不使用，因为是递归入口点
+  renameVariables(nullptr, func->getEntryBlock()); // 第一个参数 alloca 在这里不使用，因为是递归入口点
 
   // --------------------------------------------------------------------
   // 阶段4: 清理
@@ -209,21 +209,16 @@ void Mem2RegContext::insertPhis(AllocaInst *alloca, const std::unordered_set<Bas
 }
 
 // 对支配树进行深度优先遍历，重命名变量并替换 load/store 指令
-// 移除了 AllocaInst *currentAlloca 参数，因为这个函数是为整个基本块处理所有可提升的 Alloca
-void Mem2RegContext::renameVariables(BasicBlock *currentBB) {
-  // 1. 在函数开始时，记录每个 promotableAlloca 的当前栈深度。
-  // 这将用于在函数返回时精确地回溯栈状态。
-  std::map<AllocaInst *, size_t> originalStackSizes;
-  for (auto alloca : promotableAllocas) {
-    originalStackSizes[alloca] = allocaToValueStackMap[alloca].size();
-  }
+void Mem2RegContext::renameVariables(AllocaInst *currentAlloca, BasicBlock *currentBB) {
+  // 维护一个局部栈，用于存储当前基本块中为 Phi 和 Store 创建的 SSA 值，以便在退出时弹出
+  std::stack<Value *> localStackPushed;
 
   // --------------------------------------------------------------------
   // 处理当前基本块的指令
   // --------------------------------------------------------------------
   for (auto instIter = currentBB->getInstructions().begin(); instIter != currentBB->getInstructions().end();) {
     Instruction *inst = instIter->get();
-      bool instDeleted = false;
+    bool instDeleted = false;
 
     // 处理 Phi 指令 (如果是当前 alloca 的 Phi)
     if (auto phiInst = dynamic_cast<PhiInst *>(inst)) {
@@ -232,69 +227,52 @@ void Mem2RegContext::renameVariables(BasicBlock *currentBB) {
         if (allocaToPhiMap[alloca].count(currentBB) && allocaToPhiMap[alloca][currentBB] == phiInst) {
           // 为 Phi 指令的输出创建一个新的 SSA 值，并压入值栈
           allocaToValueStackMap[alloca].push(phiInst);
-          if (DEBUG) {
-            std::cout << "Mem2Reg: Pushed Phi " << (phiInst->getName().empty() ? "anonymous" : phiInst->getName()) << " for alloca " << alloca->getName()
-              << ". Stack size: " << allocaToValueStackMap[alloca].size() << std::endl;
-          }
-          break; // 找到对应的 alloca，处理下一个指令
+          localStackPushed.push(phiInst); // 记录以便弹出
+          break;                          // 找到对应的 alloca，处理下一个指令
         }
       }
     }
     // 处理 LoadInst
     else if (auto loadInst = dynamic_cast<LoadInst *>(inst)) {
+      // 检查这个 LoadInst 是否是为某个可提升的 alloca
       for (auto alloca : promotableAllocas) {
-        // 检查 LoadInst 的指针是否直接是 alloca，或者是指向 alloca 的 GEP
-        Value *ptrOperand = loadInst->getPointer();
-        if (ptrOperand == alloca || (dynamic_cast<GetElementPtrInst *>(ptrOperand) &&
-                                     dynamic_cast<GetElementPtrInst *>(ptrOperand)->getBasePointer() == alloca)) {
+        if (loadInst->getPointer() == alloca) { 
+          // loadInst->getPointer() 返回 AllocaInst*
+          // 将 LoadInst 的所有用途替换为当前 alloca 值栈顶部的 SSA 值
           assert(!allocaToValueStackMap[alloca].empty() && "Value stack empty for alloca during load replacement!");
-          if (DEBUG) {
-            std::cout << "Mem2Reg: Replacing load "
-                      << (ptrOperand->getName().empty() ? "anonymous" : ptrOperand->getName()) << " with SSA value "
-                      << (allocaToValueStackMap[alloca].top()->getName().empty()
-                              ? "anonymous"
-                              : allocaToValueStackMap[alloca].top()->getName())
-                      << " for alloca " << alloca->getName() << std::endl;
-            std::cout << "Mem2Reg: allocaToValueStackMap[" << alloca->getName()
-                      << "] size: " << allocaToValueStackMap[alloca].size() << std::endl;
-          }
           loadInst->replaceAllUsesWith(allocaToValueStackMap[alloca].top());
-          instIter = SysYIROptUtils::usedelete(instIter);
+          // instIter = currentBB->force_delete_inst(loadInst); // 删除 LoadInst
+          SysYIROptUtils::usedelete(loadInst); // 仅删除 use 关系
+          instIter = currentBB->getInstructions().erase(instIter); // 删除 LoadInst
           instDeleted = true;
+          // std::cerr << "Mem2Reg: Replaced load " << loadInst->name() << " with SSA value." << std::endl;
           break;
         }
       }
     }
     // 处理 StoreInst
     else if (auto storeInst = dynamic_cast<StoreInst *>(inst)) {
+      // 检查这个 StoreInst 是否是为某个可提升的 alloca
       for (auto alloca : promotableAllocas) {
-        // 检查 StoreInst 的指针是否直接是 alloca，或者是指向 alloca 的 GEP
-        Value *ptrOperand = storeInst->getPointer();
-        if (ptrOperand == alloca || (dynamic_cast<GetElementPtrInst *>(ptrOperand) &&
-                                     dynamic_cast<GetElementPtrInst *>(ptrOperand)->getBasePointer() == alloca)) {
-          if (DEBUG) {
-            std::cout << "Mem2Reg: Replacing store to "
-                      << (ptrOperand->getName().empty() ? "anonymous" : ptrOperand->getName()) << " with SSA value "
-                      << (storeInst->getValue()->getName().empty() ? "anonymous" : storeInst->getValue()->getName())
-                      << " for alloca " << alloca->getName() << std::endl;
-            std::cout << "Mem2Reg: allocaToValueStackMap[" << alloca->getName()
-                      << "] size before push: " << allocaToValueStackMap[alloca].size() << std::endl;
-          }
+        if (storeInst->getPointer() == alloca) { 
+          // 假设 storeInst->getPointer() 返回 AllocaInst*
+          // 将 StoreInst 存储的值作为新的 SSA 值，压入值栈
           allocaToValueStackMap[alloca].push(storeInst->getValue());
-          instIter = SysYIROptUtils::usedelete(instIter);
+          localStackPushed.push(storeInst->getValue());          // 记录以便弹出
+          SysYIROptUtils::usedelete(storeInst);
+          instIter = currentBB->getInstructions().erase(instIter); // 删除 StoreInst
           instDeleted = true;
-          if (DEBUG) {
-            std::cout << "Mem2Reg: allocaToValueStackMap[" << alloca->getName()
-                      << "] size after push: " << allocaToValueStackMap[alloca].size() << std::endl;
-          }
+          // std::cerr << "Mem2Reg: Replaced store to " << storeInst->ptr()->name() << " with SSA value." << std::endl;
           break;
         }
       }
     }
+
     if (!instDeleted) {
       ++instIter; // 如果指令没有被删除，移动到下一个
     }
   }
+
   // --------------------------------------------------------------------
   // 处理后继基本块的 Phi 指令参数
   // --------------------------------------------------------------------
@@ -309,57 +287,38 @@ void Mem2RegContext::renameVariables(BasicBlock *currentBB) {
         // 参数值是当前 alloca 值栈顶部的 SSA 值
         assert(!allocaToValueStackMap[alloca].empty() && "Value stack empty for alloca when setting phi operand!");
         phiInst->addIncoming(allocaToValueStackMap[alloca].top(), currentBB);
-        if (DEBUG) {
-          std::cout << "Mem2Reg: Added incoming arg to Phi "
-                    << (phiInst->getName().empty() ? "anonymous" : phiInst->getName()) << " from "
-                    << currentBB->getName() << " with value "
-                    << (allocaToValueStackMap[alloca].top()->getName().empty()
-                            ? "anonymous"
-                            : allocaToValueStackMap[alloca].top()->getName())
-                    << std::endl;
-        }
       }
     }
   }
+
   // --------------------------------------------------------------------
   // 递归访问支配树的子节点
   // --------------------------------------------------------------------
   const std::set<BasicBlock *> *dominatedBlocks = dt->getDominatorTreeChildren(currentBB);
-  if (dominatedBlocks) { // 检查是否存在子节点
-    if(DEBUG){
-      std::cout << "Mem2Reg: Processing dominated blocks for " << currentBB->getName() << std::endl;
-      for (auto dominatedBB : *dominatedBlocks) {
-        std::cout << "Mem2Reg: Dominated block: " << (dominatedBB ? dominatedBB->getName() : "null") << std::endl;
-      }
-    }
+  if(dominatedBlocks){
     for (auto dominatedBB : *dominatedBlocks) {
-      if (dominatedBB) { // 确保子块有效
-        if (DEBUG) {
-          std::cout << "Mem2Reg: Recursively renaming variables in dominated block: " << dominatedBB->getName()
-                    << std::endl;
-        }
-        renameVariables(dominatedBB); // 递归调用，不再传递 currentAlloca
+      if (dominatedBB) {
+        std::cout << "Mem2Reg: Recursively renaming variables in dominated block: " << dominatedBB->getName() << std::endl;
+        renameVariables(currentAlloca, dominatedBB);
       }
     }
   }
+  
 
   // --------------------------------------------------------------------
-  // 退出基本块时，弹出在此块中压入值栈的 SSA 值，恢复栈到进入该块时的状态
+  // 退出基本块时，弹出在此块中压入值栈的 SSA 值
   // --------------------------------------------------------------------
-  for (auto alloca : promotableAllocas) {
-    while (allocaToValueStackMap[alloca].size() > originalStackSizes[alloca]) {
-      if (DEBUG) {
-        std::cout << "Mem2Reg: Popping value "
-                  << (allocaToValueStackMap[alloca].top()->getName().empty()
-                          ? "anonymous"
-                          : allocaToValueStackMap[alloca].top()->getName())
-                  << " for alloca " << alloca->getName() << ". Stack size: " << allocaToValueStackMap[alloca].size()
-                  << " -> " << (allocaToValueStackMap[alloca].size() - 1) << std::endl;
+  while (!localStackPushed.empty()) {
+    Value *val = localStackPushed.top();
+    localStackPushed.pop();
+    // 找到是哪个 alloca 对应的栈
+    for (auto alloca : promotableAllocas) {
+      if (!allocaToValueStackMap[alloca].empty() && allocaToValueStackMap[alloca].top() == val) {
+        allocaToValueStackMap[alloca].pop();
+        break;
       }
-      allocaToValueStackMap[alloca].pop();
     }
   }
-
 }
 
 // 删除所有原始的 AllocaInst、LoadInst 和 StoreInst
@@ -368,6 +327,7 @@ void Mem2RegContext::cleanup() {
     if (alloca && alloca->getParent()) {
       // 删除 alloca 指令本身
       SysYIROptUtils::usedelete(alloca);
+      alloca->getParent()->removeInst(alloca); // 从基本块中删除 alloca
       
       // std::cerr << "Mem2Reg: Deleted alloca " << alloca->name() << std::endl;
     }

src/midend/Pass/Optimize/Reg2Mem.cpp

@@ -74,7 +74,7 @@ void Reg2MemContext::allocateMemoryForSSAValues(Function *func) {
     // 默认情况下，将所有参数是提升到内存
     if (isPromotableToMemory(arg)) {
       // 参数的类型就是 AllocaInst 需要分配的类型
-      AllocaInst *alloca = builder->createAllocaInst(Type::getPointerType(arg->getType()), arg->getName() + ".reg2mem");
+      AllocaInst *alloca = builder->createAllocaInst(Type::getPointerType(arg->getType()), {}, arg->getName() + ".reg2mem");
       // 将参数值 store 到 alloca 中 (这是 Mem2Reg 逆转的关键一步)
       valueToAllocaMap[arg] = alloca;
 
@@ -103,7 +103,7 @@ void Reg2MemContext::allocateMemoryForSSAValues(Function *func) {
         // AllocaInst 应该在入口块，而不是当前指令所在块
         // 这里我们只是创建，并稍后调整其位置
         // 通常的做法是在循环结束后统一将 alloca 放到 entryBlock 的顶部
-        AllocaInst *alloca = builder->createAllocaInst(Type::getPointerType(inst.get()->getType()), inst.get()->getName() + ".reg2mem");
+        AllocaInst *alloca = builder->createAllocaInst(Type::getPointerType(inst.get()->getType()), {}, inst.get()->getName() + ".reg2mem");
         valueToAllocaMap[inst.get()] = alloca;
       }
     }
@@ -148,8 +148,8 @@ void Reg2MemContext::rewritePhis(Function *func) {
           // 1. 为 Phi 指令的每个入边，在前驱块的末尾插入 Store 指令
           // PhiInst 假设有 getIncomingValues() 和 getIncomingBlocks()
           for (unsigned i = 0; i < phiInst->getNumIncomingValues(); ++i) {         // 假设 PhiInst 是通过操作数来管理入边的
-            Value *incomingValue = phiInst->getIncomingValue(i);                   // 获取入值
-            BasicBlock *incomingBlock = phiInst->getIncomingBlock(i); // 获取对应的入块
+            Value *incomingValue = phiInst->getValue(i);                   // 获取入值
+            BasicBlock *incomingBlock = phiInst->getBlock(i); // 获取对应的入块
 
             // 在入块的跳转指令之前插入 StoreInst
             // 需要找到 incomingBlock 的终结指令 (Terminator Instruction)
@@ -181,7 +181,8 @@ void Reg2MemContext::rewritePhis(Function *func) {
   // 实际删除 Phi 指令
   for (auto phi : phisToErase) {
     if (phi && phi->getParent()) {
-      SysYIROptUtils::usedelete(phi);
+      SysYIROptUtils::usedelete(phi);    // 清理 use-def 链
+      phi->getParent()->removeInst(phi); // 从基本块中删除
     }
   }
 }

src/midend/Pass/Optimize/SCCP.cpp

@@ -1,880 +0,0 @@
-#include "SCCP.h"
-#include "Dom.h"
-#include "Liveness.h"
-#include <algorithm>
-#include <cassert>
-#include <cmath>  // For std::fmod, std::fabs
-#include <limits> // For std::numeric_limits
-
-namespace sysy {
-
-// Pass ID for SCCP
-void *SCCP::ID = (void *)&SCCP::ID;
-
-// SCCPContext methods
-SSAPValue SCCPContext::Meet(const SSAPValue &a, const SSAPValue &b) {
-  if (a.state == LatticeVal::Bottom || b.state == LatticeVal::Bottom) {
-    return SSAPValue(LatticeVal::Bottom);
-  }
-  if (a.state == LatticeVal::Top) {
-    return b;
-  }
-  if (b.state == LatticeVal::Top) {
-    return a;
-  }
-  // Both are constants
-  if (a.constant_type != b.constant_type) {
-    return SSAPValue(LatticeVal::Bottom); // 不同类型的常量，结果为 Bottom
-  }
-  if (a.constantVal == b.constantVal) {
-    return a; // 相同常量
-  }
-  return SSAPValue(LatticeVal::Bottom); // 相同类型但值不同，结果为 Bottom
-}
-
-SSAPValue SCCPContext::GetValueState(Value *v) {
-  if (auto constVal = dynamic_cast<ConstantValue *>(v)) {
-    // 特殊处理 UndefinedValue：将其视为 Bottom
-    if (dynamic_cast<UndefinedValue *>(constVal)) {
-      return SSAPValue(LatticeVal::Bottom);
-    }
-    // 处理常规的 ConstantInteger 和 ConstantFloating
-    if (constVal->getType()->isInt()) {
-      return SSAPValue(constVal->getInt());
-    } else if (constVal->getType()->isFloat()) {
-      return SSAPValue(constVal->getFloat());
-    } else {
-      // 对于其他 ConstantValue 类型（例如，ConstantArray 等），
-      // 如果它们的具体值不能用于标量常量传播，则保守地视为 Bottom。
-      return SSAPValue(LatticeVal::Bottom);
-    }
-  }
-  if (valueState.count(v)) {
-    return valueState[v];
-  }
-  return SSAPValue(); // 默认初始化为 Top
-}
-
-void SCCPContext::UpdateState(Value *v, SSAPValue newState) {
-  SSAPValue oldState = GetValueState(v);
-  if (newState != oldState) {
-    if (DEBUG) {
-      std::cout << "Updating state for " << v->getName() << " from (";
-      if (oldState.state == LatticeVal::Top)
-        std::cout << "Top";
-      else if (oldState.state == LatticeVal::Constant) {
-        if (oldState.constant_type == ValueType::Integer)
-          std::cout << "Const<int>(" << std::get<int>(oldState.constantVal) << ")";
-        else
-          std::cout << "Const<float>(" << std::get<float>(oldState.constantVal) << ")";
-      } else
-        std::cout << "Bottom";
-      std::cout << ") to (";
-      if (newState.state == LatticeVal::Top)
-        std::cout << "Top";
-      else if (newState.state == LatticeVal::Constant) {
-        if (newState.constant_type == ValueType::Integer)
-          std::cout << "Const<int>(" << std::get<int>(newState.constantVal) << ")";
-        else
-          std::cout << "Const<float>(" << std::get<float>(newState.constantVal) << ")";
-      } else
-        std::cout << "Bottom";
-      std::cout << ")" << std::endl;
-    }
-
-    valueState[v] = newState;
-    // 如果状态发生变化，将所有使用者添加到指令工作列表
-    for (auto &use_ptr : v->getUses()) {
-      if (auto userInst = dynamic_cast<Instruction *>(use_ptr->getUser())) {
-        instWorkList.push(userInst);
-      }
-    }
-  }
-}
-
-void SCCPContext::AddEdgeToWorkList(BasicBlock *fromBB, BasicBlock *toBB) {
-  // 检查边是否已经访问过，防止重复处理
-  if (visitedCFGEdges.count({fromBB, toBB})) {
-    return;
-  }
-  visitedCFGEdges.insert({fromBB, toBB});
-
-  if (DEBUG) {
-    std::cout << "Adding edge to worklist: " << fromBB->getName() << " -> " << toBB->getName() << std::endl;
-  }
-  edgeWorkList.push({fromBB, toBB});
-}
-
-void SCCPContext::MarkBlockExecutable(BasicBlock *block) {
-  if (executableBlocks.insert(block).second) { // insert 返回 pair，second 为 true 表示插入成功
-    if (DEBUG) {
-      std::cout << "Marking block " << block->getName() << " as executable." << std::endl;
-    }
-    // 将新可执行块中的所有指令添加到指令工作列表
-    for (auto &inst_ptr : block->getInstructions()) {
-      instWorkList.push(inst_ptr.get());
-    }
-  }
-}
-
-// 辅助函数：对二元操作进行常量折叠
-SSAPValue SCCPContext::ComputeConstant(BinaryInst *binaryInst, SSAPValue lhsVal, SSAPValue rhsVal) {
-  // 确保操作数是常量
-  if (lhsVal.state != LatticeVal::Constant || rhsVal.state != LatticeVal::Constant) {
-    return SSAPValue(LatticeVal::Bottom); // 如果不是常量，则不能折叠
-  }
-
-  // 处理整数运算 (kAdd, kSub, kMul, kDiv, kRem, kICmp*, kAnd, kOr)
-  if (lhsVal.constant_type == ValueType::Integer && rhsVal.constant_type == ValueType::Integer) {
-    int lhs = std::get<int>(lhsVal.constantVal);
-    int rhs = std::get<int>(rhsVal.constantVal);
-    int result = 0;
-
-    switch (binaryInst->getKind()) {
-    case Instruction::kAdd:
-      result = lhs + rhs;
-      break;
-    case Instruction::kSub:
-      result = lhs - rhs;
-      break;
-    case Instruction::kMul:
-      result = lhs * rhs;
-      break;
-    case Instruction::kDiv:
-      if (rhs == 0)
-        return SSAPValue(LatticeVal::Bottom); // 除零
-      result = lhs / rhs;
-      break;
-    case Instruction::kRem:
-      if (rhs == 0)
-        return SSAPValue(LatticeVal::Bottom); // 模零
-      result = lhs % rhs;
-      break;
-    case Instruction::kICmpEQ:
-      result = (lhs == rhs);
-      break;
-    case Instruction::kICmpNE:
-      result = (lhs != rhs);
-      break;
-    case Instruction::kICmpLT:
-      result = (lhs < rhs);
-      break;
-    case Instruction::kICmpGT:
-      result = (lhs > rhs);
-      break;
-    case Instruction::kICmpLE:
-      result = (lhs <= rhs);
-      break;
-    case Instruction::kICmpGE:
-      result = (lhs >= rhs);
-      break;
-    case Instruction::kAnd:
-      result = (lhs && rhs);
-      break;
-    case Instruction::kOr:
-      result = (lhs || rhs);
-      break;
-    default:
-      return SSAPValue(LatticeVal::Bottom); // 未知或不匹配的二元操作
-    }
-    return SSAPValue(result);
-  }
-  // 处理浮点运算 (kFAdd, kFSub, kFMul, kFDiv, kFCmp*)
-  else if (lhsVal.constant_type == ValueType::Float && rhsVal.constant_type == ValueType::Float) {
-    float lhs = std::get<float>(lhsVal.constantVal);
-    float rhs = std::get<float>(rhsVal.constantVal);
-    float f_result = 0.0f;
-    int i_result = 0; // For comparison results
-
-    switch (binaryInst->getKind()) {
-    case Instruction::kFAdd:
-      f_result = lhs + rhs;
-      break;
-    case Instruction::kFSub:
-      f_result = lhs - rhs;
-      break;
-    case Instruction::kFMul:
-      f_result = lhs * rhs;
-      break;
-    case Instruction::kFDiv:
-      if (rhs == 0.0f)
-        return SSAPValue(LatticeVal::Bottom); // 除零
-      f_result = lhs / rhs;
-      break;
-    // kRem 不支持浮点数，但如果你的 IR 定义了浮点模运算，需要使用 std::fmod
-    case Instruction::kFCmpEQ:
-      i_result = (lhs == rhs);
-      return SSAPValue(i_result);
-    case Instruction::kFCmpNE:
-      i_result = (lhs != rhs);
-      return SSAPValue(i_result);
-    case Instruction::kFCmpLT:
-      i_result = (lhs < rhs);
-      return SSAPValue(i_result);
-    case Instruction::kFCmpGT:
-      i_result = (lhs > rhs);
-      return SSAPValue(i_result);
-    case Instruction::kFCmpLE:
-      i_result = (lhs <= rhs);
-      return SSAPValue(i_result);
-    case Instruction::kFCmpGE:
-      i_result = (lhs >= rhs);
-      return SSAPValue(i_result);
-    default:
-      return SSAPValue(LatticeVal::Bottom); // 未知或不匹配的浮点二元操作
-    }
-    return SSAPValue(f_result);
-  }
-
-  return SSAPValue(LatticeVal::Bottom); // 类型不匹配或不支持的类型组合
-}
-
-// 辅助函数：对一元操作进行常量折叠
-SSAPValue SCCPContext::ComputeConstant(UnaryInst *unaryInst, SSAPValue operandVal) {
-  if (operandVal.state != LatticeVal::Constant) {
-    return SSAPValue(LatticeVal::Bottom);
-  }
-
-  if (operandVal.constant_type == ValueType::Integer) {
-    int val = std::get<int>(operandVal.constantVal);
-    switch (unaryInst->getKind()) {
-    case Instruction::kAdd:
-      return SSAPValue(val);
-    case Instruction::kNeg:
-      return SSAPValue(-val);
-    case Instruction::kNot:
-      return SSAPValue(!val);
-    default:
-      return SSAPValue(LatticeVal::Bottom);
-    }
-  } else if (operandVal.constant_type == ValueType::Float) {
-    float val = std::get<float>(operandVal.constantVal);
-    switch (unaryInst->getKind()) {
-    case Instruction::kAdd:
-      return SSAPValue(val);
-    case Instruction::kFNeg:
-      return SSAPValue(-val);
-    case Instruction::kFNot:
-      return SSAPValue(static_cast<int>(val == 0.0f)); // 浮点数非，0.0f 为真，其他为假
-    default:
-      return SSAPValue(LatticeVal::Bottom);
-    }
-  }
-  return SSAPValue(LatticeVal::Bottom);
-}
-
-// 辅助函数：处理单条指令
-void SCCPContext::ProcessInstruction(Instruction *inst) {
-  SSAPValue oldState = GetValueState(inst);
-  SSAPValue newState;
-
-  if (!executableBlocks.count(inst->getParent())) {
-    // 如果指令所在的块不可执行，其值应保持 Top
-    // 除非它之前已经是 Bottom，因为 Bottom 是单调的
-    if (oldState.state != LatticeVal::Bottom) {
-      newState = SSAPValue(); // Top
-    } else {
-      newState = oldState; // 保持 Bottom
-    }
-    UpdateState(inst, newState);
-    return; // 不处理不可达块中的指令的实际值
-  }
-
-  switch (inst->getKind()) {
-  case Instruction::kAdd:
-  case Instruction::kSub:
-  case Instruction::kMul:
-  case Instruction::kDiv:
-  case Instruction::kRem:
-  case Instruction::kICmpEQ:
-  case Instruction::kICmpNE:
-  case Instruction::kICmpLT:
-  case Instruction::kICmpGT:
-  case Instruction::kICmpLE:
-  case Instruction::kICmpGE:
-  case Instruction::kFAdd:
-  case Instruction::kFSub:
-  case Instruction::kFMul:
-  case Instruction::kFDiv:
-  case Instruction::kFCmpEQ:
-  case Instruction::kFCmpNE:
-  case Instruction::kFCmpLT:
-  case Instruction::kFCmpGT:
-  case Instruction::kFCmpLE:
-  case Instruction::kFCmpGE:
-  case Instruction::kAnd:
-  case Instruction::kOr: {
-    BinaryInst *binaryInst = static_cast<BinaryInst *>(inst);
-    SSAPValue lhs = GetValueState(binaryInst->getOperand(0));
-    SSAPValue rhs = GetValueState(binaryInst->getOperand(1));
-    // 如果任一操作数是 Bottom，结果就是 Bottom
-    if (lhs.state == LatticeVal::Bottom || rhs.state == LatticeVal::Bottom) {
-      newState = SSAPValue(LatticeVal::Bottom);
-    } else if (lhs.state == LatticeVal::Top || rhs.state == LatticeVal::Top) {
-      newState = SSAPValue(); // Top
-    } else {                  // 都是常量
-      newState = ComputeConstant(binaryInst, lhs, rhs);
-    }
-    break;
-  }
-  case Instruction::kNeg:
-  case Instruction::kNot:
-  case Instruction::kFNeg:
-  case Instruction::kFNot: {
-    UnaryInst *unaryInst = static_cast<UnaryInst *>(inst);
-    SSAPValue operand = GetValueState(unaryInst->getOperand());
-    if (operand.state == LatticeVal::Bottom) {
-      newState = SSAPValue(LatticeVal::Bottom);
-    } else if (operand.state == LatticeVal::Top) {
-      newState = SSAPValue(); // Top
-    } else {                  // 是常量
-      newState = ComputeConstant(unaryInst, operand);
-    }
-    break;
-  }
-  // 直接处理类型转换指令
-  case Instruction::kFtoI: {
-    SSAPValue operand = GetValueState(inst->getOperand(0));
-    if (operand.state == LatticeVal::Constant && operand.constant_type == ValueType::Float) {
-      newState = SSAPValue(static_cast<int>(std::get<float>(operand.constantVal)));
-    } else if (operand.state == LatticeVal::Bottom) {
-      newState = SSAPValue(LatticeVal::Bottom);
-    } else { // Top
-      newState = SSAPValue();
-    }
-    break;
-  }
-  case Instruction::kItoF: {
-    SSAPValue operand = GetValueState(inst->getOperand(0));
-    if (operand.state == LatticeVal::Constant && operand.constant_type == ValueType::Integer) {
-      newState = SSAPValue(static_cast<float>(std::get<int>(operand.constantVal)));
-    } else if (operand.state == LatticeVal::Bottom) {
-      newState = SSAPValue(LatticeVal::Bottom);
-    } else { // Top
-      newState = SSAPValue();
-    }
-    break;
-  }
-  case Instruction::kBitFtoI: {
-    SSAPValue operand = GetValueState(inst->getOperand(0));
-    if (operand.state == LatticeVal::Constant && operand.constant_type == ValueType::Float) {
-      float fval = std::get<float>(operand.constantVal);
-      newState = SSAPValue(*reinterpret_cast<int *>(&fval));
-    } else if (operand.state == LatticeVal::Bottom) {
-      newState = SSAPValue(LatticeVal::Bottom);
-    } else { // Top
-      newState = SSAPValue();
-    }
-    break;
-  }
-  case Instruction::kBitItoF: {
-    SSAPValue operand = GetValueState(inst->getOperand(0));
-    if (operand.state == LatticeVal::Constant && operand.constant_type == ValueType::Integer) {
-      int ival = std::get<int>(operand.constantVal);
-      newState = SSAPValue(*reinterpret_cast<float *>(&ival));
-    } else if (operand.state == LatticeVal::Bottom) {
-      newState = SSAPValue(LatticeVal::Bottom);
-    } else { // Top
-      newState = SSAPValue();
-    }
-    break;
-  }
-  case Instruction::kLoad: {
-    // 对于 Load 指令，除非我们有特殊的别名分析，否则假定为 Bottom
-    // 或者如果它加载的是一个已知常量地址的全局常量
-    Value *ptr = inst->getOperand(0);
-    if (auto globalVal = dynamic_cast<GlobalValue *>(ptr)) {
-      // 如果 GlobalValue 有初始化器，并且它是常量，我们可以传播
-      // 这需要额外的逻辑来检查 globalVal 的初始化器
-      // 暂时保守地设置为 Bottom
-      newState = SSAPValue(LatticeVal::Bottom);
-    } else {
-      newState = SSAPValue(LatticeVal::Bottom);
-    }
-    break;
-  }
-  case Instruction::kStore:
-    // Store 指令不产生值，其 SSAPValue 不重要
-    newState = SSAPValue(); // 保持 Top
-    break;
-  case Instruction::kCall:
-    // 大多数 Call 指令都假定为 Bottom，除非是纯函数且所有参数都是常量
-    newState = SSAPValue(LatticeVal::Bottom);
-    break;
-  case Instruction::kGetElementPtr: {
-    // GEP 指令计算地址，通常其结果值（地址指向的内容）是 Bottom
-    // 除非所有索引和基指针都是常量，指向一个确定常量值的内存位置
-    bool all_ops_constant = true;
-    for (unsigned i = 0; i < inst->getNumOperands(); ++i) {
-      if (GetValueState(inst->getOperand(i)).state != LatticeVal::Constant) {
-        all_ops_constant = false;
-        break;
-      }
-    }
-    // 即使地址是常量，地址处的内容通常不是。所以通常是 Bottom
-    newState = SSAPValue(LatticeVal::Bottom);
-    break;
-  }
-  case Instruction::kPhi: {
-    PhiInst *phi = static_cast<PhiInst *>(inst);
-    SSAPValue phiResult = SSAPValue(); // 初始为 Top
-
-    for (unsigned i = 0; i < phi->getNumIncomingValues(); ++i) {
-      Value *incomingVal = phi->getIncomingValue(i);
-      BasicBlock *incomingBlock = phi->getIncomingBlock(i);
-
-      if (executableBlocks.count(incomingBlock)) { // 仅考虑可执行前驱
-        phiResult = Meet(phiResult, GetValueState(incomingVal));
-        if (phiResult.state == LatticeVal::Bottom)
-          break; // 如果已经 Bottom，则提前退出
-      }
-    }
-    newState = phiResult;
-    break;
-  }
-  case Instruction::kAlloca: // 对应 kAlloca
-    // Alloca 分配内存，返回一个指针，其内容是 Bottom
-    newState = SSAPValue(LatticeVal::Bottom);
-    break;
-  case Instruction::kBr:     // 对应 kBr
-  case Instruction::kCondBr: // 对应 kCondBr
-  case Instruction::kReturn: // 对应 kReturn
-  case Instruction::kUnreachable: // 对应 kUnreachable
-    // 终结符指令不产生值
-    newState = SSAPValue(); // 保持 Top
-    break;
-  case Instruction::kMemset:
-    // Memset 不产生值，但有副作用，不进行常量传播
-    newState = SSAPValue(LatticeVal::Bottom);
-    break;
-  default:
-    if (DEBUG) {
-      std::cout << "Unimplemented instruction kind in SCCP: " << inst->getKind() << std::endl;
-    }
-    newState = SSAPValue(LatticeVal::Bottom); // 未知指令保守处理为 Bottom
-    break;
-  }
-  UpdateState(inst, newState);
-
-  // 特殊处理终结符指令，影响 CFG 边的可达性
-  if (inst->isTerminator()) {
-    if (inst->isBranch()) {
-
-      if (inst->isCondBr()) { // 使用 kCondBr
-        CondBrInst *branchInst = static_cast<CondBrInst *>(inst);
-        SSAPValue condVal = GetValueState(branchInst->getOperand(0));
-        if (condVal.state == LatticeVal::Constant) {
-          bool condition_is_true = false;
-          if (condVal.constant_type == ValueType::Integer) {
-            condition_is_true = (std::get<int>(condVal.constantVal) != 0);
-          } else if (condVal.constant_type == ValueType::Float) {
-            condition_is_true = (std::get<float>(condVal.constantVal) != 0.0f);
-          }
-
-          if (condition_is_true) {
-            AddEdgeToWorkList(branchInst->getParent(), branchInst->getThenBlock());
-          } else {
-            AddEdgeToWorkList(branchInst->getParent(), branchInst->getElseBlock());
-          }
-        } else { // 条件是 Top 或 Bottom，两条路径都可能
-          AddEdgeToWorkList(branchInst->getParent(), branchInst->getThenBlock());
-          AddEdgeToWorkList(branchInst->getParent(), branchInst->getElseBlock());
-        }
-      } else { // 无条件分支 (kBr)
-        UncondBrInst *branchInst = static_cast<UncondBrInst *>(inst);
-        AddEdgeToWorkList(branchInst->getParent(), branchInst->getBlock());
-      }
-    }
-  }
-}
-
-// 辅助函数：处理单条控制流边
-void SCCPContext::ProcessEdge(const std::pair<BasicBlock *, BasicBlock *> &edge) {
-  BasicBlock *fromBB = edge.first;
-  BasicBlock *toBB = edge.second;
-
-  MarkBlockExecutable(toBB);
-
-  // 对于目标块中的所有 Phi 指令，重新评估其值，因为可能有新的前驱被激活
-  for (auto &inst_ptr : toBB->getInstructions()) {
-    if (dynamic_cast<PhiInst *>(inst_ptr.get())) {
-      instWorkList.push(inst_ptr.get());
-    }
-  }
-}
-
-// 阶段1: 常量传播与折叠
-bool SCCPContext::PropagateConstants(Function *func) {
-  bool changed = false;
-
-  // 初始化：所有值 Top，所有块不可执行
-  for (auto &bb_ptr : func->getBasicBlocks()) {
-    executableBlocks.erase(bb_ptr.get());
-    for (auto &inst_ptr : bb_ptr->getInstructions()) {
-      valueState[inst_ptr.get()] = SSAPValue(); // Top
-    }
-  }
-
-  // 标记入口块为可执行
-  if (!func->getBasicBlocks().empty()) {
-    MarkBlockExecutable(func->getEntryBlock());
-  }
-
-  // 主循环：处理工作列表直到不动点
-  while (!instWorkList.empty() || !edgeWorkList.empty()) {
-    while (!edgeWorkList.empty()) {
-      ProcessEdge(edgeWorkList.front());
-      edgeWorkList.pop();
-    }
-
-    while (!instWorkList.empty()) {
-      Instruction *inst = instWorkList.front();
-      instWorkList.pop();
-      ProcessInstruction(inst);
-    }
-  }
-
-  // 应用常量替换和死代码消除
-  std::vector<Instruction *> instsToDelete;
-  for (auto &bb_ptr : func->getBasicBlocks()) {
-    BasicBlock *bb = bb_ptr.get();
-    if (!executableBlocks.count(bb)) {
-      // 整个块是死块，标记所有指令删除
-      for (auto &inst_ptr : bb->getInstructions()) {
-        instsToDelete.push_back(inst_ptr.get());
-      }
-      changed = true;
-      continue;
-    }
-    for (auto it = bb->begin(); it != bb->end();) {
-      Instruction *inst = it->get();
-      SSAPValue ssaPVal = GetValueState(inst);
-
-      if (ssaPVal.state == LatticeVal::Constant) {
-        ConstantValue *constVal = nullptr;
-        if (ssaPVal.constant_type == ValueType::Integer) {
-          constVal = ConstantInteger::get(std::get<int>(ssaPVal.constantVal));
-        } else if (ssaPVal.constant_type == ValueType::Float) {
-          constVal = ConstantFloating::get(std::get<float>(ssaPVal.constantVal));
-        } else {
-          constVal = UndefinedValue::get(inst->getType()); // 不应发生
-        }
-
-        if (DEBUG) {
-          std::cout << "Replacing " << inst->getName() << " with constant ";
-          if (ssaPVal.constant_type == ValueType::Integer)
-            std::cout << std::get<int>(ssaPVal.constantVal);
-          else
-            std::cout << std::get<float>(ssaPVal.constantVal);
-          std::cout << std::endl;
-        }
-        inst->replaceAllUsesWith(constVal);
-        instsToDelete.push_back(inst);
-        ++it;
-        changed = true;
-      } else {
-        // 如果操作数是常量，直接替换为常量值（常量折叠）
-        for (unsigned i = 0; i < inst->getNumOperands(); ++i) {
-          Value *operand = inst->getOperand(i);
-          SSAPValue opVal = GetValueState(operand);
-          if (opVal.state == LatticeVal::Constant) {
-            ConstantValue *constOp = nullptr;
-            if (opVal.constant_type == ValueType::Integer) {
-              constOp = ConstantInteger::get(std::get<int>(opVal.constantVal));
-            } else if (opVal.constant_type == ValueType::Float) {
-              constOp = ConstantFloating::get(std::get<float>(opVal.constantVal));
-            } else {
-              constOp = UndefinedValue::get(operand->getType());
-            }
-
-            if (constOp != operand) {
-              inst->setOperand(i, constOp);
-              changed = true;
-            }
-          }
-        }
-        ++it;
-      }
-    }
-  }
-
-  // 实际删除指令
-  // TODO: 删除的逻辑需要考虑修改
-  for (Instruction *inst : instsToDelete) {
-    // 在尝试删除之前，先检查指令是否仍然附加到其父基本块。
-    // 如果它已经没有父块，可能说明它已被其他方式处理或已处于无效状态。
-    if (inst->getParent() != nullptr) {
-      // 调用负责完整删除的函数，该函数应负责清除uses并将其从父块中移除。
-      SysYIROptUtils::usedelete(inst);
-    } 
-    else {
-        // 指令已不属于任何父块，无需再次删除。
-        if (DEBUG) {
-            std::cerr << "Info: Instruction " << inst->getName() << " was already detached or is not in a parent block." << std::endl;
-        }
-    }
-  }
-  return changed;
-}
-
-// 阶段2: 控制流简化
-bool SCCPContext::SimplifyControlFlow(Function *func) {
-  bool changed = false;
-
-  // 重新确定可达块，因为 PropagateConstants 可能改变了分支条件
-  std::unordered_set<BasicBlock *> newReachableBlocks = FindReachableBlocks(func);
-
-  // 移除不可达块
-  std::vector<BasicBlock *> blocksToDelete;
-  for (auto &bb_ptr : func->getBasicBlocks()) {
-    if (bb_ptr.get() == func->getEntryBlock())
-      continue; // 入口块不能删除
-    if (newReachableBlocks.find(bb_ptr.get()) == newReachableBlocks.end()) {
-      blocksToDelete.push_back(bb_ptr.get());
-      changed = true;
-    }
-  }
-  for (BasicBlock *bb : blocksToDelete) {
-    RemoveDeadBlock(bb, func);
-  }
-
-  // 简化分支指令
-  for (auto &bb_ptr : func->getBasicBlocks()) {
-    BasicBlock *bb = bb_ptr.get();
-    if (!newReachableBlocks.count(bb))
-      continue; // 只处理可达块
-
-    Instruction *terminator = bb->terminator()->get();
-    if (terminator->isBranch()) {
-
-      if (terminator->isCondBr()) { // 检查是否是条件分支 (kCondBr)
-        CondBrInst *branchInst = static_cast<CondBrInst *>(terminator);
-        SSAPValue condVal = GetValueState(branchInst->getOperand(0));
-        if (condVal.state == LatticeVal::Constant) {
-          bool condition_is_true = false;
-          if (condVal.constant_type == ValueType::Integer) {
-            condition_is_true = (std::get<int>(condVal.constantVal) != 0);
-          } else if (condVal.constant_type == ValueType::Float) {
-            condition_is_true = (std::get<float>(condVal.constantVal) != 0.0f);
-          }
-          SimplifyBranch(branchInst, condition_is_true);
-          changed = true;
-        }
-      }
-    }
-  }
-
-  return changed;
-}
-
-// 查找所有可达的基本块 (基于常量条件)
-std::unordered_set<BasicBlock *> SCCPContext::FindReachableBlocks(Function *func) {
-  std::unordered_set<BasicBlock *> reachable;
-  std::queue<BasicBlock *> q;
-
-  if (func->getEntryBlock()) {
-    q.push(func->getEntryBlock());
-    reachable.insert(func->getEntryBlock());
-  }
-
-  while (!q.empty()) {
-    BasicBlock *currentBB = q.front();
-    q.pop();
-
-    Instruction *terminator = currentBB->terminator()->get();
-    if (!terminator)
-      continue;
-
-    if (terminator->isBranch()) {
-      if (terminator->isCondBr()) { // 检查是否是条件分支 (kCondBr)
-        CondBrInst *branchInst = static_cast<CondBrInst *>(terminator);
-        SSAPValue condVal = GetValueState(branchInst->getOperand(0));
-        if (condVal.state == LatticeVal::Constant) {
-          bool condition_is_true = false;
-          if (condVal.constant_type == ValueType::Integer) {
-            condition_is_true = (std::get<int>(condVal.constantVal) != 0);
-          } else if (condVal.constant_type == ValueType::Float) {
-            condition_is_true = (std::get<float>(condVal.constantVal) != 0.0f);
-          }
-
-          if (condition_is_true) {
-            BasicBlock *trueBlock = branchInst->getThenBlock();
-            if (reachable.find(trueBlock) == reachable.end()) {
-              reachable.insert(trueBlock);
-              q.push(trueBlock);
-            }
-          } else {
-            BasicBlock *falseBlock = branchInst->getElseBlock();
-            if (reachable.find(falseBlock) == reachable.end()) {
-              reachable.insert(falseBlock);
-              q.push(falseBlock);
-            }
-          }
-        } else { // 条件是 Top 或 Bottom，两条路径都可达
-          for (auto succ : branchInst->getSuccessors()) {
-            if (reachable.find(succ) == reachable.end()) {
-              reachable.insert(succ);
-              q.push(succ);
-            }
-          }
-        }
-      } else { // 无条件分支 (kBr)
-        UncondBrInst *branchInst = static_cast<UncondBrInst *>(terminator);
-        BasicBlock *targetBlock = branchInst->getBlock();
-        if (reachable.find(targetBlock) == reachable.end()) {
-          reachable.insert(targetBlock);
-          q.push(targetBlock);
-        }
-      }
-    } else if (terminator->isReturn() || terminator->isUnreachable()) {
-      // ReturnInst 没有后继，不需要处理
-      // UnreachableInst 也没有后继，不需要处理
-    }
-  }
-  return reachable;
-}
-
-// 移除死块
-void SCCPContext::RemoveDeadBlock(BasicBlock *bb, Function *func) {
-  if (DEBUG) {
-    std::cout << "Removing dead block: " << bb->getName() << std::endl;
-  }
-  // 首先更新其所有前驱的终结指令，移除指向死块的边
-  std::vector<BasicBlock *> preds_to_update;
-  for (auto &pred : bb->getPredecessors()) {
-    if (pred != nullptr) { // 检查是否为空指针
-        preds_to_update.push_back(pred);
-    }
-  }
-  for (BasicBlock *pred : preds_to_update) {
-    if (executableBlocks.count(pred)) {
-      UpdateTerminator(pred, bb);
-    }
-  }
-
-  // 移除其后继的 Phi 节点的入边
-  std::vector<BasicBlock *> succs_to_update;
-  for (auto succ : bb->getSuccessors()) {
-    succs_to_update.push_back(succ);
-  }
-  for (BasicBlock *succ : succs_to_update) {
-    RemovePhiIncoming(succ, bb);
-    succ->removePredecessor(bb);
-  }
-
-  func->removeBasicBlock(bb); // 从函数中移除基本块
-}
-
-// 简化分支（将条件分支替换为无条件分支）
-void SCCPContext::SimplifyBranch(CondBrInst *brInst, bool condVal) {
-  BasicBlock *parentBB = brInst->getParent();
-  BasicBlock *trueBlock = brInst->getThenBlock();
-  BasicBlock *falseBlock = brInst->getElseBlock();
-
-  if (DEBUG) {
-    std::cout << "Simplifying branch in " << parentBB->getName() << ": cond is " << (condVal ? "true" : "false")
-              << std::endl;
-  }
-
-  builder->setPosition(parentBB, parentBB->findInstIterator(brInst));
-  if (condVal) {                            // 条件为真，跳转到真分支
-    builder->createUncondBrInst(trueBlock); // 插入无条件分支 kBr
-    SysYIROptUtils::usedelete(brInst);      // 移除旧的条件分支指令
-    parentBB->removeSuccessor(falseBlock);
-    falseBlock->removePredecessor(parentBB);
-    RemovePhiIncoming(falseBlock, parentBB);
-  } else {                                   // 条件为假，跳转到假分支
-    builder->createUncondBrInst(falseBlock); // 插入无条件分支 kBr
-    SysYIROptUtils::usedelete(brInst);       // 移除旧的条件分支指令
-    parentBB->removeSuccessor(trueBlock);
-    trueBlock->removePredecessor(parentBB);
-    RemovePhiIncoming(trueBlock, parentBB);
-  }
-}
-
-// 更新前驱块的终结指令（当一个后继块被移除时）
-void SCCPContext::UpdateTerminator(BasicBlock *predBB, BasicBlock *removedSucc) {
-  Instruction *terminator = predBB->terminator()->get();
-  if (!terminator)
-    return;
-
-  if (terminator->isBranch()) {
-    if (terminator->isCondBr()) { // 如果是条件分支
-      CondBrInst *branchInst = static_cast<CondBrInst *>(terminator);
-      if (branchInst->getThenBlock() == removedSucc) {
-        if (DEBUG) {
-          std::cout << "Updating cond br in " << predBB->getName() << ": True block (" << removedSucc->getName()
-                    << ") removed. Converting to Br to " << branchInst->getElseBlock()->getName() << std::endl;
-        }
-        builder->setPosition(predBB, predBB->findInstIterator(branchInst));
-        builder->createUncondBrInst(branchInst->getElseBlock());
-        SysYIROptUtils::usedelete(branchInst);
-        predBB->removeSuccessor(removedSucc);
-      } else if (branchInst->getElseBlock() == removedSucc) {
-        if (DEBUG) {
-          std::cout << "Updating cond br in " << predBB->getName() << ": False block (" << removedSucc->getName()
-                    << ") removed. Converting to Br to " << branchInst->getThenBlock()->getName() << std::endl;
-        }
-        builder->setPosition(predBB, predBB->findInstIterator(branchInst));
-        builder->createUncondBrInst(branchInst->getThenBlock());
-        SysYIROptUtils::usedelete(branchInst);
-        predBB->removeSuccessor(removedSucc);
-      }
-    } else { // 无条件分支 (kBr)
-      UncondBrInst *branchInst = static_cast<UncondBrInst *>(terminator);
-      if (branchInst->getBlock() == removedSucc) {
-        if (DEBUG) {
-          std::cout << "Updating unconditional br in " << predBB->getName() << ": Target block ("
-                    << removedSucc->getName() << ") removed. Replacing with Unreachable." << std::endl;
-        }
-        SysYIROptUtils::usedelete(branchInst);
-        predBB->removeSuccessor(removedSucc);
-        builder->setPosition(predBB, predBB->end());
-        builder->createUnreachableInst();
-      }
-    }
-  }
-}
-
-// 移除 Phi 节点的入边（当其前驱块被移除时）
-void SCCPContext::RemovePhiIncoming(BasicBlock *phiParentBB, BasicBlock *removedPred) { // 修正 removedPred 类型
-  std::vector<Instruction *> insts_to_check;
-  for (auto &inst_ptr : phiParentBB->getInstructions()) {
-    insts_to_check.push_back(inst_ptr.get());
-  }
-
-  for (Instruction *inst : insts_to_check) {
-    if (auto phi = dynamic_cast<PhiInst *>(inst)) {
-      phi->removeIncomingBlock(removedPred);
-    }
-  }
-}
-
-// 运行 SCCP 优化
-void SCCPContext::run(Function *func, AnalysisManager &AM) {
-  bool changed_constant_propagation = PropagateConstants(func);
-  bool changed_control_flow = SimplifyControlFlow(func);
-
-  // 如果任何一个阶段修改了 IR，标记分析结果为失效
-  if (changed_constant_propagation || changed_control_flow) {
-    // AM.invalidate(); // 假设有这样的方法来使所有分析结果失效
-  }
-}
-
-// SCCP Pass methods
-bool SCCP::runOnFunction(Function *F, AnalysisManager &AM) {
-  if (DEBUG) {
-    std::cout << "Running SCCP on function: " << F->getName() << std::endl;
-  }
-  SCCPContext context(builder);
-  context.run(F, AM);
-  return true;
-}
-
-void SCCP::getAnalysisUsage(std::set<void *> &analysisDependencies, std::set<void *> &analysisInvalidations) const {
-  // analysisInvalidations.insert(nullptr); // 表示使所有默认分析失效
-  analysisInvalidations.insert(&DominatorTreeAnalysisPass::ID); // 支配树可能受影响
-  analysisInvalidations.insert(&LivenessAnalysisPass::ID); // 活跃性分析很可能失效
-}
-
-} // namespace sysy

src/midend/Pass/Optimize/SysYIRCFGOpt.cpp

@@ -1,12 +1,12 @@
 #include "SysYIRCFGOpt.h"
 #include "SysYIROptUtils.h"
 #include <cassert>
-#include <iostream>
 #include <list>
 #include <map>
 #include <memory>
-#include <queue> // 引入队列，SysYDelNoPreBLock需要
 #include <string>
+#include <iostream>
+#include <queue> // 引入队列，SysYDelNoPreBLock需要
 
 namespace sysy {
 
@@ -18,6 +18,7 @@ void *SysYBlockMergePass::ID = (void *)&SysYBlockMergePass::ID;
 void *SysYAddReturnPass::ID = (void *)&SysYAddReturnPass::ID;
 void *SysYCondBr2BrPass::ID = (void *)&SysYCondBr2BrPass::ID;
 
+
 // ======================================================================
 // SysYCFGOptUtils: 辅助工具类，包含实际的CFG优化逻辑
 // ======================================================================
@@ -25,42 +26,40 @@ void *SysYCondBr2BrPass::ID = (void *)&SysYCondBr2BrPass::ID;
 // 删除br后的无用指令
 bool SysYCFGOptUtils::SysYDelInstAfterBr(Function *func) {
   bool changed = false;
-
+  
   auto basicBlocks = func->getBasicBlocks();
   for (auto &basicBlock : basicBlocks) {
     bool Branch = false;
     auto &instructions = basicBlock->getInstructions();
     auto Branchiter = instructions.end();
     for (auto iter = instructions.begin(); iter != instructions.end(); ++iter) {
-      if ((*iter)->isTerminator()) {
+      if ((*iter)->isTerminator()){
         Branch = true;
         Branchiter = iter;
         break;
       }
     }
-    if (Branchiter != instructions.end())
-      ++Branchiter;
+    if (Branchiter != instructions.end()) ++Branchiter;
     while (Branchiter != instructions.end()) {
       changed = true;
       Branchiter = instructions.erase(Branchiter);
     }
-
-    if (Branch) { // 更新前驱后继关系
-      auto thelastinstinst = basicBlock->terminator();
+    
+    if (Branch) {  // 更新前驱后继关系
+      auto thelastinstinst = basicBlock->getInstructions().end();
+      --thelastinstinst;
       auto &Successors = basicBlock->getSuccessors();
       for (auto iterSucc = Successors.begin(); iterSucc != Successors.end();) {
         (*iterSucc)->removePredecessor(basicBlock.get());
         basicBlock->removeSuccessor(*iterSucc);
       }
       if (thelastinstinst->get()->isUnconditional()) {
-        auto brinst = dynamic_cast<UncondBrInst *>(thelastinstinst->get());
-        BasicBlock *branchBlock = dynamic_cast<BasicBlock *>(brinst->getBlock());
+        BasicBlock* branchBlock = dynamic_cast<BasicBlock *>(thelastinstinst->get()->getOperand(0));
         basicBlock->addSuccessor(branchBlock);
         branchBlock->addPredecessor(basicBlock.get());
       } else if (thelastinstinst->get()->isConditional()) {
-        auto brinst = dynamic_cast<CondBrInst *>(thelastinstinst->get());
-        BasicBlock *thenBlock = dynamic_cast<BasicBlock *>(brinst->getThenBlock());
-        BasicBlock *elseBlock = dynamic_cast<BasicBlock *>(brinst->getElseBlock());
+        BasicBlock* thenBlock = dynamic_cast<BasicBlock *>(thelastinstinst->get()->getOperand(1));
+        BasicBlock* elseBlock = dynamic_cast<BasicBlock *>(thelastinstinst->get()->getOperand(2));
         basicBlock->addSuccessor(thenBlock);
         basicBlock->addSuccessor(elseBlock);
         thenBlock->addPredecessor(basicBlock.get());
@@ -76,27 +75,29 @@ bool SysYCFGOptUtils::SysYDelInstAfterBr(Function *func) {
 bool SysYCFGOptUtils::SysYBlockMerge(Function *func) {
   bool changed = false;
 
-  for (auto blockiter = func->getBasicBlocks().begin(); blockiter != func->getBasicBlocks().end();) {
+  for (auto blockiter = func->getBasicBlocks().begin();
+        blockiter != func->getBasicBlocks().end();) {
     if (blockiter->get()->getNumSuccessors() == 1) {
       // 如果当前块只有一个后继块
       // 且后继块只有一个前驱块
       // 则将当前块和后继块合并
       if (((blockiter->get())->getSuccessors()[0])->getNumPredecessors() == 1) {
         // std::cout << "merge block: " << blockiter->get()->getName() << std::endl;
-        BasicBlock *block = blockiter->get();
-        BasicBlock *nextBlock = blockiter->get()->getSuccessors()[0];
+        BasicBlock* block = blockiter->get();
+        BasicBlock* nextBlock = blockiter->get()->getSuccessors()[0];
         // auto nextarguments = nextBlock->getArguments();
         // 删除br指令
         if (block->getNumInstructions() != 0) {
-          auto thelastinstinst = block->terminator();
+          auto thelastinstinst = block->end();
+          (--thelastinstinst);
           if (thelastinstinst->get()->isUnconditional()) {
-            thelastinstinst = SysYIROptUtils::usedelete(thelastinstinst);
+            SysYIROptUtils::usedelete(thelastinstinst->get());
+            thelastinstinst = block->getInstructions().erase(thelastinstinst);
           } else if (thelastinstinst->get()->isConditional()) {
-            // 按道理不会走到这个分支
-            // 如果是条件分支，查看then else是否相同
-            auto brinst = dynamic_cast<CondBrInst *>(thelastinstinst->get());
-            if (brinst->getThenBlock() == brinst->getElseBlock()) {
-              thelastinstinst = SysYIROptUtils::usedelete(thelastinstinst);
+            // 如果是条件分支，判断条件是否相同，主要优化相同布尔表达式
+            if (thelastinstinst->get()->getOperand(1)->getName() == thelastinstinst->get()->getOperand(1)->getName()) {
+              SysYIROptUtils::usedelete(thelastinstinst->get());
+              thelastinstinst = block->getInstructions().erase(thelastinstinst); 
             }
           }
         }
@@ -105,7 +106,7 @@ bool SysYCFGOptUtils::SysYBlockMerge(Function *func) {
         for (auto institer = nextBlock->begin(); institer != nextBlock->end();) {
           institer->get()->setParent(block);
           block->getInstructions().emplace_back(institer->release());
-          institer = nextBlock->getInstructions().erase(institer);
+          institer = nextBlock->getInstructions().erase(institer);   
         }
         // 更新前驱后继关系，类似树节点操作
         block->removeSuccessor(nextBlock);
@@ -136,434 +137,323 @@ bool SysYCFGOptUtils::SysYBlockMerge(Function *func) {
 
 // 删除无前驱块，兼容SSA后的处理
 bool SysYCFGOptUtils::SysYDelNoPreBLock(Function *func) {
-  bool changed = false;                   // 标记是否有基本块被删除
-  std::set<BasicBlock *> reachableBlocks; // 用于存储所有可达的基本块
-  std::queue<BasicBlock *> blockQueue;    // BFS 遍历队列
-
-  BasicBlock *entryBlock = func->getEntryBlock();
-  if (entryBlock) {                     // 确保函数有入口块
-    reachableBlocks.insert(entryBlock); // 将入口块标记为可达
-    blockQueue.push(entryBlock);        // 入口块入队
-  }
-  // 如果没有入口块（比如一个空函数），则没有块是可达的，所有块都将被删除。
-
-  while (!blockQueue.empty()) { // BFS 遍历：只要队列不空
-    BasicBlock *currentBlock = blockQueue.front();
-    blockQueue.pop(); // 取出当前块
-
-    for (auto &succ : currentBlock->getSuccessors()) { // 遍历当前块的所有后继
-      // 如果后继块不在 reachableBlocks 中（即尚未被访问过）
-      if (reachableBlocks.find(succ) == reachableBlocks.end()) {
-        reachableBlocks.insert(succ); // 标记为可达
-        blockQueue.push(succ);        // 入队，以便继续遍历
-      }
-    }
-  }
-
-  std::vector<BasicBlock *> blocksToDelete; // 用于存储所有不可达的基本块
-
-  for (auto &blockPtr : func->getBasicBlocks()) {
-    BasicBlock *block = blockPtr.get();
-    // 如果当前块不在 reachableBlocks 集合中，说明它是不可达的
-    if (reachableBlocks.find(block) == reachableBlocks.end()) {
-      blocksToDelete.push_back(block); // 将其加入待删除列表
-      changed = true;                  // 只要找到一个不可达块，就说明函数发生了改变
-    }
-  }
-
-  for (BasicBlock *unreachableBlock : blocksToDelete) {
-    // 遍历不可达块中的所有指令，并删除它们
-    for (auto instIter = unreachableBlock->getInstructions().begin();
-         instIter != unreachableBlock->getInstructions().end();) {
-      instIter = SysYIROptUtils::usedelete(instIter);
-    }
-  }
-
-  for (BasicBlock *unreachableBlock : blocksToDelete) {
-    for (BasicBlock *succBlock : unreachableBlock->getSuccessors()) {
-      // 只有当后继块自身是可达的（没有被删除）时才需要处理
-      if (reachableBlocks.count(succBlock)) {
-        for (auto &phiInstPtr : succBlock->getInstructions()) {
-          // Phi 指令总是在基本块的开头。一旦遇到非 Phi 指令即可停止。
-          if (phiInstPtr->getKind() != Instruction::kPhi) {
-            break;
-          }
-          // 将这个 Phi 节点中来自不可达前驱（unreachableBlock）的输入参数删除
-          dynamic_cast<PhiInst *>(phiInstPtr.get())->removeIncomingBlock(unreachableBlock);
-        }
-      }
-    }
-  }
-
-  for (auto blockIter = func->getBasicBlocks().begin(); blockIter != func->getBasicBlocks().end();) {
-    BasicBlock *currentBlock = blockIter->get();
-    // 如果当前块不在可达块集合中，则将其从函数中移除
-    if (reachableBlocks.find(currentBlock) == reachableBlocks.end()) {
-      // func->removeBasicBlock 应该返回下一个有效的迭代器
-      func->removeBasicBlock((blockIter++)->get());
-    } else {
-      blockIter++; // 如果可达，则移动到下一个块
-    }
-  }
-
-  return changed;
-}
-
-bool SysYCFGOptUtils::SysYDelEmptyBlock(Function *func, IRBuilder *pBuilder) {
+  
   bool changed = false;
 
-  // 步骤 1: 识别并映射所有符合“空块”定义的基本块及其目标后继
-  // 使用 std::map 来存储 <空块, 空块跳转目标>
-  // 这样可以处理空块链：A -> B -> C，如果 B 是空块，A 应该跳到 C
-  std::map<BasicBlock *, BasicBlock *> emptyBlockRedirectMap;
-
-  // 为了避免在遍历 func->getBasicBlocks() 时修改它导致迭代器失效，
-  // 我们先收集所有的基本块。
-  std::vector<BasicBlock *> allBlocks;
-  for (auto &blockPtr : func->getBasicBlocks()) {
-    allBlocks.push_back(blockPtr.get());
+  for (auto &block : func->getBasicBlocks()) {
+    block->setreachableFalse();
   }
-
-  for (BasicBlock *block : allBlocks) {
-    // 入口块通常不应该被认为是空块并删除，除非它没有实际指令且只有一个后继，
-    // 但为了安全起见，通常会跳过入口块的删除。
-    // 如果入口块是空的，它应该被合并到它的后继，但处理起来更复杂，这里先不处理入口块为空的情况
-    if (block == func->getEntryBlock()) {
-      continue;
-    }
-
-    // 检查基本块是否是空的：除了Phi指令外，只包含一个终止指令 (Terminator)
-    // 且该终止指令必须是无条件跳转。
-    // 空块必须只有一个后继才能被简化
-    if (block->getNumSuccessors() == 1) {
-      bool hasNonPhiNonTerminator = false;
-      // 遍历除了最后一个指令之外的指令
-      for (auto instIter = block->getInstructions().begin(); instIter != block->getInstructions().end();) {
-        // 如果是终止指令（例如 br, ret），且不是最后一个指令，则该块有问题
-        if ((*instIter)->isTerminator() && instIter != block->terminator()) {
-          hasNonPhiNonTerminator = true;
-          break;
-        }
-        // 如果不是 Phi 指令且不是终止指令
-        if (!(*instIter)->isPhi() && !(*instIter)->isTerminator()) {
-          hasNonPhiNonTerminator = true;
-          break;
-        }
-        ++instIter;
-        if (!hasNonPhiNonTerminator &&
-            instIter == block->getInstructions().end()) { // 如果块中只有 Phi 指令和一个 Terminator
-          // 确保最后一个指令是无条件跳转
-          auto lastInst = block->terminator()->get();
-          if (lastInst && lastInst->isUnconditional()) {
-            emptyBlockRedirectMap[block] = block->getSuccessors().front();
-          }
-        }
+  // 对函数基本块做一个拓扑排序，排查不可达基本块
+  auto entryBlock = func->getEntryBlock();
+  entryBlock->setreachableTrue();
+  std::queue<BasicBlock *> blockqueue;
+  blockqueue.push(entryBlock);
+  while (!blockqueue.empty()) {
+    auto block = blockqueue.front();
+    blockqueue.pop();
+    for (auto &succ : block->getSuccessors()) {
+      if (!succ->getreachable()) {
+        succ->setreachableTrue();
+        blockqueue.push(succ);
       }
     }
   }
 
-  // 步骤 2: 遍历 emptyBlockRedirectMap，处理空块链
-  // 确保每个空块都直接重定向到其最终的非空后继块
-  for (auto const &[emptyBlock, directSucc] : emptyBlockRedirectMap) {
-    BasicBlock *targetBlock = directSucc;
-    // 沿着空块链一直找到最终的非空块目标
-    while (emptyBlockRedirectMap.count(targetBlock)) {
-      targetBlock = emptyBlockRedirectMap[targetBlock];
-    }
-    emptyBlockRedirectMap[emptyBlock] = targetBlock; // 更新映射到最终目标
-  }
-
-  // 步骤 3: 遍历所有基本块，重定向其终止指令，绕过空块
-  // 注意：这里需要再次遍历所有块，包括可能成为新目标的块
-  for (BasicBlock *currentBlock : allBlocks) {
-    // 如果 currentBlock 本身就是个空块，它会通过其前驱的重定向被处理，这里跳过
-    if (emptyBlockRedirectMap.count(currentBlock)) {
-      continue;
-    }
-
-    // 获取当前块的最后一个指令（终止指令）
-    if (currentBlock->getInstructions().empty()) {
-      // 理论上，除了入口块和可能被合并的空块外，所有块都应该有终止指令
-      // 如果这里碰到空块，可能是逻辑错误或者需要特殊处理
-      continue;
-    }
-
-    std::function<Value *(Value *, BasicBlock *)> getUltimateSourceValue = [&](Value *val,
-                                                                               BasicBlock *currentDefBlock) -> Value * {
-      // 如果值不是指令，例如常量或函数参数，则它本身就是最终来源
-      if (auto instr = dynamic_cast<Instruction *>(val)) { // Assuming Value* has a method to check if it's an instruction
-        return val;
-      }
-
-      Instruction *inst = dynamic_cast<Instruction *>(val);
-      // 如果定义指令不在任何空块中，它就是最终来源
-      if (!emptyBlockRedirectMap.count(currentDefBlock)) {
-        return val;
-      }
-
-      // 如果是 Phi 指令，且它在空块中，则继续追溯其在空块链中前驱的传入值
-      if (inst->getKind() == Instruction::kPhi) {
-        PhiInst *phi = dynamic_cast<PhiInst *>(inst);
-        // 查找哪个前驱是空块链中的上一个块
-        for (size_t i = 0; i < phi->getNumOperands(); i += 2) {
-          BasicBlock *incomingBlock = dynamic_cast<BasicBlock *>(phi->getOperand(i + 1));
-          // 检查 incomingBlock 是否是当前空块的前驱，且也在空块映射中（或就是 P）
-          // 找到在空块链中导致 currentDefBlock 的那个前驱块
-          if (emptyBlockRedirectMap.count(incomingBlock) || incomingBlock == currentBlock) {
-            // 递归追溯该传入值
-            return getUltimateSourceValue(phi->getValfromBlk(incomingBlock), incomingBlock);
-          }
-        }
-      }
-      // 如果是其他指令或者无法追溯到Phi链，则认为它在空块中产生，无法安全传播，返回null或原值
-      // 在严格的空块定义下，除了Phi和Terminator，不应有其他指令产生值。
-      return val; // Fallback: If not a Phi, or unable to trace, return itself (may be dangling)
-    };
-
-    auto lastInst = currentBlock->getInstructions().back().get();
-
-    if (lastInst->isUnconditional()) { // 无条件跳转
-      UncondBrInst *brInst = dynamic_cast<UncondBrInst *>(lastInst);
-      BasicBlock *oldTarget = dynamic_cast<BasicBlock *>(brInst->getBlock()); // 原始跳转目标
-
-      if (emptyBlockRedirectMap.count(oldTarget)) {               // 如果目标是空块
-        BasicBlock *newTarget = emptyBlockRedirectMap[oldTarget]; // 获取最终目标
-
-        // 更新 CFG 关系
-        currentBlock->removeSuccessor(oldTarget);
-        oldTarget->removePredecessor(currentBlock);
-
-        brInst->replaceOperand(0, newTarget); // 更新跳转指令的操作数
-        currentBlock->addSuccessor(newTarget);
-        newTarget->addPredecessor(currentBlock);
-
-        changed = true; // 标记发生改变
-
-        for (auto &phiInstPtr : newTarget->getInstructions()) {
-          if (phiInstPtr->getKind() == Instruction::kPhi) {
-            PhiInst *phiInst = dynamic_cast<PhiInst *>(phiInstPtr.get());
-            BasicBlock *actualEmptyPredecessorOfS = nullptr;
-            for (size_t i = 0; i < phiInst->getNumOperands(); i += 2) {
-              BasicBlock *incomingBlock = dynamic_cast<BasicBlock *>(phiInst->getOperand(i + 1));
-              if (incomingBlock && emptyBlockRedirectMap.count(incomingBlock) &&
-                  emptyBlockRedirectMap[incomingBlock] == newTarget) {
-                actualEmptyPredecessorOfS = incomingBlock;
-                break;
-              }
-            }
-
-            if (actualEmptyPredecessorOfS) {
-              // 获取 Phi 节点原本从 actualEmptyPredecessorOfS 接收的值
-              Value *valueFromEmptyPredecessor = phiInst->getValfromBlk(actualEmptyPredecessorOfS);
-
-              // 追溯这个值，找到它在非空块中的最终来源
-              // currentBlock 是 P
-              // oldTarget 是 E1 (链的起点)
-              // actualEmptyPredecessorOfS 是 En (链的终点，S 的前驱)
-              Value *ultimateSourceValue = getUltimateSourceValue(valueFromEmptyPredecessor, actualEmptyPredecessorOfS);
-
-              // 替换 Phi 节点的传入块和传入值
-              if (ultimateSourceValue) { // 确保成功追溯到有效来源
-                // phiInst->replaceIncoming(actualEmptyPredecessorOfS, currentBlock, ultimateSourceValue);
-                phiInst->replaceIncomingBlock(actualEmptyPredecessorOfS, currentBlock, ultimateSourceValue);
-              } else {
-                assert(false && "[DelEmptyBlock] Unable to trace a valid source for Phi instruction");
-                // 无法追溯到有效来源，这可能是个错误或特殊情况
-                // 此时可能需要移除该 Phi 项，或者插入一个 undef 值
-                phiInst->getValfromBlk(actualEmptyPredecessorOfS);
-              }
-            }
-          } else {
-            break;
-          }
-        }
-      }
-
-    } else if (lastInst->getKind() == Instruction::kCondBr) { // 条件跳转
-      CondBrInst *condBrInst = dynamic_cast<CondBrInst *>(lastInst);
-      BasicBlock *oldThenTarget = dynamic_cast<BasicBlock *>(condBrInst->getThenBlock());
-      BasicBlock *oldElseTarget = dynamic_cast<BasicBlock *>(condBrInst->getElseBlock());
-
-      bool thenPathChanged = false;
-      bool elsePathChanged = false;
-
-      // 处理 Then 分支
-      if (emptyBlockRedirectMap.count(oldThenTarget)) {
-        BasicBlock *newThenTarget = emptyBlockRedirectMap[oldThenTarget];
-        condBrInst->replaceOperand(1, newThenTarget); // 更新跳转指令操作数
-
-        currentBlock->removeSuccessor(oldThenTarget);
-        oldThenTarget->removePredecessor(currentBlock);
-        currentBlock->addSuccessor(newThenTarget);
-        newThenTarget->addPredecessor(currentBlock);
-        thenPathChanged = true;
-        changed = true;
-
-        // 处理新 Then 目标块中的 Phi 指令
-        // for (auto &phiInstPtr : newThenTarget->getInstructions()) {
-        //   if (phiInstPtr->getKind() == Instruction::kPhi) {
-        //     dynamic_cast<PhiInst *>(phiInstPtr.get())->delBlk(oldThenTarget);
-        //   } else {
-        //     break;
-        //   }
-        // }
-        for (auto &phiInstPtr : newThenTarget->getInstructions()) {
-          if (phiInstPtr->getKind() == Instruction::kPhi) {
-            PhiInst *phiInst = dynamic_cast<PhiInst *>(phiInstPtr.get());
-            BasicBlock *actualEmptyPredecessorOfS = nullptr;
-            for (size_t i = 0; i < phiInst->getNumOperands(); i += 2) {
-              BasicBlock *incomingBlock = dynamic_cast<BasicBlock *>(phiInst->getOperand(i + 1));
-              if (incomingBlock && emptyBlockRedirectMap.count(incomingBlock) &&
-                  emptyBlockRedirectMap[incomingBlock] == newThenTarget) {
-                actualEmptyPredecessorOfS = incomingBlock;
-                break;
-              }
-            }
-
-            if (actualEmptyPredecessorOfS) {
-              // 获取 Phi 节点原本从 actualEmptyPredecessorOfS 接收的值
-              Value *valueFromEmptyPredecessor = phiInst->getValfromBlk(actualEmptyPredecessorOfS);
-
-              // 追溯这个值，找到它在非空块中的最终来源
-              // currentBlock 是 P
-              // oldTarget 是 E1 (链的起点)
-              // actualEmptyPredecessorOfS 是 En (链的终点，S 的前驱)
-              Value *ultimateSourceValue = getUltimateSourceValue(valueFromEmptyPredecessor, actualEmptyPredecessorOfS);
-
-              // 替换 Phi 节点的传入块和传入值
-              if (ultimateSourceValue) { // 确保成功追溯到有效来源
-                // phiInst->replaceIncoming(actualEmptyPredecessorOfS, currentBlock, ultimateSourceValue);
-                phiInst->replaceIncomingBlock(actualEmptyPredecessorOfS, currentBlock, ultimateSourceValue);
-              } else {
-                assert(false && "[DelEmptyBlock] Unable to trace a valid source for Phi instruction");
-                // 无法追溯到有效来源，这可能是个错误或特殊情况
-                // 此时可能需要移除该 Phi 项，或者插入一个 undef 值
-                phiInst->removeIncomingBlock(actualEmptyPredecessorOfS);
-              }
-            }
-          } else {
-            break;
-          }
-        }
-
-      }
-
-      // 处理 Else 分支
-      if (emptyBlockRedirectMap.count(oldElseTarget)) {
-        BasicBlock *newElseTarget = emptyBlockRedirectMap[oldElseTarget];
-        condBrInst->replaceOperand(2, newElseTarget); // 更新跳转指令操作数
-
-        currentBlock->removeSuccessor(oldElseTarget);
-        oldElseTarget->removePredecessor(currentBlock);
-        currentBlock->addSuccessor(newElseTarget);
-        newElseTarget->addPredecessor(currentBlock);
-        elsePathChanged = true;
-        changed = true;
-
-        // 处理新 Else 目标块中的 Phi 指令
-        // for (auto &phiInstPtr : newElseTarget->getInstructions()) {
-        //   if (phiInstPtr->getKind() == Instruction::kPhi) {
-        //     dynamic_cast<PhiInst *>(phiInstPtr.get())->delBlk(oldElseTarget);
-        //   } else {
-        //     break;
-        //   }
-        // }
-        for (auto &phiInstPtr : newElseTarget->getInstructions()) {
-          if (phiInstPtr->getKind() == Instruction::kPhi) {
-            PhiInst *phiInst = dynamic_cast<PhiInst *>(phiInstPtr.get());
-            BasicBlock *actualEmptyPredecessorOfS = nullptr;
-            for (size_t i = 0; i < phiInst->getNumOperands(); i += 2) {
-              BasicBlock *incomingBlock = dynamic_cast<BasicBlock *>(phiInst->getOperand(i + 1));
-              if (incomingBlock && emptyBlockRedirectMap.count(incomingBlock) &&
-                  emptyBlockRedirectMap[incomingBlock] == newElseTarget) {
-                actualEmptyPredecessorOfS = incomingBlock;
-                break;
-              }
-            }
-
-            if (actualEmptyPredecessorOfS) {
-              // 获取 Phi 节点原本从 actualEmptyPredecessorOfS 接收的值
-              Value *valueFromEmptyPredecessor = phiInst->getValfromBlk(actualEmptyPredecessorOfS);
-
-              // 追溯这个值，找到它在非空块中的最终来源
-              // currentBlock 是 P
-              // oldTarget 是 E1 (链的起点)
-              // actualEmptyPredecessorOfS 是 En (链的终点，S 的前驱)
-              Value *ultimateSourceValue = getUltimateSourceValue(valueFromEmptyPredecessor, actualEmptyPredecessorOfS);
-
-              // 替换 Phi 节点的传入块和传入值
-              if (ultimateSourceValue) { // 确保成功追溯到有效来源
-                // phiInst->replaceIncoming(actualEmptyPredecessorOfS, currentBlock, ultimateSourceValue);
-                phiInst->replaceIncomingBlock(actualEmptyPredecessorOfS, currentBlock, ultimateSourceValue);
-              } else {
-                assert(false && "[DelEmptyBlock] Unable to trace a valid source for Phi instruction");
-                // 无法追溯到有效来源，这可能是个错误或特殊情况
-                // 此时可能需要移除该 Phi 项，或者插入一个 undef 值
-                phiInst->removeIncomingBlock(actualEmptyPredecessorOfS);
-              }
-            }
-          } else {
-            break;
-          }
-        }
-      }
-
-      // 额外处理：如果条件跳转的两个分支现在指向同一个块，则可以简化为无条件跳转
-      if (condBrInst->getThenBlock() == condBrInst->getElseBlock()) {
-        BasicBlock *commonTarget = dynamic_cast<BasicBlock *>(condBrInst->getThenBlock());
-        SysYIROptUtils::usedelete(lastInst); // 删除旧的条件跳转指令
-        pBuilder->setPosition(currentBlock, currentBlock->end());
-        pBuilder->createUncondBrInst(commonTarget); // 插入新的无条件跳转指令
-
-        // 更安全地更新 CFG 关系
-        std::set<BasicBlock *> currentSuccessors;
-        currentSuccessors.insert(oldThenTarget);
-        currentSuccessors.insert(oldElseTarget);
-
-        // 移除旧的后继关系
-        for (BasicBlock *succ : currentSuccessors) {
-          currentBlock->removeSuccessor(succ);
-          succ->removePredecessor(currentBlock);
-        }
-        // 添加新的后继关系
-        currentBlock->addSuccessor(commonTarget);
-        commonTarget->addPredecessor(currentBlock);
-
-        changed = true;
+  // 删除不可达基本块指令
+  for (auto blockIter = func->getBasicBlocks().begin(); blockIter != func->getBasicBlocks().end(); blockIter++) {
+    if (!blockIter->get()->getreachable()) {
+      for (auto instIter = blockIter->get()->getInstructions().begin();
+          instIter != blockIter->get()->getInstructions().end();) {
+        SysYIROptUtils::usedelete(instIter->get());
+        instIter = blockIter->get()->getInstructions().erase(instIter);
       }
     }
   }
 
-  // 步骤 4: 真正地删除空基本块
-  // 注意：只能在所有跳转和 Phi 指令都更新完毕后才能删除这些块
+  
   for (auto blockIter = func->getBasicBlocks().begin(); blockIter != func->getBasicBlocks().end();) {
-    BasicBlock *currentBlock = blockIter->get();
-    if (emptyBlockRedirectMap.count(currentBlock)) { // 如果在空块映射中
-      // 入口块不应该被删除，即使它符合空块定义，因为函数需要一个入口
-      if (currentBlock == func->getEntryBlock()) {
-        ++blockIter;
-        continue;
+    if (!blockIter->get()->getreachable()) {
+      for (auto succblock : blockIter->get()->getSuccessors()) {
+        for (auto &phiinst : succblock->getInstructions()) {
+        if (phiinst->getKind() != Instruction::kPhi) {
+          break;
+        }
+          // 使用 delBlk 方法正确地删除对应于被删除基本块的传入值
+          dynamic_cast<PhiInst *>(phiinst.get())->delBlk(blockIter->get());
+        }
       }
-
-      // 在删除块之前，确保其内部指令被正确删除（虽然这类块指令很少）
-      for (auto instIter = currentBlock->getInstructions().begin();
-           instIter != currentBlock->getInstructions().end();) {
-        instIter = SysYIROptUtils::usedelete(instIter);
-      }
-
-      // 移除块
+      // 删除不可达基本块，注意迭代器不可达问题
       func->removeBasicBlock((blockIter++)->get());
       changed = true;
     } else {
-      ++blockIter;
+      blockIter++;
+    }
+  }
+  
+  return changed;
+}
+
+// 删除空块
+bool SysYCFGOptUtils::SysYDelEmptyBlock(Function *func, IRBuilder* pBuilder) {
+  bool changed = false;
+
+  // 收集不可达基本块
+  // 这里的不可达基本块是指没有实际指令的基本块
+  // 当一个基本块没有实际指令例如只有phi指令和一个uncondbr指令时，也会被视作不可达
+  auto basicBlocks = func->getBasicBlocks();
+  std::map<sysy::BasicBlock *, BasicBlock *> EmptyBlocks;
+  // 空块儿和后继的基本块的映射
+  for (auto &basicBlock : basicBlocks) {
+    if (basicBlock->getNumInstructions() == 0) {
+      if (basicBlock->getNumSuccessors() == 1) {
+        EmptyBlocks[basicBlock.get()] = basicBlock->getSuccessors().front();
+      }
+    }
+    else{
+      // 如果只有phi指令和一个uncondbr。(phi)*(uncondbr)?
+        // 判断除了最后一个指令之外是不是只有phi指令
+      bool onlyPhi = true;
+      for (auto &inst : basicBlock->getInstructions()) {
+        if (!inst->isPhi() && !inst->isUnconditional()) {
+          onlyPhi = false;
+          break;
+        }
+      }
+      if(onlyPhi && basicBlock->getNumSuccessors() == 1) // 确保有后继且只有一个
+        EmptyBlocks[basicBlock.get()] = basicBlock->getSuccessors().front();
+    }
+  }
+  // 更新基本块信息，增加必要指令
+  for (auto &basicBlock : basicBlocks) {
+    // 把空块转换成只有跳转指令的不可达块 (这段逻辑在优化遍中可能需要调整，这里是原样保留)
+    // 通常，DelEmptyBlock 应该在BlockMerge之后运行，如果存在完全空块，它会尝试填充一个Br指令。
+    // 但是，它主要目的是重定向跳转。
+    if (distance(basicBlock->begin(), basicBlock->end()) == 0) {
+      if (basicBlock->getNumSuccessors() == 0) {
+        continue;
+      }
+      if (basicBlock->getNumSuccessors() > 1) {
+        // 如果一个空块有多个后继，说明CFG结构有问题或者需要特殊处理，这里简单assert
+        assert(false && "Empty block with multiple successors found during SysYDelEmptyBlock");
+      }
+      // 这里的逻辑有点问题，如果一个块是空的，且只有一个后继，应该直接跳转到后继。
+      // 如果这个块最终被删除了，那么其前驱也需要重定向。
+      // 这个循环的目的是重定向现有的跳转指令，而不是创建新的。
+      // 所以下面的逻辑才是核心。
+      // pBuilder->setPosition(basicBlock.get(), basicBlock->end());
+      // pBuilder->createUncondBrInst(basicBlock->getSuccessors()[0], {});
+      continue;
+    }
+
+    auto thelastinst = basicBlock->getInstructions().end();
+    --thelastinst;
+
+    // 根据br指令传递的后继块信息，跳过空块链
+    if (thelastinst->get()->isUnconditional()) {
+      BasicBlock* OldBrBlock = dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0));
+      BasicBlock *thelastBlockOld = nullptr;
+      // 如果空块链表为多个块
+      while (EmptyBlocks.count(dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0)))) {
+        thelastBlockOld = dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0));
+        thelastinst->get()->replaceOperand(0, EmptyBlocks[thelastBlockOld]);
+      }
+
+      // 如果有重定向发生
+      if (thelastBlockOld != nullptr) {
+          basicBlock->removeSuccessor(OldBrBlock);
+          OldBrBlock->removePredecessor(basicBlock.get());
+          basicBlock->addSuccessor(dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0)));
+          dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0))->addPredecessor(basicBlock.get());
+          changed = true; // 标记IR被修改
+      }
+
+
+      if (thelastBlockOld != nullptr) {
+        for (auto &InstInNew : dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0))->getInstructions()) {
+        if (InstInNew->isPhi()) {
+          // 使用 delBlk 方法删除 oldBlock 对应的传入值
+          dynamic_cast<PhiInst *>(InstInNew.get())->delBlk(thelastBlockOld);
+        } else {
+          break;
+        }
+  }
+      }
+
+    } else if (thelastinst->get()->getKind() == Instruction::kCondBr) {
+      auto OldThenBlock = dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1));
+      auto OldElseBlock = dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2));
+      bool thenChanged = false;
+      bool elseChanged = false;
+
+
+      BasicBlock *thelastBlockOld = nullptr;
+      while (EmptyBlocks.count(dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1)))) {
+        thelastBlockOld = dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1));
+        thelastinst->get()->replaceOperand(
+            1, EmptyBlocks[dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1))]);
+        thenChanged = true;
+      }
+
+      if (thenChanged) {
+        basicBlock->removeSuccessor(OldThenBlock);
+        OldThenBlock->removePredecessor(basicBlock.get());
+        basicBlock->addSuccessor(dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1)));
+        dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1))->addPredecessor(basicBlock.get());
+        changed = true; // 标记IR被修改
+      }
+      
+      // 处理 then 和 else 分支合并的情况
+      if (dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1)) ==
+          dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2))) {
+        auto thebrBlock = dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1));
+        SysYIROptUtils::usedelete(thelastinst->get());
+        thelastinst = basicBlock->getInstructions().erase(thelastinst);
+        pBuilder->setPosition(basicBlock.get(), basicBlock->end());
+        pBuilder->createUncondBrInst(thebrBlock, {});
+        changed = true; // 标记IR被修改
+        continue;
+      }
+      
+      if (thelastBlockOld != nullptr) {
+        for (auto &InstInNew : dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1))->getInstructions()) {
+          if (InstInNew->isPhi()) {
+            // 使用 delBlk 方法删除 oldBlock 对应的传入值
+            dynamic_cast<PhiInst *>(InstInNew.get())->delBlk(thelastBlockOld);
+          } else {
+            break;
+          }
+       }
+      }
+
+      thelastBlockOld = nullptr;
+      while (EmptyBlocks.count(dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2)))) {
+        thelastBlockOld = dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2));
+        thelastinst->get()->replaceOperand(
+            2, EmptyBlocks[dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2))]);
+        elseChanged = true;
+      }
+      
+      if (elseChanged) {
+        basicBlock->removeSuccessor(OldElseBlock);
+        OldElseBlock->removePredecessor(basicBlock.get());
+        basicBlock->addSuccessor(dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2)));
+        dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2))->addPredecessor(basicBlock.get());
+        changed = true; // 标记IR被修改
+      }
+
+      // 处理 then 和 else 分支合并的情况
+      if (dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1)) ==
+          dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2))) {
+        auto thebrBlock = dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1));
+        SysYIROptUtils::usedelete(thelastinst->get());
+        thelastinst = basicBlock->getInstructions().erase(thelastinst);
+        pBuilder->setPosition(basicBlock.get(), basicBlock->end());
+        pBuilder->createUncondBrInst(thebrBlock, {});
+        changed = true; // 标记IR被修改
+        continue;
+      }
+      
+
+      // 如果有重定向发生
+      // 需要更新后继块的前驱关系
+      if (thelastBlockOld != nullptr) {
+        for (auto &InstInNew : dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2))->getInstructions()) {
+          if (InstInNew->isPhi()) {
+            // 使用 delBlk 方法删除 oldBlock 对应的传入值
+            dynamic_cast<PhiInst *>(InstInNew.get())->delBlk(thelastBlockOld);
+          } else {
+            break;
+          }
+        } 
+      }
+      
+    } else {
+      // 如果不是终止指令，但有后继 (例如，末尾没有显式终止指令的块)
+      // 这段逻辑可能需要更严谨的CFG检查来确保正确性
+      if (basicBlock->getNumSuccessors() == 1) {
+        // 这里的逻辑似乎是想为没有terminator的块添加一个，但通常这应该在CFG构建阶段完成。
+        // 如果这里仍然执行，确保它符合预期。
+        // pBuilder->setPosition(basicBlock.get(), basicBlock->end());
+        // pBuilder->createUncondBrInst(basicBlock->getSuccessors()[0], {});
+        // auto thelastinst = basicBlock->getInstructions().end();
+        // (--thelastinst);
+        // auto OldBrBlock = dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0));
+        // sysy::BasicBlock *thelastBlockOld = nullptr;
+        // while (EmptyBlocks.find(dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0))) !=
+        //         EmptyBlocks.end()) {
+        //   thelastBlockOld = dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0));
+
+        //   thelastinst->get()->replaceOperand(
+        //       0, EmptyBlocks[dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0))]);
+        // }
+        
+        // basicBlock->removeSuccessor(OldBrBlock);
+        // OldBrBlock->removePredecessor(basicBlock.get());
+        // basicBlock->addSuccessor(dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0)));
+        // dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0))->addPredecessor(basicBlock.get());
+        // changed = true; // 标记IR被修改
+        // if (thelastBlockOld != nullptr) {
+        //   int indexphi = 0;
+        //   for (auto &pred : dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0))->getPredecessors()) {
+        //     if (pred == thelastBlockOld) {
+        //       break;
+        //     }
+        //     indexphi++;
+        //   }
+
+        //   for (auto &InstInNew : dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0))->getInstructions()) {
+        //     if (InstInNew->isPhi()) {
+        //       dynamic_cast<PhiInst *>(InstInNew.get())->removeOperand(indexphi + 1);
+        //     } else {
+        //       break;
+        //     }
+        //   }
+        // }
+      }
     }
   }
 
+  // 真正的删除空块
+  for (auto iter = func->getBasicBlocks().begin(); iter != func->getBasicBlocks().end();) {
+    
+    if (EmptyBlocks.count(iter->get())) {
+      // EntryBlock跳过
+      if (iter->get() == func->getEntryBlock()) {
+        ++iter;
+        continue;
+      }
+
+      for (auto instIter = iter->get()->getInstructions().begin();
+         instIter != iter->get()->getInstructions().end();) {
+        SysYIROptUtils::usedelete(instIter->get()); // 仅删除 use 关系
+        // 显式地从基本块中删除指令并更新迭代器
+        instIter = iter->get()->getInstructions().erase(instIter);
+      }
+      // 删除不可达基本块的phi指令的操作数
+      for (auto &succ : iter->get()->getSuccessors()) {
+        for (auto &instinsucc : succ->getInstructions()) {
+          if (instinsucc->isPhi()) {
+            // iter->get() 就是当前被删除的空基本块，它作为前驱连接到这里的Phi指令
+            dynamic_cast<PhiInst *>(instinsucc.get())->delBlk(iter->get());
+          } else {
+            // Phi 指令通常在基本块的开头，如果不是 Phi 指令就停止检查
+            break;
+          }
+        }
+      }
+
+      func->removeBasicBlock((iter++)->get());
+      changed = true;
+    } else {
+      ++iter;
+    }
+  }
+  
   return changed;
 }
 
 // 如果函数没有返回指令，则添加一个默认返回指令(主要解决void函数没有返回指令的问题)
-bool SysYCFGOptUtils::SysYAddReturn(Function *func, IRBuilder *pBuilder) {
+bool SysYCFGOptUtils::SysYAddReturn(Function *func, IRBuilder* pBuilder) {
   bool changed = false;
   auto basicBlocks = func->getBasicBlocks();
   for (auto &block : basicBlocks) {
@@ -577,8 +467,7 @@ bool SysYCFGOptUtils::SysYAddReturn(Function *func, IRBuilder *pBuilder) {
         auto thelastinst = block->getInstructions().end();
         --thelastinst;
         if (thelastinst->get()->getKind() != Instruction::kReturn) {
-          // std::cout << "Warning: Function " << func->getName() << " has no return instruction, adding default
-          // return." << std::endl;
+          // std::cout << "Warning: Function " << func->getName() << " has no return instruction, adding default return." << std::endl;
 
           pBuilder->setPosition(block.get(), block->end());
           // TODO: 如果int float函数缺少返回值是否需要报错
@@ -594,7 +483,7 @@ bool SysYCFGOptUtils::SysYAddReturn(Function *func, IRBuilder *pBuilder) {
       }
     }
   }
-
+  
   return changed;
 }
 
@@ -602,18 +491,18 @@ bool SysYCFGOptUtils::SysYAddReturn(Function *func, IRBuilder *pBuilder) {
 // 主要针对已知条件值的分支转换为无条件分支
 // 例如 if (cond) { ... } else { ... } 中的 cond 已经
 // 确定为 true 或 false 的情况
-bool SysYCFGOptUtils::SysYCondBr2Br(Function *func, IRBuilder *pBuilder) {
+bool SysYCFGOptUtils::SysYCondBr2Br(Function *func, IRBuilder* pBuilder) {
   bool changed = false;
 
   for (auto &basicblock : func->getBasicBlocks()) {
     if (basicblock->getNumInstructions() == 0)
       continue;
+    
+    auto thelast = basicblock->getInstructions().end();
+    --thelast;
 
-    auto thelast = basicblock->terminator();
-
-    if (thelast->get()->isConditional()) {
-      auto condBrInst = dynamic_cast<CondBrInst *>(thelast->get());
-      ConstantValue *constOperand = dynamic_cast<ConstantValue *>(condBrInst->getCondition());
+    if (thelast->get()->isConditional()){
+      ConstantValue *constOperand = dynamic_cast<ConstantValue *>(thelast->get()->getOperand(0));
       std::string opname;
       int constint = 0;
       float constfloat = 0.0F;
@@ -632,31 +521,32 @@ bool SysYCFGOptUtils::SysYCondBr2Br(Function *func, IRBuilder *pBuilder) {
       if (constfloat_Use || constint_Use) {
         changed = true;
 
-        auto thenBlock = dynamic_cast<BasicBlock *>(condBrInst->getThenBlock());
-        auto elseBlock = dynamic_cast<BasicBlock *>(condBrInst->getElseBlock());
-        thelast = SysYIROptUtils::usedelete(thelast);
+        auto thenBlock = dynamic_cast<BasicBlock *>(thelast->get()->getOperand(1));
+        auto elseBlock = dynamic_cast<BasicBlock *>(thelast->get()->getOperand(2));
+        SysYIROptUtils::usedelete(thelast->get());
+        thelast = basicblock->getInstructions().erase(thelast);
         if ((constfloat_Use && constfloat == 1.0F) || (constint_Use && constint == 1)) {
           // cond为true或非0
           pBuilder->setPosition(basicblock.get(), basicblock->end());
-          pBuilder->createUncondBrInst(thenBlock);
-
+          pBuilder->createUncondBrInst(thenBlock, {});
+          
           // 更新CFG关系
           basicblock->removeSuccessor(elseBlock);
           elseBlock->removePredecessor(basicblock.get());
-
+          
           // 删除elseBlock的phi指令中对应的basicblock.get()的传入值
           for (auto &phiinst : elseBlock->getInstructions()) {
             if (phiinst->getKind() != Instruction::kPhi) {
               break;
             }
             // 使用 delBlk 方法删除 basicblock.get() 对应的传入值
-            dynamic_cast<PhiInst *>(phiinst.get())->removeIncomingBlock(basicblock.get());
+            dynamic_cast<PhiInst *>(phiinst.get())->delBlk(basicblock.get());
           }
-
+          
         } else { // cond为false或0
 
           pBuilder->setPosition(basicblock.get(), basicblock->end());
-          pBuilder->createUncondBrInst(elseBlock);
+          pBuilder->createUncondBrInst(elseBlock, {});
 
           // 更新CFG关系
           basicblock->removeSuccessor(thenBlock);
@@ -668,8 +558,9 @@ bool SysYCFGOptUtils::SysYCondBr2Br(Function *func, IRBuilder *pBuilder) {
               break;
             }
             // 使用 delBlk 方法删除 basicblock.get() 对应的传入值
-            dynamic_cast<PhiInst *>(phiinst.get())->removeIncomingBlock(basicblock.get());
+            dynamic_cast<PhiInst *>(phiinst.get())->delBlk(basicblock.get());
           }
+
         }
       }
     }
@@ -682,28 +573,28 @@ bool SysYCFGOptUtils::SysYCondBr2Br(Function *func, IRBuilder *pBuilder) {
 // 独立的CFG优化遍的实现
 // ======================================================================
 
-bool SysYDelInstAfterBrPass::runOnFunction(Function *F, AnalysisManager &AM) {
+bool SysYDelInstAfterBrPass::runOnFunction(Function *F, AnalysisManager& AM) {
   return SysYCFGOptUtils::SysYDelInstAfterBr(F);
 }
 
-bool SysYDelEmptyBlockPass::runOnFunction(Function *F, AnalysisManager &AM) {
+bool SysYDelEmptyBlockPass::runOnFunction(Function *F, AnalysisManager& AM) {
   return SysYCFGOptUtils::SysYDelEmptyBlock(F, pBuilder);
 }
 
-bool SysYDelNoPreBLockPass::runOnFunction(Function *F, AnalysisManager &AM) {
+bool SysYDelNoPreBLockPass::runOnFunction(Function *F, AnalysisManager& AM) {
   return SysYCFGOptUtils::SysYDelNoPreBLock(F);
 }
 
-bool SysYBlockMergePass::runOnFunction(Function *F, AnalysisManager &AM) { 
-  return SysYCFGOptUtils::SysYBlockMerge(F); 
+bool SysYBlockMergePass::runOnFunction(Function *F, AnalysisManager& AM) {
+  return SysYCFGOptUtils::SysYBlockMerge(F);
 }
 
-bool SysYAddReturnPass::runOnFunction(Function *F, AnalysisManager &AM) {
+bool SysYAddReturnPass::runOnFunction(Function *F, AnalysisManager& AM) {
   return SysYCFGOptUtils::SysYAddReturn(F, pBuilder);
 }
 
-bool SysYCondBr2BrPass::runOnFunction(Function *F, AnalysisManager &AM) {
+bool SysYCondBr2BrPass::runOnFunction(Function *F, AnalysisManager& AM) {
   return SysYCFGOptUtils::SysYCondBr2Br(F, pBuilder);
 }
 
-} // namespace sysy
+}  // namespace sysy

src/midend/Pass/Pass.cpp

@@ -5,9 +5,7 @@
 #include "DCE.h"
 #include "Mem2Reg.h"
 #include "Reg2Mem.h"
-#include "SCCP.h"
-#include "BuildCFG.h"
-#include "LargeArrayToGlobal.h"
+#include "ConstPropagation.h"
 #include "Pass.h"
 #include <iostream>
 #include <queue>
@@ -37,13 +35,10 @@ void PassManager::runOptimizationPipeline(Module* moduleIR, IRBuilder* builderIR
         3. 添加优化passid
     */
     // 注册分析遍
-    registerAnalysisPass<DominatorTreeAnalysisPass>();
-    registerAnalysisPass<LivenessAnalysisPass>();
+    registerAnalysisPass<sysy::DominatorTreeAnalysisPass>();
+    registerAnalysisPass<sysy::LivenessAnalysisPass>();
 
     // 注册优化遍
-    registerOptimizationPass<BuildCFG>();
-    registerOptimizationPass<LargeArrayToGlobalPass>();
-    
     registerOptimizationPass<SysYDelInstAfterBrPass>();
     registerOptimizationPass<SysYDelNoPreBLockPass>();
     registerOptimizationPass<SysYBlockMergePass>();
@@ -56,23 +51,11 @@ void PassManager::runOptimizationPipeline(Module* moduleIR, IRBuilder* builderIR
     registerOptimizationPass<Mem2Reg>(builderIR);
     registerOptimizationPass<Reg2Mem>(builderIR);
 
-    registerOptimizationPass<SCCP>(builderIR);
-
     if (optLevel >= 1) {
       //经过设计安排优化遍的执行顺序以及执行逻辑
       if (DEBUG) std::cout << "Applying -O1 optimizations.\n";
       if (DEBUG) std::cout << "--- Running custom optimization sequence ---\n";
 
-      if(DEBUG) {
-        std::cout << "=== IR Before CFGOpt Optimizations ===\n";
-        printPasses();
-      }
-
-      this->clearPasses();
-      this->addPass(&BuildCFG::ID);
-      this->addPass(&LargeArrayToGlobalPass::ID);
-      this->run();
-
       this->clearPasses(); 
       this->addPass(&SysYDelInstAfterBrPass::ID);
       this->addPass(&SysYDelNoPreBLockPass::ID);
@@ -82,10 +65,6 @@ void PassManager::runOptimizationPipeline(Module* moduleIR, IRBuilder* builderIR
       this->addPass(&SysYAddReturnPass::ID);
       this->run(); 
 
-      this->clearPasses();
-      this->addPass(&BuildCFG::ID);
-      this->run();
-
       if(DEBUG) {
         std::cout << "=== IR After CFGOpt Optimizations ===\n";
         printPasses();
@@ -102,6 +81,7 @@ void PassManager::runOptimizationPipeline(Module* moduleIR, IRBuilder* builderIR
 
       this->clearPasses();
       this->addPass(&Mem2Reg::ID);
+      this->addPass(&ConstPropagation::ID);
       this->run();
 
       if(DEBUG) {
@@ -109,15 +89,6 @@ void PassManager::runOptimizationPipeline(Module* moduleIR, IRBuilder* builderIR
         printPasses();
       }
 
-      this->clearPasses();
-      this->addPass(&SCCP::ID);
-      this->run();
-
-      if(DEBUG) {
-        std::cout << "=== IR After SCCP Optimizations ===\n";
-        printPasses();
-      }
-
       this->clearPasses();
       this->addPass(&Reg2Mem::ID);
       this->run();
@@ -126,9 +97,7 @@ void PassManager::runOptimizationPipeline(Module* moduleIR, IRBuilder* builderIR
         std::cout << "=== IR After Reg2Mem Optimizations ===\n";
         printPasses();
       }
-      this->clearPasses();
-      this->addPass(&BuildCFG::ID);
-      this->run();
+
       if (DEBUG) std::cout << "--- Custom optimization sequence finished ---\n";
     }
 
@@ -143,7 +112,6 @@ void PassManager::runOptimizationPipeline(Module* moduleIR, IRBuilder* builderIR
       SysYPrinter printer(moduleIR);
       printer.printIR();
     }
-    
 }
 
 void PassManager::clearPasses() {

src/midend/SysYIRGenerator.cpp

@@ -15,139 +15,6 @@
 using namespace std;
 namespace sysy {
 
-std::pair<long long, int> calculate_signed_magic(int d) {
-    if (d == 0) throw std::runtime_error("Division by zero");
-    if (d == 1 || d == -1) return {0, 0}; // Not used by strength reduction
-
-    int k = 0;
-    unsigned int ad = (d > 0) ? d : -d;
-    unsigned int temp = ad;
-    while (temp > 0) {
-        temp >>= 1;
-        k++;
-    }
-    if ((ad & (ad - 1)) == 0) { // if power of 2
-        k--;
-    }
-
-    unsigned __int128 m_val = 1;
-    m_val <<= (32 + k - 1);
-    unsigned __int128 m_prime = m_val / ad;
-    long long m = m_prime + 1;
-
-    return {m, k};
-}
-
-// 清除因函数调用而失效的表达式缓存（保守策略）
-void SysYIRGenerator::invalidateExpressionsOnCall() {
-  availableBinaryExpressions.clear();
-  availableUnaryExpressions.clear();
-  availableLoads.clear();
-  availableGEPs.clear();
-}
-
-// 在进入新的基本块时清空所有表达式缓存
-void SysYIRGenerator::enterNewBasicBlock() {
-  availableBinaryExpressions.clear();
-  availableUnaryExpressions.clear();
-  availableLoads.clear();
-  availableGEPs.clear();
-}
-
-// 清除因变量赋值而失效的表达式缓存
-// @param storedAddress: store 指令的目标地址 (例如 AllocaInst* 或 GEPInst*)
-void SysYIRGenerator::invalidateExpressionsOnStore(Value *storedAddress) {
-  // 遍历二元表达式缓存，移除受影响的条目
-  // 创建一个临时列表来存储要移除的键，避免在迭代时修改容器
-  std::vector<ExpKey> binaryKeysToRemove;
-  for (const auto &pair : availableBinaryExpressions) {
-    // 检查左操作数
-    // 如果左操作数是 LoadInst，并且它从 storedAddress 加载
-    if (auto loadInst = dynamic_cast<LoadInst *>(pair.first.left)) {
-      if (loadInst->getPointer() == storedAddress) {
-        binaryKeysToRemove.push_back(pair.first);
-        continue; // 这个表达式已标记为移除，跳到下一个
-      }
-    }
-    // 如果左操作数本身就是被存储的地址 (例如，将一个地址值直接作为操作数，虽然不常见)
-    if (pair.first.left == storedAddress) {
-      binaryKeysToRemove.push_back(pair.first);
-      continue;
-    }
-
-    // 检查右操作数，逻辑同左操作数
-    if (auto loadInst = dynamic_cast<LoadInst *>(pair.first.right)) {
-      if (loadInst->getPointer() == storedAddress) {
-        binaryKeysToRemove.push_back(pair.first);
-        continue;
-      }
-    }
-    if (pair.first.right == storedAddress) {
-      binaryKeysToRemove.push_back(pair.first);
-      continue;
-    }
-  }
-  // 实际移除条目
-  for (const auto &key : binaryKeysToRemove) {
-    availableBinaryExpressions.erase(key);
-  }
-
-  // 遍历一元表达式缓存，移除受影响的条目
-  std::vector<UnExpKey> unaryKeysToRemove;
-  for (const auto &pair : availableUnaryExpressions) {
-    // 检查操作数
-    if (auto loadInst = dynamic_cast<LoadInst *>(pair.first.operand)) {
-      if (loadInst->getPointer() == storedAddress) {
-        unaryKeysToRemove.push_back(pair.first);
-        continue;
-      }
-    }
-    if (pair.first.operand == storedAddress) {
-      unaryKeysToRemove.push_back(pair.first);
-      continue;
-    }
-  }
-  // 实际移除条目
-  for (const auto &key : unaryKeysToRemove) {
-    availableUnaryExpressions.erase(key);
-  }
-  availableLoads.erase(storedAddress);
-
-  std::vector<GEPKey> gepKeysToRemove;
-  for (const auto &pair : availableGEPs) {
-    // 检查 GEP 的基指针是否受存储影响
-    if (auto loadInst = dynamic_cast<LoadInst *>(pair.first.basePointer)) {
-        if (loadInst->getPointer() == storedAddress) {
-            gepKeysToRemove.push_back(pair.first);
-            continue; // 标记此GEP为移除，跳过后续检查
-        }
-    }
-    // 如果基指针本身就是存储的目标地址 (不常见，但可能)
-    if (pair.first.basePointer == storedAddress) {
-        gepKeysToRemove.push_back(pair.first);
-        continue;
-    }
-
-    // 检查 GEP 的每个索引是否受存储影响
-    for (const auto &indexVal : pair.first.indices) {
-        if (auto loadInst = dynamic_cast<LoadInst *>(indexVal)) {
-            if (loadInst->getPointer() == storedAddress) {
-                gepKeysToRemove.push_back(pair.first);
-                break; // 标记此GEP为移除，并跳出内部循环
-            }
-        }
-        // 如果索引本身就是存储的目标地址
-        if (indexVal == storedAddress) {
-            gepKeysToRemove.push_back(pair.first);
-            break;
-        }
-    }
-  }
-  // 实际移除条目
-  for (const auto &key : gepKeysToRemove) {
-    availableGEPs.erase(key);
-  }
-}
 
 // std::vector<Value*> BinaryValueStack;  ///< 用于存储value的栈
 // std::vector<int> BinaryOpStack;  ///< 用于存储二元表达式的操作符栈 
@@ -377,56 +244,27 @@ void SysYIRGenerator::compute() {
           }
         } else {
           // 否则，创建相应的IR指令
-          ExpKey currentExpKey(static_cast<BinaryOp>(op), lhs, rhs);
-          auto it = availableBinaryExpressions.find(currentExpKey);
-
-          if (it != availableBinaryExpressions.end()) {
-            // 在缓存中找到，重用结果
-            resultValue = it->second;
-          } else {
-            if (commonType == Type::getIntType()) {
-              switch (op) {
-              case BinaryOp::ADD: resultValue = builder.createAddInst(lhs, rhs); break;
-              case BinaryOp::SUB: resultValue = builder.createSubInst(lhs, rhs); break;
-              case BinaryOp::MUL: resultValue = builder.createMulInst(lhs, rhs); break;
-              case BinaryOp::DIV: {
-                ConstantInteger *rhsConst = dynamic_cast<ConstantInteger *>(rhs);
-                if (rhsConst) {
-                  int divisor = rhsConst->getInt();
-                  if (divisor > 0 && (divisor & (divisor - 1)) == 0) {
-                    int shift = 0;
-                    int temp = divisor;
-                    while (temp > 1) {
-                      temp >>= 1;
-                      shift++;
-                    }
-                    resultValue = builder.createSRAInst(lhs, ConstantInteger::get(shift));
-                  } else {
-                    resultValue = builder.createDivInst(lhs, rhs);
-                  }
-                } else {
-                  resultValue = builder.createDivInst(lhs, rhs);
-                }
-                break;
-              }
-              case BinaryOp::MOD: resultValue = builder.createRemInst(lhs, rhs); break;
-              }
-            } else if (commonType == Type::getFloatType()) {
-              switch (op) {
-              case BinaryOp::ADD: resultValue = builder.createFAddInst(lhs, rhs); break;
-              case BinaryOp::SUB: resultValue = builder.createFSubInst(lhs, rhs); break;
-              case BinaryOp::MUL: resultValue = builder.createFMulInst(lhs, rhs); break;
-              case BinaryOp::DIV: resultValue = builder.createFDivInst(lhs, rhs); break;
-              case BinaryOp::MOD:
-                std::cerr << "Error: Modulo operator not supported for float types." << std::endl;
-                return;
-              }
-            } else {
-              std::cerr << "Error: Unsupported type for binary instruction." << std::endl;
+          if (commonType == Type::getIntType()) {
+            switch (op) {
+            case BinaryOp::ADD: resultValue = builder.createAddInst(lhs, rhs); break;
+            case BinaryOp::SUB: resultValue = builder.createSubInst(lhs, rhs); break;
+            case BinaryOp::MUL: resultValue = builder.createMulInst(lhs, rhs); break;
+            case BinaryOp::DIV: resultValue = builder.createDivInst(lhs, rhs); break;
+            case BinaryOp::MOD: resultValue = builder.createRemInst(lhs, rhs); break;
+            }
+          } else if (commonType == Type::getFloatType()) {
+            switch (op) {
+            case BinaryOp::ADD: resultValue = builder.createFAddInst(lhs, rhs); break;
+            case BinaryOp::SUB: resultValue = builder.createFSubInst(lhs, rhs); break;
+            case BinaryOp::MUL: resultValue = builder.createFMulInst(lhs, rhs); break;
+            case BinaryOp::DIV: resultValue = builder.createFDivInst(lhs, rhs); break;
+            case BinaryOp::MOD:
+              std::cerr << "Error: Modulo operator not supported for float types." << std::endl;
               return;
             }
-            // 将新创建的指令结果添加到缓存
-            availableBinaryExpressions[currentExpKey] = resultValue;
+          } else {
+            std::cerr << "Error: Unsupported type for binary instruction." << std::endl;
+            return;
           }
         }
         break;
@@ -478,45 +316,36 @@ void SysYIRGenerator::compute() {
             return;
           }
         } else {
-          // 否则，创建相应的IR指令 (在这里应用CSE)
-          UnExpKey currentUnExpKey(static_cast<BinaryOp>(op), operand);
-          auto it = availableUnaryExpressions.find(currentUnExpKey);
-          if (it != availableUnaryExpressions.end()) {
-            // 在缓存中找到，重用结果
-            resultValue = it->second;
-          } else {
-            switch (op) {
-              case BinaryOp::PLUS:
-                resultValue = operand; // 一元加指令通常直接返回操作数
-                break;
-              case BinaryOp::NEG: {
-                if (commonType == sysy::Type::getIntType()) {
-                  resultValue = builder.createNegInst(operand);
-                } else if (commonType == sysy::Type::getFloatType()) {
-                  resultValue = builder.createFNegInst(operand);
-                } else {
-                  std::cerr << "Error: Negation not supported for operand type." << std::endl;
-                  return;
-                }
-                break;
-              }
-              case BinaryOp::NOT:
-                // 逻辑非
-                if (commonType == sysy::Type::getIntType()) {
-                  resultValue = builder.createNotInst(operand);
-                } else if (commonType == sysy::Type::getFloatType()) {
-                  resultValue = builder.createFNotInst(operand);
-                } else {
-                  std::cerr << "Error: Logical NOT not supported for operand type." << std::endl;
-                  return;
-                }
-                break;
-              default:
-                std::cerr << "Error: Unknown unary operator for instructions: " << op << std::endl;
-                return;
+          // 否则，创建相应的IR指令
+          switch (op) {
+          case BinaryOp::PLUS:
+            resultValue = operand; // 一元加指令通常直接返回操作数
+            break;
+          case BinaryOp::NEG: {
+            if (commonType == sysy::Type::getIntType()) {
+              resultValue = builder.createNegInst(operand);
+            } else if (commonType == sysy::Type::getFloatType()) {
+              resultValue = builder.createFNegInst(operand);
+            } else {
+              std::cerr << "Error: Negation not supported for operand type." << std::endl;
+              return;
             }
-            // 将新创建的指令结果添加到缓存
-            availableUnaryExpressions[currentUnExpKey] = resultValue;
+            break;
+          }
+          case BinaryOp::NOT:
+            // 逻辑非
+            if (commonType == sysy::Type::getIntType()) {
+              resultValue = builder.createNotInst(operand);
+            } else if (commonType == sysy::Type::getFloatType()) {
+              resultValue = builder.createFNotInst(operand);
+            } else {
+              std::cerr << "Error: Logical NOT not supported for operand type." << std::endl;
+              return;
+            }
+            break;
+          default:
+            std::cerr << "Error: Unknown unary operator for instructions: " << op << std::endl;
+            return;
           }
         }
         break;
@@ -658,19 +487,7 @@ Value* SysYIRGenerator::getGEPAddressInst(Value* basePointer, const std::vector<
     // `indices` 向量现在由调用方（如 visitLValue, visitVarDecl, visitAssignStmt）负责完整准备，
     // 包括是否需要添加初始的 `0` 索引。
     // 所以这里直接将其传递给 `builder.createGetElementPtrInst`。
-    GEPKey key = {basePointer, indices};
-
-    // 尝试从缓存中查找
-    auto it = availableGEPs.find(key);
-    if (it != availableGEPs.end()) {
-        return it->second; // 缓存命中，返回已有的 GEPInst*
-    }
-
-    // 缓存未命中，创建新的 GEPInst
-    Value* gepInst = builder.createGetElementPtrInst(basePointer, indices); // 假设 builder 提供了 createGEPInst 方法
-    availableGEPs[key] = gepInst; // 将新的 GEPInst* 加入缓存
-
-    return gepInst;
+    return builder.createGetElementPtrInst(basePointer, indices);
 }
 
 /*
@@ -716,7 +533,7 @@ std::any SysYIRGenerator::visitGlobalConstDecl(SysYParser::GlobalConstDeclContex
     if (!dims.empty()) { // 如果有维度，说明是数组
         variableType = buildArrayType(type, dims); // 构建完整的 ArrayType
     }
-    module->createConstVar(name, Type::getPointerType(variableType), values);
+    module->createConstVar(name, Type::getPointerType(variableType), values, dims);
   }
   return std::any();
 }
@@ -745,7 +562,7 @@ std::any SysYIRGenerator::visitGlobalVarDecl(SysYParser::GlobalVarDeclContext *c
     if (!dims.empty()) { // 如果有维度，说明是数组
         variableType = buildArrayType(type, dims); // 构建完整的 ArrayType
     }
-    module->createGlobalValue(name, Type::getPointerType(variableType), values);
+    module->createGlobalValue(name, Type::getPointerType(variableType), dims, values);
   }
   return std::any();
 }
@@ -769,13 +586,7 @@ std::any SysYIRGenerator::visitConstDecl(SysYParser::ConstDeclContext *ctx) {
 
     // 显式地为局部常量在栈上分配空间
     // alloca 的类型将是指针指向常量类型，例如 `int*` 或 `int[2][3]*`
-    // 将alloca全部集中到entry中
-    auto entry = builder.getBasicBlock()->getParent()->getEntryBlock();
-    auto it = builder.getPosition();
-    auto nowblk = builder.getBasicBlock();
-    builder.setPosition(entry, entry->terminator());
-    AllocaInst *alloca = builder.createAllocaInst(Type::getPointerType(variableType), name);
-    builder.setPosition(nowblk, it);
+    AllocaInst *alloca = builder.createAllocaInst(Type::getPointerType(variableType), {}, name);
 
     ArrayValueTree *root = std::any_cast<ArrayValueTree *>(constDef->constInitVal()->accept(this));
     ValueCounter values;
@@ -842,44 +653,7 @@ std::any SysYIRGenerator::visitConstDecl(SysYParser::ConstDeclContext *ctx) {
           Value *currentValue = counterValues[k];
           unsigned currentRepeatNum = counterNumbers[k];
 
-          // 检查是否是0，并且重复次数足够大（例如 >16），才用 memset
-          if (ConstantInteger *constInt = dynamic_cast<ConstantInteger *>(currentValue)) {
-            if (constInt->getInt() == 0 && currentRepeatNum >= 16) { // 阈值可调整（如16、32等）
-              // 计算 memset 的起始地址（基于当前线性偏移量）
-              std::vector<Value *> memsetStartIndices;
-              int tempLinearIndex = linearIndexOffset;
-
-              // 将线性索引转换为多维索引
-              for (int dimIdx = dimSizes.size() - 1; dimIdx >= 0; --dimIdx) {
-                memsetStartIndices.insert(memsetStartIndices.begin(),
-                                          ConstantInteger::get(static_cast<int>(tempLinearIndex % dimSizes[dimIdx])));
-                tempLinearIndex /= dimSizes[dimIdx];
-              }
-
-              // 构造 GEP 计算 memset 的起始地址
-              std::vector<Value *> gepIndicesForMemset;
-              gepIndicesForMemset.push_back(ConstantInteger::get(0)); // 跳过 alloca 类型
-              gepIndicesForMemset.insert(gepIndicesForMemset.end(), memsetStartIndices.begin(),
-                                         memsetStartIndices.end());
-
-              Value *memsetPtr = builder.createGetElementPtrInst(alloca, gepIndicesForMemset);
-
-              // 计算 memset 的字节数 = 元素个数 × 元素大小
-              Type *elementType = type;;
-              uint64_t elementSize = elementType->getSize();
-              Value *size = ConstantInteger::get(currentRepeatNum * elementSize);
-
-              // 生成 memset 指令（假设你的 IRBuilder 有 createMemset 方法）
-              builder.createMemsetInst(memsetPtr, ConstantInteger::get(0), size, ConstantInteger::get(0));
-
-              // 跳过这些已处理的0
-              linearIndexOffset += currentRepeatNum;
-              continue; // 直接进入下一次循环
-            }
-          }
-
           for (unsigned i = 0; i < currentRepeatNum; ++i) {
-            // 对于非零值，生成对应的 store 指令
             std::vector<Value *> currentIndices;
             int tempLinearIndex = linearIndexOffset + i; // 使用偏移量和当前重复次数内的索引
 
@@ -932,12 +706,8 @@ std::any SysYIRGenerator::visitVarDecl(SysYParser::VarDeclContext *ctx) {
 
     // 对于数组，alloca 的类型将是指针指向数组类型，例如 `int[2][3]*`
     // 对于标量，alloca 的类型将是指针指向标量类型，例如 `int*`
-    auto entry = builder.getBasicBlock()->getParent()->getEntryBlock();
-    auto it = builder.getPosition();
-    auto nowblk = builder.getBasicBlock();
-    builder.setPosition(entry, entry->terminator());
-    AllocaInst *alloca = builder.createAllocaInst(Type::getPointerType(variableType), name);
-    builder.setPosition(nowblk, it);
+    AllocaInst* alloca =
+        builder.createAllocaInst(Type::getPointerType(variableType), {}, name);
 
     if (varDef->initVal() != nullptr) {
       ValueCounter values;
@@ -991,73 +761,39 @@ std::any SysYIRGenerator::visitVarDecl(SysYParser::VarDeclContext *ctx) {
               ConstantInteger::get(0));
         }
         else {
-
+          
           int linearIndexOffset = 0; // 用于追踪当前处理的线性索引的偏移量
           for (int k = 0; k < counterValues.size(); ++k) {
-            // 当前 Value 的值和重复次数
-            Value *currentValue = counterValues[k];
-            unsigned currentRepeatNum = counterNumbers[k];
-            // 检查是否是0，并且重复次数足够大（例如 >16），才用 memset
-            if (ConstantInteger *constInt = dynamic_cast<ConstantInteger *>(currentValue)) {
-              if (constInt->getInt() == 0 && currentRepeatNum >= 16) { // 阈值可调整（如16、32等）
-                // 计算 memset 的起始地址（基于当前线性偏移量）
-                std::vector<Value *> memsetStartIndices;
-                int tempLinearIndex = linearIndexOffset;
+              // 当前 Value 的值和重复次数
+              Value* currentValue = counterValues[k];
+              unsigned currentRepeatNum = counterNumbers[k];
 
-                // 将线性索引转换为多维索引
-                for (int dimIdx = dimSizes.size() - 1; dimIdx >= 0; --dimIdx) {
-                  memsetStartIndices.insert(memsetStartIndices.begin(),
-                                            ConstantInteger::get(static_cast<int>(tempLinearIndex % dimSizes[dimIdx])));
-                  tempLinearIndex /= dimSizes[dimIdx];
-                }
+              for (unsigned i = 0; i < currentRepeatNum; ++i) {
+                  std::vector<Value *> currentIndices;
+                  int tempLinearIndex = linearIndexOffset + i; // 使用偏移量和当前重复次数内的索引
 
-                // 构造 GEP 计算 memset 的起始地址
-                std::vector<Value *> gepIndicesForMemset;
-                gepIndicesForMemset.push_back(ConstantInteger::get(0)); // 跳过 alloca 类型
-                gepIndicesForMemset.insert(gepIndicesForMemset.end(), memsetStartIndices.begin(),
-                                           memsetStartIndices.end());
-
-                Value *memsetPtr = builder.createGetElementPtrInst(alloca, gepIndicesForMemset);
-
-                // 计算 memset 的字节数 = 元素个数 × 元素大小
-                Type *elementType = type;
-                ;
-                uint64_t elementSize = elementType->getSize();
-                Value *size = ConstantInteger::get(currentRepeatNum * elementSize);
-
-                // 生成 memset 指令（假设你的 IRBuilder 有 createMemset 方法）
-                builder.createMemsetInst(memsetPtr, ConstantInteger::get(0), size, ConstantInteger::get(0));
-
-                // 跳过这些已处理的0
-                linearIndexOffset += currentRepeatNum;
-                continue; // 直接进入下一次循环
+                  // 将线性索引转换为多维索引
+                  for (int dimIdx = dimSizes.size() - 1; dimIdx >= 0; --dimIdx) {
+                      currentIndices.insert(currentIndices.begin(),
+                                          ConstantInteger::get(static_cast<int>(tempLinearIndex % dimSizes[dimIdx])));
+                      tempLinearIndex /= dimSizes[dimIdx];
+                  }
+                  
+                  // 对于局部数组，alloca 本身就是 GEP 的基指针。
+                  // GEP 的第一个索引必须是 0，用于“步过”整个数组。
+                  std::vector<Value*> gepIndicesForInit;
+                  gepIndicesForInit.push_back(ConstantInteger::get(0));
+                  gepIndicesForInit.insert(gepIndicesForInit.end(), currentIndices.begin(), currentIndices.end());
+                  
+                  // 计算元素的地址
+                  Value* elementAddress = getGEPAddressInst(alloca, gepIndicesForInit);
+                  // 生成 store 指令
+                  builder.createStoreInst(currentValue, elementAddress);
               }
-            }
-            for (unsigned i = 0; i < currentRepeatNum; ++i) {
-              std::vector<Value *> currentIndices;
-              int tempLinearIndex = linearIndexOffset + i; // 使用偏移量和当前重复次数内的索引
-
-              // 将线性索引转换为多维索引
-              for (int dimIdx = dimSizes.size() - 1; dimIdx >= 0; --dimIdx) {
-                currentIndices.insert(currentIndices.begin(),
-                                      ConstantInteger::get(static_cast<int>(tempLinearIndex % dimSizes[dimIdx])));
-                tempLinearIndex /= dimSizes[dimIdx];
-              }
-
-              // 对于局部数组，alloca 本身就是 GEP 的基指针。
-              // GEP 的第一个索引必须是 0，用于“步过”整个数组。
-              std::vector<Value *> gepIndicesForInit;
-              gepIndicesForInit.push_back(ConstantInteger::get(0));
-              gepIndicesForInit.insert(gepIndicesForInit.end(), currentIndices.begin(), currentIndices.end());
-
-              // 计算元素的地址
-              Value *elementAddress = getGEPAddressInst(alloca, gepIndicesForInit);
-              // 生成 store 指令
-              builder.createStoreInst(currentValue, elementAddress);
-            }
-            // 更新线性索引偏移量，以便下一次迭代从正确的位置开始
-            linearIndexOffset += currentRepeatNum;
+              // 更新线性索引偏移量，以便下一次迭代从正确的位置开始
+              linearIndexOffset += currentRepeatNum;
           }
+
         }
       }
     }
@@ -1139,8 +875,6 @@ std::any SysYIRGenerator::visitFuncType(SysYParser::FuncTypeContext *ctx) {
 std::any SysYIRGenerator::visitFuncDef(SysYParser::FuncDefContext *ctx){
   // 更新作用域
   module->enterNewScope();
-  // 清除CSE缓存
-  enterNewBasicBlock();
 
   auto name = ctx->Ident()->getText();
   std::vector<Type *> paramActualTypes;
@@ -1161,7 +895,7 @@ std::any SysYIRGenerator::visitFuncDef(SysYParser::FuncDefContext *ctx){
         currentParamDims.push_back(ConstantInteger::get(-1)); // 标记第一个维度为未知
         for (const auto &exp : param->exp()) {
           // 访问表达式以获取维度大小，这些维度必须是常量
-          Value* dimVal = computeExp(exp);
+          Value* dimVal = std::any_cast<Value *>(visitExp(exp));
           // 确保维度是常量整数，否则 buildArrayType 会断言失败
           assert(dynamic_cast<ConstantInteger*>(dimVal) && "Array dimension in parameter must be a constant integer!");
           currentParamDims.push_back(dimVal);
@@ -1216,7 +950,7 @@ std::any SysYIRGenerator::visitFuncDef(SysYParser::FuncDefContext *ctx){
   auto funcArgs = function->getArguments();
   std::vector<AllocaInst *> allocas;
   for (int i = 0; i < paramActualTypes.size(); ++i) {
-    AllocaInst *alloca = builder.createAllocaInst(Type::getPointerType(paramActualTypes[i]), paramNames[i]);
+    AllocaInst *alloca = builder.createAllocaInst(Type::getPointerType(paramActualTypes[i]), {}, paramNames[i]);
     allocas.push_back(alloca);
     module->addVariable(paramNames[i], alloca);
   }
@@ -1231,8 +965,7 @@ std::any SysYIRGenerator::visitFuncDef(SysYParser::FuncDefContext *ctx){
   BasicBlock* funcBodyEntry = function->addBasicBlock("funcBodyEntry_" + name);
   
   // 从 entryBB 无条件跳转到 funcBodyEntry
-  builder.createUncondBrInst(funcBodyEntry);
-  BasicBlock::conectBlocks(entry, funcBodyEntry); // 连接 entryBB 和 funcBodyEntry
+  builder.createUncondBrInst(funcBodyEntry, {});
   builder.setPosition(funcBodyEntry,funcBodyEntry->end()); // 将插入点设置到 funcBodyEntry
 
   for (auto item : ctx->blockStmt()->blockItem()) {
@@ -1296,16 +1029,7 @@ std::any SysYIRGenerator::visitAssignStmt(SysYParser::AssignStmtContext *ctx) {
     if (AllocaInst *alloc = dynamic_cast<AllocaInst *>(variable)) {
       Type* allocatedType = alloc->getType()->as<PointerType>()->getBaseType(); 
       if (allocatedType->isPointer()) {
-        // 尝试从缓存中获取 builder.createLoadInst(alloc) 的结果
-        auto it = availableLoads.find(alloc);
-        if (it != availableLoads.end()) {
-            gepBasePointer = it->second; // 缓存命中，重用
-        } else {
-            gepBasePointer = builder.createLoadInst(alloc); // 缓存未命中，创建新的 LoadInst
-            availableLoads[alloc] = gepBasePointer; // 将结果加入缓存
-        }
-        // --- CSE 结束 ---
-        // gepBasePointer = builder.createLoadInst(alloc);
+        gepBasePointer = builder.createLoadInst(alloc); 
         gepIndices = indices; 
       } else {
         gepBasePointer = alloc;
@@ -1367,9 +1091,9 @@ std::any SysYIRGenerator::visitAssignStmt(SysYParser::AssignStmtContext *ctx) {
       }
     }
   }
-  
+
   builder.createStoreInst(RValue, LValue);
-  invalidateExpressionsOnStore(LValue);
+
   return std::any();
 }
 
@@ -1406,9 +1130,7 @@ std::any SysYIRGenerator::visitIfStmt(SysYParser::IfStmtContext *ctx) {
     labelstring.str("");
     function->addBasicBlock(thenBlock);
     builder.setPosition(thenBlock, thenBlock->end());
-    // CSE清除缓存
-    enterNewBasicBlock();
-    
+
     auto block = dynamic_cast<SysYParser::BlockStmtContext *>(ctx->stmt(0));
     // 如果是块语句，直接访问
     // 否则访问语句
@@ -1419,7 +1141,7 @@ std::any SysYIRGenerator::visitIfStmt(SysYParser::IfStmtContext *ctx) {
       ctx->stmt(0)->accept(this);
       module->leaveScope();
     }
-    builder.createUncondBrInst(exitBlock);
+    builder.createUncondBrInst(exitBlock, {});
     BasicBlock::conectBlocks(builder.getBasicBlock(), exitBlock);
 
     labelstring << "if_else.L" << builder.getLabelIndex();
@@ -1427,9 +1149,7 @@ std::any SysYIRGenerator::visitIfStmt(SysYParser::IfStmtContext *ctx) {
     labelstring.str("");
     function->addBasicBlock(elseBlock);
     builder.setPosition(elseBlock, elseBlock->end());
-    // CSE清除缓存
-    enterNewBasicBlock();
-    
+
     block = dynamic_cast<SysYParser::BlockStmtContext *>(ctx->stmt(1));
     if (block != nullptr) {
       visitBlockStmt(block);
@@ -1438,7 +1158,7 @@ std::any SysYIRGenerator::visitIfStmt(SysYParser::IfStmtContext *ctx) {
       ctx->stmt(1)->accept(this);
       module->leaveScope();
     }
-    builder.createUncondBrInst(exitBlock);
+    builder.createUncondBrInst(exitBlock, {});
     BasicBlock::conectBlocks(builder.getBasicBlock(), exitBlock);
 
     labelstring << "if_exit.L" << builder.getLabelIndex();
@@ -1446,9 +1166,7 @@ std::any SysYIRGenerator::visitIfStmt(SysYParser::IfStmtContext *ctx) {
     labelstring.str("");
     function->addBasicBlock(exitBlock);
     builder.setPosition(exitBlock, exitBlock->end());
-    // CSE清除缓存
-    enterNewBasicBlock();
-    
+
   } else {
     builder.pushTrueBlock(thenBlock);
     builder.pushFalseBlock(exitBlock);
@@ -1461,9 +1179,7 @@ std::any SysYIRGenerator::visitIfStmt(SysYParser::IfStmtContext *ctx) {
     labelstring.str("");
     function->addBasicBlock(thenBlock);
     builder.setPosition(thenBlock, thenBlock->end());
-    // CSE清除缓存
-    enterNewBasicBlock();
-    
+
     auto block = dynamic_cast<SysYParser::BlockStmtContext *>(ctx->stmt(0));
     if (block != nullptr) {
       visitBlockStmt(block);
@@ -1472,7 +1188,7 @@ std::any SysYIRGenerator::visitIfStmt(SysYParser::IfStmtContext *ctx) {
       ctx->stmt(0)->accept(this);
       module->leaveScope();
     }
-    builder.createUncondBrInst(exitBlock);
+    builder.createUncondBrInst(exitBlock, {});
     BasicBlock::conectBlocks(builder.getBasicBlock(), exitBlock);
 
     labelstring << "if_exit.L" << builder.getLabelIndex();
@@ -1480,9 +1196,6 @@ std::any SysYIRGenerator::visitIfStmt(SysYParser::IfStmtContext *ctx) {
     labelstring.str("");
     function->addBasicBlock(exitBlock);
     builder.setPosition(exitBlock, exitBlock->end());
-    // CSE清除缓存
-    enterNewBasicBlock();
-    
   }
   return std::any();
 }
@@ -1497,12 +1210,10 @@ std::any SysYIRGenerator::visitWhileStmt(SysYParser::WhileStmtContext *ctx) {
   labelstring << "while_head.L" << builder.getLabelIndex();
   BasicBlock *headBlock = function->addBasicBlock(labelstring.str());
   labelstring.str("");
-  builder.createUncondBrInst(headBlock);
+  builder.createUncondBrInst(headBlock, {});
   BasicBlock::conectBlocks(curBlock, headBlock);
   builder.setPosition(headBlock, headBlock->end());
-  // CSE清除缓存
-  enterNewBasicBlock();
-    
+
   BasicBlock* bodyBlock = new BasicBlock(function);
   BasicBlock* exitBlock = new BasicBlock(function);
 
@@ -1518,8 +1229,6 @@ std::any SysYIRGenerator::visitWhileStmt(SysYParser::WhileStmtContext *ctx) {
   labelstring.str("");
   function->addBasicBlock(bodyBlock);
   builder.setPosition(bodyBlock, bodyBlock->end());
-  // CSE清除缓存
-  enterNewBasicBlock();
 
   builder.pushBreakBlock(exitBlock);
   builder.pushContinueBlock(headBlock);
@@ -1534,7 +1243,7 @@ std::any SysYIRGenerator::visitWhileStmt(SysYParser::WhileStmtContext *ctx) {
     module->leaveScope();
   }
 
-  builder.createUncondBrInst(headBlock);
+  builder.createUncondBrInst(headBlock, {});
   BasicBlock::conectBlocks(builder.getBasicBlock(), exitBlock);
   builder.popBreakBlock();
   builder.popContinueBlock();
@@ -1544,22 +1253,20 @@ std::any SysYIRGenerator::visitWhileStmt(SysYParser::WhileStmtContext *ctx) {
   labelstring.str("");
   function->addBasicBlock(exitBlock);
   builder.setPosition(exitBlock, exitBlock->end());
-    // CSE清除缓存
-  enterNewBasicBlock();
-
+  
   return std::any();
 }
 
 std::any SysYIRGenerator::visitBreakStmt(SysYParser::BreakStmtContext *ctx) {
   BasicBlock* breakBlock = builder.getBreakBlock();
-  builder.createUncondBrInst(breakBlock);
+  builder.createUncondBrInst(breakBlock, {});
   BasicBlock::conectBlocks(builder.getBasicBlock(), breakBlock);
   return std::any();
 }
 
 std::any SysYIRGenerator::visitContinueStmt(SysYParser::ContinueStmtContext *ctx) {
   BasicBlock* continueBlock = builder.getContinueBlock();
-  builder.createUncondBrInst(continueBlock);
+  builder.createUncondBrInst(continueBlock, {});
   BasicBlock::conectBlocks(builder.getBasicBlock(), continueBlock);
   return std::any();
 }
@@ -1661,34 +1368,62 @@ std::any SysYIRGenerator::visitLValue(SysYParser::LValueContext *ctx) {
 
   // 3. 处理可变变量 (AllocaInst/GlobalValue) 或带非常量索引的常量变量
   // 这里区分标量访问和数组元素/子数组访问
-  Value *targetAddress = nullptr;
+
   // 检查是否是访问标量变量本身（没有索引，且声明维度为0）
   if (dims.empty() && declaredNumDims == 0) {
+    // 对于标量变量，直接加载其值。
+    // variable 本身就是指向标量的指针 (e.g., int* %a)
     if (dynamic_cast<AllocaInst*>(variable) || dynamic_cast<GlobalValue*>(variable)) {
-        targetAddress = variable;
+        value = builder.createLoadInst(variable);
     } else {
+        // 如果走到这里且不是AllocaInst/GlobalValue，但dims为空且declaredNumDims为0，
+        // 且又不是ConstantVariable (前面已处理)，则可能是错误情况。
         assert(false && "Unhandled scalar variable type in LValue access.");
         return static_cast<Value*>(nullptr);
     }
   } else {
+    // 访问数组元素或子数组（有索引，或变量本身是数组/多维指针）
     Value* gepBasePointer = nullptr;
-    std::vector<Value*> gepIndices;
+    std::vector<Value*> gepIndices; // 准备传递给 getGEPAddressInst 的索引列表
+    // GEP 的基指针就是变量本身（它是一个指向内存的指针）
     if (AllocaInst *alloc = dynamic_cast<AllocaInst *>(variable)) {
+      // 情况 A: 局部变量 (AllocaInst)
+      // 获取 AllocaInst 分配的内存的实际类型。
+      // 例如：对于 `int b[10][20];`，`allocatedType` 是 `[10 x [20 x i32]]`。
+      // 对于 `int b[][20]` 的函数参数，其 AllocaInst 存储的是一个指针，
+      // 此时 `allocatedType` 是 `[20 x i32]*`。
       Type* allocatedType = alloc->getType()->as<PointerType>()->getBaseType(); 
+
       if (allocatedType->isPointer()) {
-        gepBasePointer = builder.createLoadInst(alloc);
+        // 如果 AllocaInst 分配的是一个指针类型 (例如，用于存储函数参数的指针，如 int b[][20] 中的 b)
+        // 即 `allocatedType` 是一个指向数组指针的指针 (e.g., [20 x i32]**)
+        // 那么 GEP 的基指针是加载这个指针变量的值。
+        gepBasePointer = builder.createLoadInst(alloc); // 加载出实际的指针值 (e.g., [20 x i32]*)
+        // 对于这种参数指针，用户提供的索引直接作用于它。不需要额外的 0。
         gepIndices = dims; 
       } else {
-        gepBasePointer = alloc;
+        // 如果 AllocaInst 分配的是实际的数组数据 (例如，int b[10][20] 中的 b)
+        // 那么 AllocaInst 本身就是 GEP 的基指针。
+        // 这里的 `alloc` 是指向数组的指针 (e.g., [10 x [20 x i32]]*)
+        gepBasePointer = alloc; // 类型是 [10 x [20 x i32]]*
+        // 对于这种完整的数组分配，GEP 的第一个索引必须是 0，用于“步过”整个数组。
         gepIndices.push_back(ConstantInteger::get(0));
         gepIndices.insert(gepIndices.end(), dims.begin(), dims.end());
       }
     } else if (GlobalValue *glob = dynamic_cast<GlobalValue *>(variable)) {
-      gepBasePointer = glob;
+      // 情况 B: 全局变量 (GlobalValue)
+      // GlobalValue 总是指向全局数据的指针。
+      gepBasePointer = glob; // 类型是 [61 x [67 x i32]]*
+      // 对于全局数组，GEP 的第一个索引必须是 0，用于“步过”整个数组。
       gepIndices.push_back(ConstantInteger::get(0));
       gepIndices.insert(gepIndices.end(), dims.begin(), dims.end());
     } else if (ConstantVariable *constV = dynamic_cast<ConstantVariable *>(variable)) {
+      // 情况 C: 常量变量 (ConstantVariable)，如果它代表全局数组常量
+      // 假设 ConstantVariable 可以直接作为 GEP 的基指针。
       gepBasePointer = constV;
+      // 对于常量数组，也需要 0 索引来“步过”整个数组。
+      // 这里可以进一步检查 constV->getType()->as<PointerType>()->getBaseType()->isArray()
+      // 但为了简洁，假设所有 ConstantVariable 作为 GEP 基指针时都需要此 0。
       gepIndices.push_back(ConstantInteger::get(0));
       gepIndices.insert(gepIndices.end(), dims.begin(), dims.end());
     } else {
@@ -1696,25 +1431,18 @@ std::any SysYIRGenerator::visitLValue(SysYParser::LValueContext *ctx) {
       return static_cast<Value *>(nullptr);
     }
 
-    targetAddress = getGEPAddressInst(gepBasePointer, gepIndices);
+    // 现在调用 getGEPAddressInst，传入正确准备的基指针和索引列表
+    Value *targetAddress = getGEPAddressInst(gepBasePointer, gepIndices);
 
-  }
-
-  // 如果提供的索引数量少于声明的维度数量，则表示访问的是子数组，返回其地址 (无需加载)
-  if (dims.size() < declaredNumDims) {
-      value = targetAddress;
-  } else {
-    // value = builder.createLoadInst(targetAddress);
-    auto it = availableLoads.find(targetAddress);
-    if (it != availableLoads.end()) {
-      value = it->second; // 缓存命中，重用已有的 LoadInst 结果
+    // 如果提供的索引数量少于声明的维度数量，则表示访问的是子数组，返回其地址
+    if (dims.size() < declaredNumDims) {
+        value = targetAddress;
     } else {
-      // 缓存未命中，创建新的 LoadInst
-      value = builder.createLoadInst(targetAddress);
-      availableLoads[targetAddress] = value; // 将新的 LoadInst 结果加入缓存
+        // 否则，表示访问的是最终的标量元素，加载其值
+        // 假设 createLoadInst 接受 Value* pointer
+        value = builder.createLoadInst(targetAddress);
     }
   }
-
   return value;
 }
 
@@ -1834,7 +1562,6 @@ std::any SysYIRGenerator::visitUnaryExp(SysYParser::UnaryExpContext *ctx) {
     visitPrimaryExp(ctx->primaryExp());
   } else if (ctx->call() != nullptr) {
     BinaryExpStack.push_back(std::any_cast<Value *>(visitCall(ctx->call())));BinaryExpLenStack.back()++;
-    invalidateExpressionsOnCall();
   } else if (ctx->unaryOp() != nullptr) {
       // 遇到一元操作符，将其压入 BinaryExpStack
       auto opNode = dynamic_cast<antlr4::tree::TerminalNode*>(ctx->unaryOp()->children[0]);
@@ -2080,7 +1807,7 @@ std::any SysYIRGenerator::visitLAndExp(SysYParser::LAndExpContext *ctx){
     labelstring.str("");
 
     auto cond = std::any_cast<Value *>(visitEqExp(ctx->eqExp(i)));
-    builder.createCondBrInst(cond, newtrueBlock, falseBlock);
+    builder.createCondBrInst(cond, newtrueBlock, falseBlock, {}, {});
 
     BasicBlock::conectBlocks(curBlock, newtrueBlock);
     BasicBlock::conectBlocks(curBlock, falseBlock);
@@ -2090,7 +1817,7 @@ std::any SysYIRGenerator::visitLAndExp(SysYParser::LAndExpContext *ctx){
   }
 
   auto cond = std::any_cast<Value *>(visitEqExp(conds.back()));
-  builder.createCondBrInst(cond, trueBlock, falseBlock);
+  builder.createCondBrInst(cond, trueBlock, falseBlock, {}, {});
 
   BasicBlock::conectBlocks(curBlock, trueBlock);
   BasicBlock::conectBlocks(curBlock, falseBlock);
@@ -2207,7 +1934,7 @@ void Utils::createExternalFunction(
   for (int i = 0; i < paramTypes.size(); ++i) {
     auto arg = new Argument(paramTypes[i], function, i, paramNames[i]);
     auto alloca = pBuilder->createAllocaInst(
-        Type::getPointerType(paramTypes[i]), paramNames[i]);
+        Type::getPointerType(paramTypes[i]), {}, paramNames[i]);
     function->insertArgument(arg);
     auto store = pBuilder->createStoreInst(arg, alloca);
     pModule->addVariable(paramNames[i], alloca);

src/midend/SysYIRPrinter.cpp

@@ -240,8 +240,6 @@ void SysYPrinter::printInst(Instruction *pInst) {
     case Kind::kMul:
     case Kind::kDiv:
     case Kind::kRem:
-    case Kind::kSRA:
-    case Kind::kMulh:
     case Kind::kFAdd:
     case Kind::kFSub:
     case Kind::kFMul:
@@ -274,8 +272,6 @@ void SysYPrinter::printInst(Instruction *pInst) {
         case Kind::kMul: std::cout << "mul"; break;
         case Kind::kDiv: std::cout << "sdiv"; break;
         case Kind::kRem: std::cout << "srem"; break;
-        case Kind::kSRA: std::cout << "ashr"; break;
-        case Kind::kMulh: std::cout << "mulh"; break;
         case Kind::kFAdd: std::cout << "fadd"; break;
         case Kind::kFSub: std::cout << "fsub"; break;
         case Kind::kFMul: std::cout << "fmul"; break;
@@ -299,12 +295,7 @@ void SysYPrinter::printInst(Instruction *pInst) {
       
       // Types and operands
       std::cout << " ";
-      // For comparison operations, print operand types instead of result type
-      if (pInst->getKind() >= Kind::kICmpEQ && pInst->getKind() <= Kind::kFCmpGE) {
-        printType(binInst->getLhs()->getType());
-      } else {
-        printType(binInst->getType());
-      }
+      printType(binInst->getType());
       std::cout << " ";
       printValue(binInst->getLhs());
       std::cout << ", ";
@@ -417,12 +408,7 @@ void SysYPrinter::printInst(Instruction *pInst) {
       }
       std::cout << std::endl;
     } break;
-
-    case Kind::kUnreachable: {
-      std::cout << "Unreachable" << std::endl;
-      
-    } break;
-
+    
     case Kind::kAlloca: {
       auto allocaInst = dynamic_cast<AllocaInst *>(pInst);
       std::cout << "%" << allocaInst->getName() << " = alloca ";
@@ -433,6 +419,17 @@ void SysYPrinter::printInst(Instruction *pInst) {
       auto allocatedType = allocaInst->getAllocatedType();
       printType(allocatedType);
       
+      // 仍然打印维度信息，如果存在的话
+      if (allocaInst->getNumDims() > 0) { 
+        std::cout << ", ";
+        for (size_t i = 0; i < allocaInst->getNumDims(); i++) {
+          if (i > 0) std::cout << ", ";
+          printType(Type::getIntType()); // 维度大小通常是 i32 类型
+          std::cout << " ";
+          printValue(allocaInst->getDim(i));
+        }
+      }
+      
       std::cout << ", align 4" << std::endl;
     } break;
     
@@ -445,6 +442,17 @@ void SysYPrinter::printInst(Instruction *pInst) {
       std::cout << " ";
       printValue(loadInst->getPointer()); // 要加载的地址
       
+      // 仍然打印索引信息，如果存在的话
+      if (loadInst->getNumIndices() > 0) {
+        std::cout << ", indices "; // 或者其他分隔符，取决于你期望的格式
+        for (size_t i = 0; i < loadInst->getNumIndices(); i++) {
+            if (i > 0) std::cout << ", ";
+            printType(loadInst->getIndex(i)->getType());
+            std::cout << " ";
+            printValue(loadInst->getIndex(i));
+        }
+      }
+      
       std::cout << ", align 4" << std::endl;
     } break;
     
@@ -459,6 +467,16 @@ void SysYPrinter::printInst(Instruction *pInst) {
       std::cout << " ";
       printValue(storeInst->getPointer()); // 目标地址
       
+      // 仍然打印索引信息，如果存在的话
+      if (storeInst->getNumIndices() > 0) {
+        std::cout << ", indices "; // 或者其他分隔符
+        for (size_t i = 0; i < storeInst->getNumIndices(); i++) {
+            if (i > 0) std::cout << ", ";
+            printType(storeInst->getIndex(i)->getType());
+            std::cout << " ";
+            printValue(storeInst->getIndex(i));
+        }
+      }
       
       std::cout << ", align 4" << std::endl;
     } break;
@@ -517,9 +535,9 @@ void SysYPrinter::printInst(Instruction *pInst) {
         if (!firstPair) std::cout << ", ";
         firstPair = false;
         std::cout << "[ ";
-        printValue(phiInst->getIncomingValue(i));
+        printValue(phiInst->getValue(i));
         std::cout << ", %";
-        printBlock(phiInst->getIncomingBlock(i));
+        printBlock(phiInst->getBlock(i));
         std::cout << " ]";
       }
       std::cout << std::endl;

src/sysyc.cpp

@@ -21,8 +21,6 @@ using namespace sysy;
 
 int DEBUG = 0;
 int DEEPDEBUG = 0;
-int DEEPERDEBUG = 0;
-int DEBUGLENGTH = 50;
 
 static string argStopAfter;
 static string argInputFile;

testdata/functional/00_main.out

@@ -0,0 +1 @@
+3

testdata/functional/00_main.sy

@@ -0,0 +1,3 @@
+int main(){
+    return 3;
+}

testdata/functional/01_var_defn2.out

@@ -0,0 +1 @@
+10

testdata/functional/01_var_defn2.sy

@@ -0,0 +1,8 @@
+//test domain of global var define and local define
+int a = 3;
+int b = 5;
+
+int main(){
+    int a = 5;
+    return a + b;
+}

testdata/functional/02_var_defn3.out

@@ -0,0 +1 @@
+5

testdata/functional/02_var_defn3.sy

@@ -0,0 +1,8 @@
+//test local var define
+int main(){
+    int a, b0, _c;
+    a = 1;
+    b0 = 2;
+    _c = 3;
+    return b0 + _c;
+}

testdata/functional/03_arr_defn2.out

@@ -0,0 +1 @@
+0

testdata/functional/03_arr_defn2.sy

@@ -0,0 +1,4 @@
+int a[10][10];
+int main(){
+    return 0;
+}

testdata/functional/04_arr_defn3.out

@@ -0,0 +1 @@
+14

testdata/functional/04_arr_defn3.sy

@@ -0,0 +1,9 @@
+//test array define
+int main(){
+    int a[4][2] = {};
+    int b[4][2] = {1, 2, 3, 4, 5, 6, 7, 8};
+    int c[4][2] = {{1, 2}, {3, 4}, {5, 6}, {7, 8}};
+    int d[4][2] = {1, 2, {3}, {5}, 7 , 8};
+    int e[4][2] = {{d[2][1], c[2][1]}, {3, 4}, {5, 6}, {7, 8}};
+    return e[3][1] + e[0][0] + e[0][1] + a[2][0];
+}

testdata/functional/05_arr_defn4.out

@@ -0,0 +1 @@
+21

testdata/functional/05_arr_defn4.sy

@@ -0,0 +1,9 @@
+int main(){
+    const int a[4][2] = {{1, 2}, {3, 4}, {}, 7};
+
+    int b[4][2] = {};
+    int c[4][2] = {1, 2, 3, 4, 5, 6, 7, 8};
+    int d[3 + 1][2] = {1, 2, {3}, {5}, a[3][0], 8};
+    int e[4][2][1] = {{d[2][1], {c[2][1]}}, {3, 4}, {5, 6}, {7, 8}};
+    return e[3][1][0] + e[0][0][0] + e[0][1][0] + d[3][0];
+}

testdata/functional/06_const_var_defn2.out

@@ -0,0 +1 @@
+5

testdata/functional/06_const_var_defn2.sy

@@ -0,0 +1,6 @@
+//test const gloal var define
+const int a = 10, b = 5;
+
+int main(){
+    return b;
+}

testdata/functional/07_const_var_defn3.out

@@ -0,0 +1 @@
+5

testdata/functional/07_const_var_defn3.sy

@@ -0,0 +1,5 @@
+//test const local var define
+int main(){
+    const int a = 10, b = 5;
+    return b;
+}

testdata/functional/08_const_array_defn.out

@@ -0,0 +1 @@
+4

testdata/functional/08_const_array_defn.sy

@@ -0,0 +1,5 @@
+const int a[5]={0,1,2,3,4};
+
+int main(){
+    return a[4];
+}

testdata/functional/09_func_defn.out

@@ -0,0 +1 @@
+9

testdata/functional/09_func_defn.sy

@@ -0,0 +1,11 @@
+int a;
+int func(int p){
+	p = p - 1;
+	return p;
+}
+int main(){
+	int b;
+	a = 10;
+	b = func(a);
+	return b;
+}

testdata/functional/10_var_defn_func.out

@@ -0,0 +1 @@
+4

testdata/functional/10_var_defn_func.sy

@@ -0,0 +1,8 @@
+int defn(){
+    return 4;
+}
+
+int main(){
+    int a=defn();
+    return a;
+}

testdata/functional/11_add2.out

@@ -0,0 +1 @@
+9

testdata/functional/11_add2.sy

@@ -0,0 +1,7 @@
+//test add
+int main(){
+    int a, b;
+    a = 10;
+    b = -1;
+    return a + b;
+}

testdata/functional/12_addc.out

@@ -0,0 +1 @@
+15

testdata/functional/12_addc.sy

@@ -0,0 +1,5 @@
+//test addc
+const int a = 10;
+int main(){
+    return a + 5;
+}

testdata/functional/13_sub2.out

@@ -0,0 +1 @@
+248