[IR]消除Falltrhough现象

[IR]优化生成Ret指令逻辑 [README]添加TODO表
[IR]重构数组地址相关指令
2025-07-20 18:23:48 +08:00 · 2025-07-20 15:33:58 +08:00 · 2025-07-20 13:00:15 +08:00 · 2025-07-20 12:54:19 +08:00 · 2025-07-20 12:45:52 +08:00 · 2025-07-19 18:00:42 +08:00
31 changed files with 2646 additions and 2335 deletions
--- a/README.md
+++ b/README.md
@ -38,3 +38,12 @@ mysysy/ $ bash setup.sh

 ### 配套脚本
   （TODO: 需要完善）
+
+
+### TODO_list:
+
+除开注释中的TODO后续时间充足可以考虑的TODO:
+
+- store load指令由于gep指令的引入, 维度信息的记录是非必须的, 考虑删除
+
+- use def关系经过mem2reg和phi函数明确转换为ssa形式, 以及函数参数通过value数组明确定义, 使得基本块的args参数信息记录非必须, 考虑删除
--- a/src/AddressCalculationExpansion.cpp
+++ b/src/AddressCalculationExpansion.cpp
@ -47,7 +47,7 @@ bool AddressCalculationExpansion::run() {
                    for (const auto& use_ptr : allocaInst->getDims()) {
                        Value* dimValue = use_ptr->getValue();
                        if (ConstantValue* constVal = dynamic_cast<ConstantValue*>(dimValue)) {
-                            dims.push_back(constVal->getValue<int>());
+                            dims.push_back(constVal->getInt());
                        } else {
                            std::cerr << "Warning: AllocaInst dimension is not a constant integer. Skipping GEP expansion for: ";
                            SysYPrinter::printValue(allocaInst);
@ -101,13 +101,13 @@ bool AddressCalculationExpansion::run() {
                    }
                }

-                Value* totalOffset = ConstantValue::get(0);
+                Value* totalOffset = ConstantInteger::get(0);
                pBuilder->setPosition(bb, it);

                for (size_t i = 0; i < indexOperands.size(); ++i) {
                    Value* index = indexOperands[i];
                    int stride = calculateStride(dims, i);
-                    Value* strideConst = ConstantValue::get(stride);
+                    Value* strideConst = ConstantInteger::get(stride);
                    Type* intType = Type::getIntType();
                    BinaryInst* currentDimOffsetInst = pBuilder->createBinaryInst(Instruction::kMul, intType, index, strideConst);
                    BinaryInst* newTotalOffsetInst = pBuilder->createBinaryInst(Instruction::kAdd, intType, totalOffset, currentDimOffsetInst);
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@ -21,16 +21,17 @@ add_executable(sysyc
  IR.cpp
  SysYIRGenerator.cpp
  SysYIRPrinter.cpp
-  SysYIROptPre.cpp
-  SysYIRAnalyser.cpp
-  DeadCodeElimination.cpp
+  SysYIRCFGOpt.cpp
+  # SysYIRAnalyser.cpp
+  # DeadCodeElimination.cpp
  AddressCalculationExpansion.cpp
-  Mem2Reg.cpp
-  Reg2Mem.cpp
+  # Mem2Reg.cpp
+  # Reg2Mem.cpp
  RISCv64Backend.cpp
  RISCv64ISel.cpp
  RISCv64RegAlloc.cpp
  RISCv64AsmPrinter.cpp
+  RISCv64Passes.cpp
 )

 # 设置 include 路径，包含 ANTLR 运行时库和项目头文件
--- a/src/DeadCodeElimination.cpp
+++ b/src/DeadCodeElimination.cpp
@ -37,7 +37,7 @@ void DeadCodeElimination::eliminateDeadStores(Function* func, bool& changed) {
      auto storeInst = dynamic_cast<StoreInst*>(inst);
      auto pointer = storeInst->getPointer();
      // 如果是全局变量或者是函数的数组参数
-      if (isGlobal(pointer) || (isArr(pointer) &&
+      if (SysYIROptUtils::isGlobal(pointer) || (SysYIROptUtils::isArr(pointer) &&
            std::find(func->getEntryBlock()->getArguments().begin(),
                    func->getEntryBlock()->getArguments().end(),
                    pointer) != func->getEntryBlock()->getArguments().end())) {
@ -63,7 +63,7 @@ void DeadCodeElimination::eliminateDeadStores(Function* func, bool& changed) {
          std::cout << "=== Dead Store Found ===\n";
          SysYPrinter::printInst(storeInst);
        }
-        usedelete(storeInst);
+        SysYIROptUtils::usedelete(storeInst);
        iter = instrs.erase(iter);
      } else {
        ++iter;
@ -85,7 +85,7 @@ void DeadCodeElimination::eliminateDeadLoads(Function* func, bool& changed) {
            std::cout << "=== Dead Load Binary Unary Found ===\n";
            SysYPrinter::printInst(inst);
          }
-          usedelete(inst);
+          SysYIROptUtils::usedelete(inst);
          iter = instrs.erase(iter);
          continue;
        }
@ -114,7 +114,7 @@ void DeadCodeElimination::eliminateDeadAllocas(Function* func, bool& changed) {
            std::cout << "=== Dead Alloca Found ===\n";
            SysYPrinter::printInst(inst);
          }
-          usedelete(inst);
+          SysYIROptUtils::usedelete(inst);
          iter = instrs.erase(iter);
          continue;
        }
@ -183,7 +183,7 @@ void DeadCodeElimination::eliminateDeadRedundantLoadStore(Function* func, bool&
        /// 如果 pointer 仅被该 phi 使用，可以删除 ph
        if (tag) {
          changed = true;
-          usedelete(inst);
+          SysYIROptUtils::usedelete(inst);
          iter = instrs.erase(iter);
          continue;
        }
@ -193,7 +193,7 @@ void DeadCodeElimination::eliminateDeadRedundantLoadStore(Function* func, bool&
        auto pointer = memsetInst->getPointer();
        if (pointer->getUses().empty()) {
          changed = true;
-          usedelete(inst);
+          SysYIROptUtils::usedelete(inst);
          iter = instrs.erase(iter);
          continue;
        }
@ -234,7 +234,7 @@ void DeadCodeElimination::eliminateDeadRedundantLoadStore(Function* func, bool&
                        SysYPrinter::printInst(loadInst);
                        SysYPrinter::printInst(nextStore);
                      }
-                      usedelete(loadInst);
+                      SysYIROptUtils::usedelete(loadInst);
                      iter = instrs.erase(iter);
                      // 删除 prevStore 这里是不是可以留给删除无用store处理？
                      // if (prevStore->getUses().empty()) {
@ -256,21 +256,4 @@ void DeadCodeElimination::eliminateDeadRedundantLoadStore(Function* func, bool&
 }


-bool DeadCodeElimination::isGlobal(Value *val){
-  auto gval = dynamic_cast<GlobalValue *>(val);
-  return gval != nullptr;
-}
-
-bool DeadCodeElimination::isArr(Value *val){
-  auto aval = dynamic_cast<AllocaInst *>(val);
-  return aval != nullptr && aval->getNumDims() != 0;
-}
-
-void DeadCodeElimination::usedelete(Instruction *instr){
-  for (auto &use1 : instr->getOperands()) {
-    auto val1 = use1->getValue();
-    val1->removeUse(use1);
-  }
-}
-
 } // namespace sysy
--- a/src/IR.cpp
+++ b/src/IR.cpp
@ -49,6 +49,11 @@ auto Type::getFunctionType(Type *returnType, const std::vector<Type *> &paramTyp
  return FunctionType::get(returnType, paramTypes);
 }

+auto Type::getArrayType(Type *elementType, unsigned numElements) -> Type * {
+  // forward to ArrayType
+  return ArrayType::get(elementType, numElements);
+}
+
 auto Type::getSize() const -> unsigned {
  switch (kind) {
    case kInt:
@ -58,6 +63,10 @@ auto Type::getSize() const -> unsigned {
    case kPointer:
    case kFunction:
      return 8;
+    case Kind::kArray: {
+      const ArrayType* arrType = static_cast<const ArrayType*>(this);
+      return arrType->getElementType()->getSize() * arrType->getNumElements();
+    }
    case kVoid:
      return 0;
  }
@ -95,6 +104,11 @@ FunctionType*FunctionType::get(Type *returnType, const std::vector<Type *> &para
  return result.first->get();
 }

+ArrayType *ArrayType::get(Type *elementType, unsigned numElements) {
+  // TODO:可以考虑在这里添加缓存，避免重复创建相同的数组类型
+  return new ArrayType(elementType, numElements);
+}
+
 void Value::replaceAllUsesWith(Value *value) {
  for (auto &use : uses) {
    use->getUser()->setOperand(use->getIndex(), value);
@ -102,30 +116,54 @@ void Value::replaceAllUsesWith(Value *value) {
  uses.clear();
 }

-ConstantValue* ConstantValue::get(int value) {
-  static std::map<int, std::unique_ptr<ConstantValue>> intConstants;
-  auto iter = intConstants.find(value);
-  if (iter != intConstants.end()) {
-    return iter->second.get();
-  }
-  auto inst = new ConstantValue(value);
-  assert(inst);
-  auto result = intConstants.emplace(value, inst);
-  return result.first->second.get();
+
+// Implementations for static members
+
+std::unordered_map<ConstantValueKey, ConstantValue*, ConstantValueHash, ConstantValueEqual> ConstantValue::mConstantPool;
+std::unordered_map<Type*, UndefinedValue*> UndefinedValue::UndefValues;
+
+ConstantValue* ConstantValue::get(Type* type, ConstantValVariant val) {
+  ConstantValueKey key = {type, val};
+  auto it = mConstantPool.find(key);
+  if (it != mConstantPool.end()) {
+    return it->second;
  }

-ConstantValue* ConstantValue::get(float value) {
-  static std::map<float, std::unique_ptr<ConstantValue>> floatConstants;
-  auto iter = floatConstants.find(value);
-  if (iter != floatConstants.end()) {
-    return iter->second.get();
+  ConstantValue* newConstant = nullptr;
+  if (std::holds_alternative<int>(val)) {
+    newConstant = new ConstantInteger(type, std::get<int>(val));
+  } else if (std::holds_alternative<float>(val)) {
+    newConstant = new ConstantFloating(type, std::get<float>(val));
+  } else {
+    assert(false && "Unsupported ConstantValVariant type");
  }
-  auto inst = new ConstantValue(value);
-  assert(inst);
-  auto result = floatConstants.emplace(value, inst);
-  return result.first->second.get();
+
+  mConstantPool[key] = newConstant;
+  return newConstant;
 }

+ConstantInteger* ConstantInteger::get(Type* type, int val) {
+  return dynamic_cast<ConstantInteger*>(ConstantValue::get(type, val));
+}
+
+ConstantFloating* ConstantFloating::get(Type* type, float val) {
+  return dynamic_cast<ConstantFloating*>(ConstantValue::get(type, val));
+}
+
+UndefinedValue* UndefinedValue::get(Type* type) {
+  assert(!type->isVoid() && "Cannot get UndefinedValue of void type!");
+
+  auto it = UndefValues.find(type);
+  if (it != UndefValues.end()) {
+    return it->second;
+  }
+
+  UndefinedValue* newUndef = new UndefinedValue(type);
+  UndefValues[type] = newUndef;
+  return newUndef;
+}
+
+
 auto Function::getCalleesWithNoExternalAndSelf() -> std::set<Function *> {
  std::set<Function *> result;
  for (auto callee : callees) {
@ -441,44 +479,7 @@ Function * Function::clone(const std::string &suffix) const  {
        break;
      }

-      case Instruction::kLa: {
-        auto oldLaInst = dynamic_cast<LaInst *>(inst);
-        auto oldPointer = oldLaInst->getPointer();
-        Value *newPointer;
-        std::vector<Value *> newIndices;
-        newPointer = oldNewValueMap.at(oldPointer);
-
-        for (const auto &index : oldLaInst->getIndices()) {
-          newIndices.emplace_back(oldNewValueMap.at(index->getValue()));
-        }
-        ss << oldLaInst->getName() << suffix;
-        auto newLaInst = new LaInst(newPointer, newIndices, oldNewBlockMap.at(oldLaInst->getParent()), ss.str());
-        ss.str("");
-        oldNewValueMap.emplace(oldLaInst, newLaInst);
-        break;
-      }
-
-      case Instruction::kGetSubArray: {
-        auto oldGetSubArrayInst = dynamic_cast<GetSubArrayInst *>(inst);
-        auto oldFather = oldGetSubArrayInst->getFatherArray();
-        auto oldChild = oldGetSubArrayInst->getChildArray();
-        Value *newFather;
-        Value *newChild;
-        std::vector<Value *> newIndices;
-        newFather = oldNewValueMap.at(oldFather);
-        newChild = oldNewValueMap.at(oldChild);
-
-        for (const auto &index : oldGetSubArrayInst->getIndices()) {
-          newIndices.emplace_back(oldNewValueMap.at(index->getValue()));
-        }
-        ss << oldGetSubArrayInst->getName() << suffix;
-        auto newGetSubArrayInst =
-            new GetSubArrayInst(dynamic_cast<LVal *>(newFather), dynamic_cast<LVal *>(newChild), newIndices,
-                                oldNewBlockMap.at(oldGetSubArrayInst->getParent()), ss.str());
-        ss.str("");
-        oldNewValueMap.emplace(oldGetSubArrayInst, newGetSubArrayInst);
-        break;
-      }
+      // TODO：复制GEP指令

      case Instruction::kMemset: {
        auto oldMemsetInst = dynamic_cast<MemsetInst *>(inst);
@ -545,6 +546,83 @@ void User::replaceOperand(unsigned index, Value *value) {
  value->addUse(use);
 }

+/**
+ * phi相关函数
+ */
+
+ Value* PhiInst::getvalfromBlk(BasicBlock* blk){
+  refreshB2VMap();
+  if( blk2val.find(blk) != blk2val.end()) {
+    return blk2val.at(blk);
+  }
+  return nullptr;
+}
+
+BasicBlock* PhiInst::getBlkfromVal(Value* val){
+  // 返回第一个值对应的基本块
+  for(unsigned i = 0; i < vsize; i++) {
+    if(getValue(i) == val) {
+      return getBlock(i);
+    }
+  }
+  return nullptr;
+}
+
+void PhiInst::delValue(Value* val){
+  //根据value删除对应的基本块和值
+  unsigned i = 0;
+  BasicBlock* blk = getBlkfromVal(val);
+  for(i = 0; i < vsize; i++) {
+    if(getValue(i) == val) {
+      break;
+    }
+  }
+  removeOperand(2 * i + 1); // 删除blk
+  removeOperand(2 * i); // 删除val
+  vsize--;
+  blk2val.erase(blk); // 删除blk2val映射
+}
+
+void PhiInst::delBlk(BasicBlock* blk){
+  //根据Blk删除对应的基本块和值
+  unsigned i = 0;
+  Value* val = getvalfromBlk(blk);
+  for(i = 0; i < vsize; i++) {
+    if(getBlock(i) == blk) {
+      break;
+    }
+  }
+  removeOperand(2 * i + 1); // 删除blk
+  removeOperand(2 * i); // 删除val
+  vsize--;
+  blk2val.erase(blk); // 删除blk2val映射
+}
+
+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::replaceold2new(BasicBlock* oldBlk, BasicBlock* newBlk){
+  refreshB2VMap();
+  Value* val = blk2val.at(oldBlk);
+  // 替换基本块
+  delBlk(oldBlk);
+  addIncoming(val, newBlk);
+}
+
+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)
    : Instruction(kCall, callee->getReturnType(), parent, name) {
  addOperand(callee);
--- a/src/Mem2Reg.cpp
+++ b/src/Mem2Reg.cpp
--- a/src/RISCv64Backend.cpp
+++ b/src/RISCv64Backend.cpp
@ -2,6 +2,7 @@
 #include "RISCv64ISel.h"
 #include "RISCv64RegAlloc.h"
 #include "RISCv64AsmPrinter.h"
+#include "RISCv64Passes.h" // 包含优化Pass的头文件
 #include <sstream>

 namespace sysy {
@ -11,7 +12,7 @@ std::string RISCv64CodeGen::code_gen() {
    return module_gen();
 }

-// 模块级代码生成 (移植自原文件，处理.data段和驱动函数生成)
+// 模块级代码生成
 std::string RISCv64CodeGen::module_gen() {
    std::stringstream ss;
    
@ -52,17 +53,31 @@ std::string RISCv64CodeGen::module_gen() {
    return ss.str();
 }

-// function_gen 现在是新的、模块化的处理流水线
+// function_gen 现在是包含具体优化名称的、完整的处理流水线
 std::string RISCv64CodeGen::function_gen(Function* func) {
+    // === 完整的后端处理流水线 ===
+
    // 阶段 1: 指令选择 (sysy::IR -> LLIR with virtual registers)
    RISCv64ISel isel;
    std::unique_ptr<MachineFunction> mfunc = isel.runOnFunction(func);

-    // 阶段 2: 寄存器分配 (包含栈帧布局, 活跃性分析, 图着色, spill/rewrite)
+    // 阶段 2: 指令调度 (Instruction Scheduling)
+    PreRA_Scheduler scheduler;
+    scheduler.runOnMachineFunction(mfunc.get());
+
+    // 阶段 3: 物理寄存器分配 (Register Allocation)
    RISCv64RegAlloc reg_alloc(mfunc.get());
    reg_alloc.run();

-    // 阶段 3: 代码发射 (LLIR with physical regs -> Assembly Text)
+    // 阶段 4: 窥孔优化 (Peephole Optimization)
+    PeepholeOptimizer peephole;
+    peephole.runOnMachineFunction(mfunc.get());
+
+    // 阶段 5: 局部指令调度 (Local Scheduling)
+    PostRA_Scheduler local_scheduler;
+    local_scheduler.runOnMachineFunction(mfunc.get());
+
+    // 阶段 6: 代码发射 (Code Emission)
    std::stringstream ss;
    RISCv64AsmPrinter printer(mfunc.get());
    printer.run(ss);
--- a/src/RISCv64Passes.cpp
+++ b/src/RISCv64Passes.cpp
@ -1,8 +1,54 @@
-// RISCv64Passes.cpp
 #include "RISCv64Passes.h"
+#include <iostream>

 namespace sysy {

-// 此处为未来优化Pass的实现
+// --- 寄存器分配前优化 ---
+
+void PreRA_Scheduler::runOnMachineFunction(MachineFunction* mfunc) {
+    // TODO: 在此实现寄存器分配前的指令调度。
+    // 遍历mfunc中的每一个MachineBasicBlock。
+    // 对每个基本块内的MachineInstr列表进行重排。
+    //
+    // 实现思路:
+    // 1. 分析每个基本块内指令的数据依赖关系，构建依赖图(DAG)。
+    // 2. 根据目标处理器的流水线特性（指令延迟等），使用列表调度等算法对指令进行重排。
+    // 3. 此时操作的是虚拟寄存器，只存在真依赖，调度自由度最大。
+    //
+    // std::cout << "Running Pre-RA Instruction Scheduler..." << std::endl;
+}
+
+
+// --- 寄存器分配后优化 ---
+
+void PeepholeOptimizer::runOnMachineFunction(MachineFunction* mfunc) {
+    // TODO: 在此实现窥孔优化。
+    // 遍历mfunc中的每一个MachineBasicBlock。
+    // 对每个基本块内的MachineInstr列表进行扫描和替换。
+    //
+    // 实现思路:
+    // 1. 维护一个大小固定（例如3-5条指令）的滑动窗口。
+    // 2. 识别特定的冗余模式，例如:
+    //    - `mv a0, a1` 后紧跟 `mv a1, a0` (可消除的交换)
+    //    - `sw t0, 12(s0)` 后紧跟 `lw t1, 12(s0)` (冗余加载)
+    //    - 强度削减: `mul x, x, 2` -> `slli x, x, 1`
+    // 3. 识别后，直接修改MachineInstr列表（删除、替换或插入指令）。
+    //
+    // std::cout << "Running Post-RA Peephole Optimizer..." << std::endl;
+}
+
+void PostRA_Scheduler::runOnMachineFunction(MachineFunction* mfunc) {
+    // TODO: 在此实现寄存器分配后的局部指令调度。
+    // 遍历mfunc中的每一个MachineBasicBlock。
+    // 重点关注由寄存器分配器插入的spill/fill代码。
+    //
+    // 实现思路:
+    // 1. 识别出用于spill/fill的lw/sw指令。
+    // 2. 在不违反数据依赖（包括物理寄存器引入的伪依赖）的前提下，
+    //    尝试将lw指令向上移动，使其与使用它的指令之间有足够的距离，以隐藏访存延迟。
+    // 3. 同样，可以尝试将sw指令向下移动。
+    //
+    // std::cout << "Running Post-RA Local Scheduler..." << std::endl;
+}

 } // namespace sysy
--- a/src/Reg2Mem.cpp
+++ b/src/Reg2Mem.cpp
@ -103,7 +103,7 @@ void Reg2Mem::DeletePhiInst(){
          }
          // 删除phi指令
          auto &instructions = basicBlock->getInstructions();
-          usedelete(iter->get());
+          SysYIROptUtils::usedelete(iter->get());
          iter = instructions.erase(iter);
          if (basicBlock->getNumInstructions() == 0) {
            if (basicBlock->getNumSuccessors() == 1) {
@ -119,11 +119,4 @@ void Reg2Mem::DeletePhiInst(){
  }
 }

-void Reg2Mem::usedelete(Instruction *instr) {
-  for (auto &use : instr->getOperands()) {
-    auto val = use->getValue();
-    val->removeUse(use);
-  }
-}
-
 }  // namespace sysy
--- a/src/SysYIRAnalyser.cpp
+++ b/src/SysYIRAnalyser.cpp
@ -523,9 +523,6 @@ bool ActiveVarAnalysis::analyze(Module *pModule, BasicBlock *block) {
 }


-auto ActiveVarAnalysis::getActiveTable() const -> const std::map<BasicBlock *, std::vector<std::set<User *>>> & {
-  return activeTable;
-}


 } // namespace sysy
--- a/src/SysYIRCFGOpt.cpp
+++ b/src/SysYIRCFGOpt.cpp
@ -0,0 +1,565 @@
+#include "SysYIRCFGOpt.h"
+#include "SysYIROptUtils.h"
+#include <cassert>
+#include <list>
+#include <map>
+#include <memory>
+#include <string>
+#include <iostream>
+#include "IR.h"
+#include "IRBuilder.h"
+
+namespace sysy {
+
+
+// 删除br后的无用指令
+bool SysYCFGOpt::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 (Branch) 
+        SysYIROptUtils::usedelete(iter->get());
+      else if ((*iter)->isTerminator()){
+        Branch = true;
+        Branchiter = iter;
+      }
+    }
+    if (Branchiter != instructions.end()) ++Branchiter;
+    while (Branchiter != instructions.end()) {
+      changed = true;
+      Branchiter = instructions.erase(Branchiter);
+    }
+    
+    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()) {
+        BasicBlock* branchBlock = dynamic_cast<BasicBlock *>(thelastinstinst->get()->getOperand(0));
+        basicBlock->addSuccessor(branchBlock);
+        branchBlock->addPredecessor(basicBlock.get());
+      } else if (thelastinstinst->get()->isConditional()) {
+        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());
+        elseBlock->addPredecessor(basicBlock.get());
+      }
+    }
+  }
+
+  return changed;
+}
+
+// 合并空基本块
+bool SysYCFGOpt::SysYBlockMerge(Function *func) {
+  bool changed = false;
+
+  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];
+        auto nextarguments = nextBlock->getArguments();
+        // 删除br指令
+        if (block->getNumInstructions() != 0) {
+          auto thelastinstinst = block->end();
+          (--thelastinstinst);
+          if (thelastinstinst->get()->isUnconditional()) {
+            SysYIROptUtils::usedelete(thelastinstinst->get());
+            block->getInstructions().erase(thelastinstinst);
+          } else if (thelastinstinst->get()->isConditional()) {
+            // 如果是条件分支，判断条件是否相同，主要优化相同布尔表达式
+            if (thelastinstinst->get()->getOperand(1)->getName() == thelastinstinst->get()->getOperand(1)->getName()) {
+              SysYIROptUtils::usedelete(thelastinstinst->get());
+              block->getInstructions().erase(thelastinstinst);
+            }
+          }
+        }
+        // 将后继块的指令移动到当前块
+        // 并将后继块的父指针改为当前块
+        for (auto institer = nextBlock->begin(); institer != nextBlock->end();) {
+          institer->get()->setParent(block);
+          block->getInstructions().emplace_back(institer->release());
+          institer = nextBlock->getInstructions().erase(institer);   
+        }
+        // 合并参数
+        // TODO：是否需要去重?
+        for (auto &argm : nextarguments) {
+          argm->setParent(block);
+          block->insertArgument(argm);
+        }
+        // 更新前驱后继关系，类似树节点操作
+        block->removeSuccessor(nextBlock);
+        nextBlock->removePredecessor(block);
+        std::list<BasicBlock *> succshoulddel;
+        for (auto &succ : nextBlock->getSuccessors()) {
+          block->addSuccessor(succ);
+          succ->replacePredecessor(nextBlock, block);
+          succshoulddel.push_back(succ);
+        }
+        for (auto del : succshoulddel) {
+          nextBlock->removeSuccessor(del);
+        }
+
+        func->removeBasicBlock(nextBlock);
+        changed = true;
+
+      } else {
+        blockiter++;
+      }
+    } else {
+      blockiter++;
+    }
+  }
+
+  return changed;
+}
+
+// 删除无前驱块，兼容SSA后的处理
+bool SysYCFGOpt::SysYDelNoPreBLock(Function *func) {
+  
+  bool changed = false;
+
+  for (auto &block : func->getBasicBlocks()) {
+    block->setreachableFalse();
+  }
+  // 对函数基本块做一个拓扑排序，排查不可达基本块
+  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);
+      }
+    }
+  }
+
+  // 删除不可达基本块指令
+  for (auto blockIter = func->getBasicBlocks().begin(); blockIter != func->getBasicBlocks().end();blockIter++) {
+    if (!blockIter->get()->getreachable()) 
+      for (auto &iterInst : blockIter->get()->getInstructions()) 
+        SysYIROptUtils::usedelete(iterInst.get());
+  
+  }
+
+  
+  for (auto blockIter = func->getBasicBlocks().begin(); blockIter != func->getBasicBlocks().end();) {
+    if (!blockIter->get()->getreachable()) {
+      for (auto succblock : blockIter->get()->getSuccessors()) {
+        int indexphi = 1;
+        for (auto pred : succblock->getPredecessors()) {
+          if (pred == blockIter->get()) {
+            break;
+          }
+          indexphi++;
+        }
+        for (auto &phiinst : succblock->getInstructions()) {
+          if (phiinst->getKind() != Instruction::kPhi) {
+            break;
+          }
+          phiinst->removeOperand(indexphi);
+        }
+      }
+      // 删除不可达基本块，注意迭代器不可达问题
+      func->removeBasicBlock((blockIter++)->get());
+      changed = true;
+    } else {
+      blockIter++;
+    }
+  }
+  
+  return changed;
+}
+
+// 删除空块
+bool SysYCFGOpt::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)
+        EmptyBlocks[basicBlock.get()] = basicBlock->getSuccessors().front();
+    }
+    
+    
+  }
+  // 更新基本块信息，增加必要指令
+  for (auto &basicBlock : basicBlocks) {
+    // 把空块转换成只有跳转指令的不可达块
+    if (distance(basicBlock->begin(), basicBlock->end()) == 0) {
+      if (basicBlock->getNumSuccessors() == 0) {
+        continue;
+      }
+      if (basicBlock->getNumSuccessors() > 1) {
+        assert("");
+      }
+      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.find(dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0))) !=
+              EmptyBlocks.end()) {
+        thelastBlockOld = dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0));
+        thelastinst->get()->replaceOperand(0, EmptyBlocks[thelastBlockOld]);
+      }
+
+      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());
+
+      if (thelastBlockOld != nullptr) {
+        int indexphi = 0;
+        for (auto &pred : dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0))->getPredecessors()) {
+          if (pred == thelastBlockOld) {
+            break;
+          }
+          indexphi++;
+        }
+
+        // 更新phi指令的操作数
+        // 移除thelastBlockOld对应的phi操作数
+        for (auto &InstInNew : dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0))->getInstructions()) {
+          if (InstInNew->isPhi()) {
+            dynamic_cast<PhiInst *>(InstInNew.get())->removeOperand(indexphi + 1);
+          } 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));
+
+      BasicBlock *thelastBlockOld = nullptr;
+      while (EmptyBlocks.find(dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1))) !=
+              EmptyBlocks.end()) {
+        thelastBlockOld = dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1));
+        thelastinst->get()->replaceOperand(
+            1, EmptyBlocks[dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1))]);
+      }
+      basicBlock->removeSuccessor(OldThenBlock);
+      OldThenBlock->removePredecessor(basicBlock.get());
+      // 处理 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, {});
+        continue;
+      }
+      basicBlock->addSuccessor(dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1)));
+      dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1))->addPredecessor(basicBlock.get());
+      // auto indexInNew = dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0))->getPredecessors().
+
+      if (thelastBlockOld != nullptr) {
+        int indexphi = 0;
+        for (auto &pred : dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1))->getPredecessors()) {
+          if (pred == thelastBlockOld) {
+            break;
+          }
+          indexphi++;
+        }
+
+        for (auto &InstInNew : dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1))->getInstructions()) {
+          if (InstInNew->isPhi()) {
+            dynamic_cast<PhiInst *>(InstInNew.get())->removeOperand(indexphi + 1);
+          } else {
+            break;
+          }
+        }
+      }
+
+      thelastBlockOld = nullptr;
+      while (EmptyBlocks.find(dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2))) !=
+              EmptyBlocks.end()) {
+        thelastBlockOld = dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2));
+        thelastinst->get()->replaceOperand(
+            2, EmptyBlocks[dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2))]);
+      }
+      basicBlock->removeSuccessor(OldElseBlock);
+      OldElseBlock->removePredecessor(basicBlock.get());
+      // 处理 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, {});
+        continue;
+      }
+      basicBlock->addSuccessor(dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2)));
+      dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2))->addPredecessor(basicBlock.get());
+
+      if (thelastBlockOld != nullptr) {
+        int indexphi = 0;
+        for (auto &pred : dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2))->getPredecessors()) {
+          if (pred == thelastBlockOld) {
+            break;
+          }
+          indexphi++;
+        }
+        for (auto &InstInNew : dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2))->getInstructions()) {
+          if (InstInNew->isPhi()) {
+            dynamic_cast<PhiInst *>(InstInNew.get())->removeOperand(indexphi + 1);
+          } else {
+            break;
+          }
+        }
+      }
+    } else {
+      if (basicBlock->getNumSuccessors() == 1) {
+        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());
+        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.find(iter->get()) != EmptyBlocks.end()) {
+      // EntryBlock跳过
+      if (iter->get() == func->getEntryBlock()) {
+        ++iter;
+        continue;
+      }
+
+      for (auto &iterInst : iter->get()->getInstructions()) 
+        SysYIROptUtils::usedelete(iterInst.get());
+      // 删除不可达基本块的phi指令的操作数
+      for (auto &succ : iter->get()->getSuccessors()) {
+        int index = 0;
+        for (auto &pred : succ->getPredecessors()) {
+          if (pred == iter->get()) {
+            break;
+          }
+          index++;
+        }
+
+        for (auto &instinsucc : succ->getInstructions()) {
+          if (instinsucc->isPhi()) {
+            dynamic_cast<PhiInst *>(instinsucc.get())->removeOperand(index);
+          } else {
+            break;
+          }
+        }
+      }
+
+      func->removeBasicBlock((iter++)->get());
+      changed = true;
+    } else {
+      ++iter;
+    }
+  }
+  
+  return changed;
+
+}
+
+// 如果函数没有返回指令，则添加一个默认返回指令(主要解决void函数没有返回指令的问题)
+bool SysYCFGOpt::SysYAddReturn(Function *func, IRBuilder* pBuilder) {
+  bool changed = false;
+  auto basicBlocks = func->getBasicBlocks();
+  for (auto &block : basicBlocks) {
+    if (block->getNumSuccessors() == 0) {
+      changed = true;
+      // 如果基本块没有后继块，则添加一个返回指令
+      if (block->getNumInstructions() == 0) {
+        pBuilder->setPosition(block.get(), block->end());
+        pBuilder->createReturnInst();
+      }
+      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;
+
+        pBuilder->setPosition(block.get(), block->end());
+        // TODO: 如果int float函数缺少返回值是否需要报错
+        if (func->getReturnType()->isInt()) {
+          pBuilder->createReturnInst(ConstantInteger::get(0));
+        } else if (func->getReturnType()->isFloat()) {
+          pBuilder->createReturnInst(ConstantFloating::get(0.0F));
+        } else {
+          pBuilder->createReturnInst();
+        }
+      }
+    }
+  }
+  
+  return changed;
+}
+
+// 条件分支转换为无条件分支
+// 主要针对已知条件值的分支转换为无条件分支
+// 例如 if (cond) { ... } else { ... } 中的 cond 已经
+// 确定为 true 或 false 的情况
+bool SysYCFGOpt::SysYCondBr2Br(Function *func, IRBuilder* pBuilder) {
+  bool changed = false;
+
+  for (auto &basicblock : func->getBasicBlocks()) {
+    if (basicblock->getNumInstructions() == 0)
+      continue;
+    
+    auto thelast = basicblock->getInstructions().end();
+    --thelast;
+
+    if (thelast->get()->isConditional()){
+      ConstantValue *constOperand = dynamic_cast<ConstantValue *>(thelast->get()->getOperand(0));
+      std::string opname;
+      int constint = 0;
+      float constfloat = 0.0F;
+      bool constint_Use = false;
+      bool constfloat_Use = false;
+      if (constOperand != nullptr) {
+        if (constOperand->isFloat()) {
+          constfloat = constOperand->getFloat();
+          constfloat_Use = true;
+        } else {
+          constint = constOperand->getInt();
+          constint_Use = true;
+        }
+      }
+      // 如果可以计算
+      if (constfloat_Use || constint_Use) {
+        changed = true;
+
+        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)) {
+
+          pBuilder->setPosition(basicblock.get(), basicblock->end());
+          pBuilder->createUncondBrInst(thenBlock, {});
+          int phiindex = 0;
+          for (auto pred : elseBlock->getPredecessors()) {
+            phiindex++;
+            if (pred == basicblock.get()) {
+              break;
+            }
+          }
+
+          for (auto &phiinst : elseBlock->getInstructions()) {
+            if (phiinst->getKind() != Instruction::kPhi) {
+              break;
+            }
+            phiinst->removeOperand(phiindex);
+          }
+          basicblock->removeSuccessor(elseBlock);
+          elseBlock->removePredecessor(basicblock.get());
+        } else {
+
+          pBuilder->setPosition(basicblock.get(), basicblock->end());
+          pBuilder->createUncondBrInst(elseBlock, {});
+          int phiindex = 0;
+          for (auto pred : thenBlock->getPredecessors()) {
+            phiindex++;
+            if (pred == basicblock.get()) {
+              break;
+            }
+          }
+
+          for (auto &phiinst : thenBlock->getInstructions()) {
+            if (phiinst->getKind() != Instruction::kPhi) {
+              break;
+            }
+            phiinst->removeOperand(phiindex);
+          }
+          basicblock->removeSuccessor(thenBlock);
+          thenBlock->removePredecessor(basicblock.get());
+        }
+      }
+    }
+  }
+
+  return changed;
+}
+
+}  // namespace sysy
--- a/src/SysYIRGenerator.cpp
+++ b/src/SysYIRGenerator.cpp
@ -10,12 +10,78 @@
 #include <sstream>
 #include <string>
 #include <vector>
-using namespace std;
 #include "SysYIRGenerator.h"

-
+using namespace std;
 namespace sysy {

+
+Type* SysYIRGenerator::buildArrayType(Type* baseType, const std::vector<Value*>& dims){
+  Type* currentType = baseType;
+    // 从最内层维度开始构建 ArrayType
+    // 例如对于 int arr[2][3]，先处理 [3]，再处理 [2]
+    // 注意：SysY 的 dims 是从最外层到最内层，所以我们需要反向迭代
+    // 或者调整逻辑，使得从内到外构建 ArrayType
+    // 假设 dims 列表是 [dim1, dim2, dim3...] (例如 [2, 3] for int[2][3])
+    // 我们需要从最内层维度开始向外构建 ArrayType
+    for (int i = dims.size() - 1; i >= 0; --i) {
+        // 维度大小必须是常量，否则无法构建 ArrayType
+        ConstantInteger* constDim = dynamic_cast<ConstantInteger*>(dims[i]);
+        if (constDim == nullptr) {
+            // 如果维度不是常量，可能需要特殊处理，例如将其视为指针
+            // 对于函数参数 int arr[] 这种，第一个维度可以为未知
+            // 在这里，我们假设所有声明的数组维度都是常量
+            assert(false && "Array dimension must be a constant integer!");
+            return nullptr;
+        }
+        unsigned dimSize = constDim->getInt();
+        currentType = Type::getArrayType(currentType, dimSize);
+    }
+    return currentType;
+}
+
+Value* SysYIRGenerator::getGEPAddressInst(Value* basePointer, const std::vector<Value*>& indices) {
+    // 检查 basePointer 是否为指针类型
+    if (!basePointer->getType()->isPointer()) {
+      assert(false && "GEP base pointer must be a pointer type!");
+    }
+
+    // 获取基指针所指向的实际类型 (例如 int* 指向 int, int[2][3]* 指向 int[2][3])
+    Type* currentElementType = basePointer->getType()->as<PointerType>()->getBaseType();
+
+    std::vector<Value*> actualGEPIndices;
+    // GEP 指令的第一个索引通常是0，用于“跳过”基指针指向的聚合类型本身，直接指向其第一个元素。
+    // 例如，对于 AllocaInst 返回的 `int[2][3]*`，第一个 `0` 索引表示从数组的开始而不是指针本身开始索引。
+    actualGEPIndices.push_back(ConstantInteger::get(0));
+
+    // 将用户提供的索引添加到 GEP 操作数中
+    for (Value* index : indices) {
+        actualGEPIndices.push_back(index);
+    }
+
+    // 根据索引链计算最终的元素类型
+    Type* finalTargetType = currentElementType;
+
+    // 遍历用户提供的索引（不包括我们添加的第一个0），逐步确定 GEP 的最终结果类型
+    // 每个索引都“深入”一个维度
+    for (size_t i = 0; i < indices.size(); ++i) { // 这里遍历的是用户提供的索引
+        if (finalTargetType && finalTargetType->isArray()) {
+            finalTargetType = finalTargetType->as<ArrayType>()->getElementType();
+        } else {
+            // 如果索引链还在继续，但当前类型已经不是数组或聚合类型，这通常是一个错误
+            // 或者表示访问的是标量，后续索引无效。此时，finalTargetType 已经是最终的标量类型，不能再深入。
+            // 例如，对 int arr[5]; 访问 arr[i][j] (j 是多余的)，这里会停止类型推断。
+            break;
+        }
+    }
+
+    // GEP 的结果总是指针类型，指向最终计算出的元素
+    Type* gepResultType = Type::getPointerType(finalTargetType);
+
+    // 创建 GEP 指令。假设 builder.createGetElementPtrInst 的签名为
+    // (Type* resultType, Value* basePointer, const std::vector<Value*>& indices)
+    return builder.createGetElementPtrInst(basePointer, actualGEPIndices);
+}
 /*
 * @brief: visit compUnit
 * @details:
@ -119,41 +185,111 @@ std::any SysYIRGenerator::visitVarDecl(SysYParser::VarDeclContext *ctx) {
      }
    }

+    Type* variableType = type;
+    if (!dims.empty()) { // 如果有维度，说明是数组
+        variableType = buildArrayType(type, dims); // 构建完整的 ArrayType
+    }
+
+    // 对于数组，alloca 的类型将是指针指向数组类型，例如 `int[2][3]*`
+    // 对于标量，alloca 的类型将是指针指向标量类型，例如 `int*`
    AllocaInst* alloca =
        builder.createAllocaInst(Type::getPointerType(type), dims, name);

    if (varDef->initVal() != nullptr) {
      ValueCounter values;
-      // 这里的varDef->initVal()可能是ScalarInitValue或ArrayInitValue
      ArrayValueTree* root = std::any_cast<ArrayValueTree *>(varDef->initVal()->accept(this));
      Utils::tree2Array(type, root, dims, dims.size(), values, &builder);
      delete root;
-      if (dims.empty()) {
+
+      if (dims.empty()) { // 标量变量初始化
        builder.createStoreInst(values.getValue(0), alloca);
-      } else {
-        // 对于多维数组，使用memset初始化
-        // 计算每个维度的大小
-        // 这里的values.getNumbers()返回的是每个维度的大小
-        // 这里的values.getValues()返回的是每个维度对应的值
-        // 例如：对于一个二维数组，values.getNumbers()可能是[3, 4]，表示3行4列
-        // values.getValues()可能是[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
-        // 对于每个维度，使用memset将对应的值填充到数组中
-        // 这里的alloca是一个指向数组的指针
-        const std::vector<unsigned int> & counterNumbers = values.getNumbers();
+      } else { // 数组变量初始化
        const std::vector<sysy::Value *> &counterValues = values.getValues();
-        unsigned begin = 0;
-        for (size_t i = 0; i < counterNumbers.size(); i++) {
+
+        int numElements = 1;
+        std::vector<int> dimSizes;
+        for (Value *dimVal : dims) {
+          if (ConstantInteger *constInt = dynamic_cast<ConstantInteger *>(dimVal)) {
+            int dimSize = constInt->getInt();
+            numElements *= dimSize;
+            dimSizes.push_back(dimSize);
+          }
+          // TODO else 错误处理：数组维度必须是常量（对于静态分配）
+        }
+        unsigned int elementSizeInBytes = type->getSize();
+        unsigned int totalSizeInBytes = numElements * elementSizeInBytes;
+
+        bool allValuesAreZero = false;
+        if (counterValues.empty()) {
+          allValuesAreZero = true;
+        }
+        else {
+          allValuesAreZero = true;
+          for (Value *val : counterValues){
+            if (ConstantInteger *constInt = dynamic_cast<ConstantInteger *>(val)){
+              if (constInt->getInt() != 0){
+                allValuesAreZero = false;
+                break;
+              }
+            }
+            else{
+              allValuesAreZero = false;
+              break;
+            }
+          }
+        }
+
+        if (allValuesAreZero) {
+          builder.createMemsetInst(
+              alloca,
+              ConstantInteger::get(0),
+              ConstantInteger::get(totalSizeInBytes),
+              ConstantInteger::get(0));
+        }
+        else {
+          for (size_t k = 0; k < counterValues.size(); ++k) {
+            std::vector<Value *> currentIndices;
+            int tempLinearIndex = k;
+
+            // 将线性索引转换为多维索引
+            for (int dimIdx = dimSizes.size() - 1; dimIdx >= 0; --dimIdx)
+            {
+              currentIndices.insert(currentIndices.begin(),
+                                    ConstantInteger::get(static_cast<int>(tempLinearIndex % dimSizes[dimIdx])));
+              tempLinearIndex /= dimSizes[dimIdx];
+            }
+
+            // 计算元素的地址
+            Value* elementAddress = getGEPAddressInst(alloca, currentIndices);
+            // 生成 store 指令 (假设 createStoreInst 接受 Value* value, Value* pointer)
+            builder.createStoreInst(counterValues[k], elementAddress);
+          }
+        }
+      }
+    }
+    else { // 如果没有显式初始化值，默认对数组进行零初始化
+      if (!dims.empty()) { // 只有数组才需要默认的零初始化
+        int numElements = 1;
+        for (Value *dimVal : dims) {
+          if (ConstantInteger *constInt = dynamic_cast<ConstantInteger *>(dimVal)) {
+            numElements *= constInt->getInt();
+          }
+        }
+        unsigned int elementSizeInBytes = type->getSize();
+        unsigned int totalSizeInBytes = numElements * elementSizeInBytes;

        builder.createMemsetInst(
-              alloca, ConstantValue::get(static_cast<int>(begin)),
-              ConstantValue::get(static_cast<int>(counterNumbers[i])),
-              counterValues[i]);
-          begin += counterNumbers[i];
-        }
+            alloca,
+            ConstantInteger::get(0),
+            ConstantInteger::get(totalSizeInBytes),
+            ConstantInteger::get(0)
+          );
      }
    }
+
    module->addVariable(name, alloca);
  }
+
  return std::any();
 }

@ -204,7 +340,6 @@ std::any SysYIRGenerator::visitFuncType(SysYParser::FuncTypeContext *ctx) {
 std::any SysYIRGenerator::visitFuncDef(SysYParser::FuncDefContext *ctx){
  // 更新作用域
  module->enterNewScope();
-  HasReturnInst = false;

  auto name = ctx->Ident()->getText();
  std::vector<Type *> paramTypes;
@ -218,7 +353,7 @@ std::any SysYIRGenerator::visitFuncDef(SysYParser::FuncDefContext *ctx){
      paramNames.push_back(param->Ident()->getText());
      std::vector<Value *> dims = {};
      if (!param->LBRACK().empty()) {
-        dims.push_back(ConstantValue::get(-1)); // 第一个维度不确定
+        dims.push_back(ConstantInteger::get(-1)); // 第一个维度不确定
        for (const auto &exp : param->exp()) {
          dims.push_back(std::any_cast<Value *>(visitExp(exp)));
        }
@ -240,22 +375,34 @@ std::any SysYIRGenerator::visitFuncDef(SysYParser::FuncDefContext *ctx){
    module->addVariable(paramNames[i], alloca);
  }

+  // 在处理函数体之前，创建一个新的基本块作为函数体的实际入口
+  // 这样 entryBB 就可以在完成初始化后跳转到这里
+  BasicBlock* funcBodyEntry = function->addBasicBlock("funcBodyEntry");
+  
+  // 从 entryBB 无条件跳转到 funcBodyEntry
+  builder.createUncondBrInst(funcBodyEntry, {});
+  builder.setPosition(funcBodyEntry,funcBodyEntry->end()); // 将插入点设置到 funcBodyEntry
+
  for (auto item : ctx->blockStmt()->blockItem()) {
    visitBlockItem(item);
  }

-  if(HasReturnInst == false) {
-    // 如果没有return语句，则默认返回0
-    if (returnType != Type::getVoidType()) {
-      Value* returnValue = ConstantValue::get(0);
-      if (returnType == Type::getFloatType()) {
-        returnValue = ConstantValue::get(0.0f);
-      }
-      builder.createReturnInst(returnValue);
-    } else {
+  // 如果函数没有显式的返回语句，且返回类型不是 void，则需要添加一个默认的返回值
+  ReturnInst* retinst = nullptr;
+  retinst = dynamic_cast<ReturnInst*>(builder.getBasicBlock()->terminator()->get());
+
+  if (!retinst) {
+    if (returnType->isVoid()) {
        builder.createReturnInst();
+    } else if (returnType->isInt()) {
+        builder.createReturnInst(ConstantInteger::get(0)); // 默认返回 0
+    } else if (returnType->isFloat()) {
+        builder.createReturnInst(ConstantFloating::get(0.0f)); // 默认返回 0.0f
+    } else {
+        assert(false && "Function with no explicit return and non-void type should return a value.");
    }
  }
+
  module->leaveScope();

  return std::any();
@ -277,28 +424,55 @@ std::any SysYIRGenerator::visitAssignStmt(SysYParser::AssignStmtContext *ctx) {
    dims.push_back(std::any_cast<Value *>(visitExp(exp)));
  }
  
-  auto variable = module->getVariable(name);
-  Value* value = std::any_cast<Value *>(visitExp(ctx->exp()));
-  Type* variableType = dynamic_cast<PointerType *>(variable->getType())->getBaseType();
+  auto variable = module->getVariable(name); // 获取 AllocaInst 或 GlobalValue
+  Value* value = std::any_cast<Value *>(visitExp(ctx->exp())); // 右值

-  // 左值右值类型不同处理
-  if (variableType != value->getType()) {
+  if (variable == nullptr) {
+      throw std::runtime_error("Variable " + name + " not found in assignment.");
+  }
+
+  // 计算最终赋值目标元素的类型
+  // variable 本身应该是一个指针类型 (例如 int* 或 int[2][3]*)
+  if (!variable->getType()->isPointer()) {
+      assert(false && "Variable to be assigned must be a pointer type!");
+      return std::any();
+  }
+  Type* targetElementType = variable->getType()->as<PointerType>()->getBaseType(); // 从基指针指向的类型开始
+
+  // 模拟 GEP 路径，根据 dims 确定最终元素的类型
+  for (size_t i = 0; i < dims.size(); ++i) {
+      if (targetElementType && targetElementType->isArray()) {
+          targetElementType = targetElementType->as<ArrayType>()->getElementType();
+      } else {
+          break; // 如果不是数组类型但还有索引，或者索引超出维度，则停止推断
+      }
+  }
+
+  // 左值右值类型不同处理：根据最终元素类型进行转换
+  if (targetElementType != value->getType()) {
    ConstantValue * constValue = dynamic_cast<ConstantValue *>(value);
    if (constValue != nullptr) {
-      if (variableType == Type::getFloatType()) {
-        value = ConstantValue::get(static_cast<float>(constValue->getInt()));
-      } else {
-        value = ConstantValue::get(static_cast<int>(constValue->getFloat()));
+      if (targetElementType == Type::getFloatType()) {
+        value = ConstantFloating::get(static_cast<float>(constValue->getInt()));
+      } else { // 假设如果不是浮点型，就是整型
+        value = ConstantInteger::get(static_cast<int>(constValue->getFloat()));
      }
    } else {
-      if (variableType == Type::getFloatType()) {
+      if (targetElementType == Type::getFloatType()) {
        value = builder.createIToFInst(value);
-      } else {
+      } else { // 假设如果不是浮点型，就是整型
        value = builder.createFtoIInst(value);
      }
    }
  }
-  builder.createStoreInst(value, variable, dims, variable->getName());
+
+  // 计算目标地址：如果 dims 为空，就是变量本身地址；否则通过 GEP 计算
+  Value* targetAddress = variable;
+  if (!dims.empty()) {
+    targetAddress = getGEPAddressInst(variable, dims);
+  }
+
+  builder.createStoreInst(value, targetAddress);

  return std::any();
 }
@ -386,6 +560,7 @@ std::any SysYIRGenerator::visitIfStmt(SysYParser::IfStmtContext *ctx) {
      ctx->stmt(0)->accept(this);
      module->leaveScope();
    }
+    builder.createUncondBrInst(exitBlock, {});
    BasicBlock::conectBlocks(builder.getBasicBlock(), exitBlock);

    labelstring << "if_exit.L" << builder.getLabelIndex();
@ -407,6 +582,7 @@ std::any SysYIRGenerator::visitWhileStmt(SysYParser::WhileStmtContext *ctx) {
  labelstring << "while_head.L" << builder.getLabelIndex();
  BasicBlock *headBlock = function->addBasicBlock(labelstring.str());
  labelstring.str("");
+  builder.createUncondBrInst(headBlock, {});
  BasicBlock::conectBlocks(curBlock, headBlock);
  builder.setPosition(headBlock, headBlock->end());

@ -478,9 +654,9 @@ std::any SysYIRGenerator::visitReturnStmt(SysYParser::ReturnStmtContext *ctx) {
      ConstantValue * constValue = dynamic_cast<ConstantValue *>(returnValue);
      if (constValue != nullptr) {
        if (funcType == Type::getFloatType()) {
-          returnValue = ConstantValue::get(static_cast<float>(constValue->getInt()));
+          returnValue = ConstantInteger::get(static_cast<float>(constValue->getInt()));
        } else {
-          returnValue = ConstantValue::get(static_cast<int>(constValue->getFloat()));
+          returnValue = ConstantFloating::get(static_cast<int>(constValue->getFloat()));
        }
      } else {
        if (funcType == Type::getFloatType()) {
@ -491,56 +667,94 @@ std::any SysYIRGenerator::visitReturnStmt(SysYParser::ReturnStmtContext *ctx) {
      }
    }
  builder.createReturnInst(returnValue);
-  HasReturnInst = true;
+
  return std::any();
 }


+// SysYIRGenerator.cpp (修改部分)
+
 std::any SysYIRGenerator::visitLValue(SysYParser::LValueContext *ctx) {
  std::string name = ctx->Ident()->getText();
  User* variable = module->getVariable(name);

  Value* value = nullptr;
+  if (variable == nullptr) {
+    throw std::runtime_error("Variable " + name + " not found.");
+  }
  std::vector<Value *> dims;
  for (const auto &exp : ctx->exp()) {
    dims.push_back(std::any_cast<Value *>(visitExp(exp)));
  }

-  if (variable == nullptr) {
-    throw std::runtime_error("Variable " + name + " not found.");
+  // 1. 获取变量的声明维度数量
+  unsigned declaredNumDims = 0;
+  if (AllocaInst* alloc = dynamic_cast<AllocaInst*>(variable)) {
+    declaredNumDims = alloc->getNumDims();
+  } else if (GlobalValue* glob = dynamic_cast<GlobalValue*>(variable)) {
+    declaredNumDims = glob->getNumDims();
+  } else if (ConstantVariable* constV = dynamic_cast<ConstantVariable*>(variable)) {
+    declaredNumDims = constV->getNumDims();
  }

-  bool indicesConstant = true;
+  // 2. 处理常量变量 (ConstantVariable) 且所有索引都是常量的情况
+  ConstantVariable* constVar = dynamic_cast<ConstantVariable *>(variable);
+  if (constVar != nullptr) {
+    bool allIndicesConstant = true;
    for (const auto &dim : dims) {
      if (dynamic_cast<ConstantValue *>(dim) == nullptr) {
-      indicesConstant = false;
+        allIndicesConstant = false;
        break;
      }
    }
-
-  ConstantVariable* constVar = dynamic_cast<ConstantVariable *>(variable);
-  GlobalValue* globalVar = dynamic_cast<GlobalValue *>(variable);
-  AllocaInst* localVar = dynamic_cast<AllocaInst *>(variable);
-  if (constVar != nullptr && indicesConstant) {
-    // 如果是常量变量，且索引是常量，则直接获取子数组
-    value = constVar->getByIndices(dims);
-  } else if (module->isInGlobalArea() && (globalVar != nullptr)) {
-    assert(indicesConstant);
-    value = globalVar->getByIndices(dims);
-  } else {
-    if ((globalVar != nullptr && globalVar->getNumDims() > dims.size()) ||
-        (localVar != nullptr && localVar->getNumDims() > dims.size()) ||
-        (constVar != nullptr && constVar->getNumDims() > dims.size())) {
-      // value = builder.createLaInst(variable, indices);
-      // 如果变量是全局变量或局部变量，且索引数量小于维度数量，则创建createGetSubArray获取子数组
-      auto getArrayInst =
-          builder.createGetSubArray(dynamic_cast<LVal *>(variable), dims);
-      value = getArrayInst->getChildArray();
-    } else {
-      value = builder.createLoadInst(variable, dims);
+    if (allIndicesConstant) {
+      // 如果是常量变量且所有索引都是常量，直接通过 getByIndices 获取编译时值
+      // 这个方法会根据索引深度返回最终的标量值或指向子数组的指针 (作为 ConstantValue/Variable)
+      return constVar->getByIndices(dims);
    }
  }

+  // 3. 处理可变变量 (AllocaInst/GlobalValue) 或带非常量索引的常量变量
+  // 这里区分标量访问和数组元素/子数组访问
+
+  // 检查是否是访问标量变量本身（没有索引，且声明维度为0）
+  if (dims.empty() && declaredNumDims == 0) {
+    // 对于标量变量，直接加载其值。
+    // variable 本身就是指向标量的指针 (e.g., int* %a)
+    if (dynamic_cast<AllocaInst*>(variable) || dynamic_cast<GlobalValue*>(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* targetAddress = nullptr;
+
+    // GEP 的基指针就是变量本身（它是一个指向内存的指针）
+    if (dynamic_cast<AllocaInst*>(variable) || dynamic_cast<GlobalValue*>(variable) || (constVar != nullptr)) {
+        // 允许对 ConstantVariable (如果它代表全局数组常量) 进行 GEP
+        targetAddress = getGEPAddressInst(variable, dims);
+    } else {
+        // 其他情况（例如尝试对非指针类型或不支持的 LValue 进行 GEP）应报错
+        assert(false && "LValue variable type not supported for GEP or dynamic load.");
+        return static_cast<Value*>(nullptr);
+    }
+
+    // 现在 targetAddress 持有元素或子数组的地址。
+    // 需要判断是加载值，还是返回子数组的地址。
+
+    // 如果提供的索引数量少于声明的维度数量，则表示访问的是子数组，返回其地址
+    if (dims.size() < declaredNumDims) {
+        value = targetAddress;
+    } else {
+        // 否则，表示访问的是最终的标量元素，加载其值
+        // 假设 createLoadInst 接受 Value* pointer
+        value = builder.createLoadInst(targetAddress);
+    }
+  }
  return value;
 }

@ -560,10 +774,10 @@ std::any SysYIRGenerator::visitPrimaryExp(SysYParser::PrimaryExpContext *ctx) {
 std::any SysYIRGenerator::visitNumber(SysYParser::NumberContext *ctx) {
  if (ctx->ILITERAL() != nullptr) {
    int value = std::stol(ctx->ILITERAL()->getText(), nullptr, 0);
-    return static_cast<Value *>(ConstantValue::get(value));
+    return static_cast<Value *>(ConstantInteger::get(value));
  } else if (ctx->FLITERAL() != nullptr) {
    float value = std::stof(ctx->FLITERAL()->getText());
-    return static_cast<Value *>(ConstantValue::get(value));
+    return static_cast<Value *>(ConstantFloating::get(value));
  }
  throw std::runtime_error("Unknown number type.");
  return std::any(); // 不会到达这里
@ -599,9 +813,9 @@ std::any SysYIRGenerator::visitCall(SysYParser::CallContext *ctx) {
        ConstantValue * constValue = dynamic_cast<ConstantValue *>(args[i]);
        if (constValue != nullptr) {
          if (params[i]->getType() == Type::getPointerType(Type::getFloatType())) {
-            args[i] = ConstantValue::get(static_cast<float>(constValue->getInt()));
+            args[i] = ConstantInteger::get(static_cast<float>(constValue->getInt()));
          } else {
-            args[i] = ConstantValue::get(static_cast<int>(constValue->getFloat()));
+            args[i] = ConstantFloating::get(static_cast<int>(constValue->getFloat()));
          }
        } else {
          if (params[i]->getType() == Type::getPointerType(Type::getFloatType())) {
@ -629,9 +843,9 @@ std::any SysYIRGenerator::visitUnaryExp(SysYParser::UnaryExpContext *ctx) {
    ConstantValue * constValue = dynamic_cast<ConstantValue *>(value);
    if (constValue != nullptr) {
      if (constValue->isFloat()) {
-        result = ConstantValue::get(-constValue->getFloat());
+        result = ConstantFloating::get(-constValue->getFloat());
      } else {
-        result = ConstantValue::get(-constValue->getInt());
+        result = ConstantInteger::get(-constValue->getInt());
      }
    } else if (value != nullptr) {
      if (value->getType() == Type::getIntType()) {
@ -648,9 +862,9 @@ std::any SysYIRGenerator::visitUnaryExp(SysYParser::UnaryExpContext *ctx) {
    if (constValue != nullptr) {
      if (constValue->isFloat()) {
        result =
-            ConstantValue::get(1 - (constValue->getFloat() != 0.0F ? 1 : 0));
+            ConstantFloating::get(1 - (constValue->getFloat() != 0.0F ? 1 : 0));
      } else {
-        result = ConstantValue::get(1 - (constValue->getInt() != 0 ? 1 : 0));
+        result = ConstantInteger::get(1 - (constValue->getInt() != 0 ? 1 : 0));
      }
    } else if (value != nullptr) {
      if (value->getType() == Type::getIntType()) {
@ -692,13 +906,13 @@ std::any SysYIRGenerator::visitMulExp(SysYParser::MulExpContext *ctx) {
      if (operandType != floatType) {
        ConstantValue * constValue = dynamic_cast<ConstantValue *>(operand);
        if (constValue != nullptr) 
-          operand = ConstantValue::get(static_cast<float>(constValue->getInt()));
+          operand = ConstantFloating::get(static_cast<float>(constValue->getInt()));
        else 
          operand = builder.createIToFInst(operand);
      } else if (resultType != floatType) {
        ConstantValue* constResult = dynamic_cast<ConstantValue *>(result);
        if (constResult != nullptr) 
-          result = ConstantValue::get(static_cast<float>(constResult->getInt()));
+          result = ConstantFloating::get(static_cast<float>(constResult->getInt()));
         else 
          result = builder.createIToFInst(result);
      }
@ -707,14 +921,14 @@ std::any SysYIRGenerator::visitMulExp(SysYParser::MulExpContext *ctx) {
      ConstantValue* constOperand = dynamic_cast<ConstantValue *>(operand);
      if (opType == SysYParser::MUL) {
        if ((constOperand != nullptr) && (constResult != nullptr)) {
-          result = ConstantValue::get(constResult->getFloat() *
+          result = ConstantFloating::get(constResult->getFloat() *
                                      constOperand->getFloat());
        } else {
          result = builder.createFMulInst(result, operand);
        }
      } else if (opType == SysYParser::DIV) {
        if ((constOperand != nullptr) && (constResult != nullptr)) {
-          result = ConstantValue::get(constResult->getFloat() /
+          result = ConstantFloating::get(constResult->getFloat() /
                                      constOperand->getFloat());
        } else {
          result = builder.createFDivInst(result, operand);
@ -729,17 +943,17 @@ std::any SysYIRGenerator::visitMulExp(SysYParser::MulExpContext *ctx) {
      ConstantValue * constOperand = dynamic_cast<ConstantValue *>(operand);
      if (opType == SysYParser::MUL) {
        if ((constOperand != nullptr) && (constResult != nullptr)) 
-          result = ConstantValue::get(constResult->getInt() * constOperand->getInt());
+          result = ConstantInteger::get(constResult->getInt() * constOperand->getInt());
        else 
          result = builder.createMulInst(result, operand);
      } else if (opType == SysYParser::DIV) {
        if ((constOperand != nullptr) && (constResult != nullptr)) 
-          result = ConstantValue::get(constResult->getInt() / constOperand->getInt());
+          result = ConstantInteger::get(constResult->getInt() / constOperand->getInt());
         else 
          result = builder.createDivInst(result, operand);
      } else {
        if ((constOperand != nullptr) && (constResult != nullptr)) 
-          result = ConstantValue::get(constResult->getInt() % constOperand->getInt());
+          result = ConstantInteger::get(constResult->getInt() % constOperand->getInt());
         else 
          result = builder.createRemInst(result, operand);
      }
@ -767,13 +981,13 @@ std::any SysYIRGenerator::visitAddExp(SysYParser::AddExpContext *ctx) {
      if (operandType != floatType) {
        ConstantValue * constOperand = dynamic_cast<ConstantValue *>(operand);
        if (constOperand != nullptr) 
-          operand = ConstantValue::get(static_cast<float>(constOperand->getInt()));
+          operand = ConstantFloating::get(static_cast<float>(constOperand->getInt()));
        else 
          operand = builder.createIToFInst(operand);
      } else if (resultType != floatType) {
        ConstantValue * constResult = dynamic_cast<ConstantValue *>(result);
        if (constResult != nullptr) 
-          result = ConstantValue::get(static_cast<float>(constResult->getInt()));
+          result = ConstantFloating::get(static_cast<float>(constResult->getInt()));
        else 
          result = builder.createIToFInst(result);
      }
@ -782,12 +996,12 @@ std::any SysYIRGenerator::visitAddExp(SysYParser::AddExpContext *ctx) {
      ConstantValue *  constOperand = dynamic_cast<ConstantValue *>(operand);
      if (opType == SysYParser::ADD) {
        if ((constResult != nullptr) && (constOperand != nullptr))
-          result = ConstantValue::get(constResult->getFloat() + constOperand->getFloat());
+          result = ConstantFloating::get(constResult->getFloat() + constOperand->getFloat());
        else 
          result = builder.createFAddInst(result, operand);
      } else {
        if ((constResult != nullptr) && (constOperand != nullptr)) 
-          result = ConstantValue::get(constResult->getFloat() - constOperand->getFloat());
+          result = ConstantFloating::get(constResult->getFloat() - constOperand->getFloat());
        else
          result = builder.createFSubInst(result, operand);
      }
@ -796,12 +1010,12 @@ std::any SysYIRGenerator::visitAddExp(SysYParser::AddExpContext *ctx) {
      ConstantValue *  constOperand = dynamic_cast<ConstantValue *>(operand);
      if (opType == SysYParser::ADD) {
        if ((constResult != nullptr) && (constOperand != nullptr))
-          result = ConstantValue::get(constResult->getInt() + constOperand->getInt());
+          result = ConstantInteger::get(constResult->getInt() + constOperand->getInt());
        else 
          result = builder.createAddInst(result, operand);
      } else {
        if ((constResult != nullptr) && (constOperand != nullptr))
-          result = ConstantValue::get(constResult->getInt() - constOperand->getInt());
+          result = ConstantInteger::get(constResult->getInt() - constOperand->getInt());
        else 
          result = builder.createSubInst(result, operand);
      }
@ -833,10 +1047,10 @@ std::any SysYIRGenerator::visitRelExp(SysYParser::RelExpContext *ctx) {
      auto operand2 = constOperand->isFloat() ? constOperand->getFloat()
                                              : constOperand->getInt();

-      if (opType == SysYParser::LT)      result = ConstantValue::get(operand1 < operand2 ? 1 : 0);
-      else if (opType == SysYParser::GT) result = ConstantValue::get(operand1 > operand2 ? 1 : 0);
-      else if (opType == SysYParser::LE) result = ConstantValue::get(operand1 <= operand2 ? 1 : 0);
-      else if (opType == SysYParser::GE) result = ConstantValue::get(operand1 >= operand2 ? 1 : 0);
+      if (opType == SysYParser::LT)      result = ConstantInteger::get(operand1 < operand2 ? 1 : 0);
+      else if (opType == SysYParser::GT) result = ConstantInteger::get(operand1 > operand2 ? 1 : 0);
+      else if (opType == SysYParser::LE) result = ConstantInteger::get(operand1 <= operand2 ? 1 : 0);
+      else if (opType == SysYParser::GE) result = ConstantInteger::get(operand1 >= operand2 ? 1 : 0);
      else                          assert(false);

    } else {
@ -848,14 +1062,14 @@ std::any SysYIRGenerator::visitRelExp(SysYParser::RelExpContext *ctx) {
      if (resultType == floatType || operandType == floatType) {
        if (resultType != floatType) {
          if (constResult != nullptr)
-            result = ConstantValue::get(static_cast<float>(constResult->getInt()));
+            result = ConstantFloating::get(static_cast<float>(constResult->getInt()));
          else 
            result = builder.createIToFInst(result);
          
        }
        if (operandType != floatType) {
          if (constOperand != nullptr) 
-            operand = ConstantValue::get(static_cast<float>(constOperand->getInt()));
+            operand = ConstantFloating::get(static_cast<float>(constOperand->getInt()));
          else 
            operand = builder.createIToFInst(operand);
          
@ -901,8 +1115,8 @@ std::any SysYIRGenerator::visitEqExp(SysYParser::EqExpContext *ctx) {
      auto operand2 = constOperand->isFloat() ? constOperand->getFloat()
                                              : constOperand->getInt();

-      if (opType == SysYParser::EQ)      result = ConstantValue::get(operand1 == operand2 ? 1 : 0);
-      else if (opType == SysYParser::NE) result = ConstantValue::get(operand1 != operand2 ? 1 : 0);
+      if (opType == SysYParser::EQ)      result = ConstantInteger::get(operand1 == operand2 ? 1 : 0);
+      else if (opType == SysYParser::NE) result = ConstantInteger::get(operand1 != operand2 ? 1 : 0);
      else                          assert(false);
      
    } else {
@ -913,13 +1127,13 @@ std::any SysYIRGenerator::visitEqExp(SysYParser::EqExpContext *ctx) {
      if (resultType == floatType || operandType == floatType) {
        if (resultType != floatType) {
          if (constResult != nullptr)
-            result = ConstantValue::get(static_cast<float>(constResult->getInt()));
+            result = ConstantFloating::get(static_cast<float>(constResult->getInt()));
          else 
            result = builder.createIToFInst(result);
        }
        if (operandType != floatType) {
          if (constOperand != nullptr) 
-            operand = ConstantValue::get(static_cast<float>(constOperand->getInt()));
+            operand = ConstantFloating::get(static_cast<float>(constOperand->getInt()));
          else
            operand = builder.createIToFInst(operand);
        }
@ -943,9 +1157,9 @@ std::any SysYIRGenerator::visitEqExp(SysYParser::EqExpContext *ctx) {
    // 如果只有一个关系表达式，则将结果转换为0或1
    if (constResult != nullptr) {
      if (constResult->isFloat()) 
-        result = ConstantValue::get(constResult->getFloat() != 0.0F ? 1 : 0);
+        result = ConstantInteger::get(constResult->getFloat() != 0.0F ? 1 : 0);
      else
-        result = ConstantValue::get(constResult->getInt() != 0 ? 1 : 0);
+        result = ConstantInteger::get(constResult->getInt() != 0 ? 1 : 0);
    }
  }

@ -1013,6 +1227,7 @@ void Utils::tree2Array(Type *type, ArrayValueTree *root,
                        ValueCounter &result, IRBuilder *builder) {
  Value* value = root->getValue();
  auto &children = root->getChildren();
+  // 类型转换
  if (value != nullptr) {
    if (type == value->getType()) {
      result.push_back(value);
@ -1020,14 +1235,14 @@ void Utils::tree2Array(Type *type, ArrayValueTree *root,
      if (type == Type::getFloatType()) {
        ConstantValue* constValue = dynamic_cast<ConstantValue *>(value);
        if (constValue != nullptr)
-          result.push_back(ConstantValue::get(static_cast<float>(constValue->getInt())));
+          result.push_back(ConstantFloating::get(static_cast<float>(constValue->getInt())));
        else 
          result.push_back(builder->createIToFInst(value));
        
      } else {
        ConstantValue* constValue = dynamic_cast<ConstantValue *>(value);
        if (constValue != nullptr)
-          result.push_back(ConstantValue::get(static_cast<int>(constValue->getFloat())));
+          result.push_back(ConstantInteger::get(static_cast<int>(constValue->getFloat())));
        else 
          result.push_back(builder->createFtoIInst(value));
        
@ -1061,9 +1276,9 @@ void Utils::tree2Array(Type *type, ArrayValueTree *root,
  int num = blockSize - afterSize + beforeSize;
  if (num > 0) {
    if (type == Type::getFloatType())
-      result.push_back(ConstantValue::get(0.0F), num);
+      result.push_back(ConstantFloating::get(0.0F), num);
    else 
-      result.push_back(ConstantValue::get(0), num);
+      result.push_back(ConstantInteger::get(0), num);
  }
 }

@ -1101,7 +1316,7 @@ void Utils::initExternalFunction(Module *pModule, IRBuilder *pBuilder) {
                                 funcName, pModule, pBuilder);
  paramTypes.push_back(Type::getIntType());
  paramNames.emplace_back("x");
-  paramDims.push_back(std::vector<Value *>{ConstantValue::get(-1)});
+  paramDims.push_back(std::vector<Value *>{ConstantInteger::get(-1)});
  funcName = "getarray";
  Utils::createExternalFunction(paramTypes, paramNames, paramDims, returnType,
                                 funcName, pModule, pBuilder);
@ -1117,7 +1332,7 @@ void Utils::initExternalFunction(Module *pModule, IRBuilder *pBuilder) {
  returnType = Type::getIntType();
  paramTypes.push_back(Type::getFloatType());
  paramNames.emplace_back("x");
-  paramDims.push_back(std::vector<Value *>{ConstantValue::get(-1)});
+  paramDims.push_back(std::vector<Value *>{ConstantInteger::get(-1)});
  funcName = "getfarray";
  Utils::createExternalFunction(paramTypes, paramNames, paramDims, returnType,
                                 funcName, pModule, pBuilder);
@ -1141,7 +1356,7 @@ void Utils::initExternalFunction(Module *pModule, IRBuilder *pBuilder) {
  paramTypes.push_back(Type::getIntType());
  paramDims.clear();
  paramDims.emplace_back();
-  paramDims.push_back(std::vector<Value *>{ConstantValue::get(-1)});
+  paramDims.push_back(std::vector<Value *>{ConstantInteger::get(-1)});
  paramNames.clear();
  paramNames.emplace_back("n");
  paramNames.emplace_back("a");
@ -1164,7 +1379,7 @@ void Utils::initExternalFunction(Module *pModule, IRBuilder *pBuilder) {
  paramTypes.push_back(Type::getFloatType());
  paramDims.clear();
  paramDims.emplace_back();
-  paramDims.push_back(std::vector<Value *>{ConstantValue::get(-1)});
+  paramDims.push_back(std::vector<Value *>{ConstantInteger::get(-1)});
  paramNames.clear();
  paramNames.emplace_back("n");
  paramNames.emplace_back("a");
--- a/src/SysYIROptPre.cpp
+++ b/src/SysYIROptPre.cpp
@ -1,484 +0,0 @@
-#include "SysYIROptPre.h"
-#include <cassert>
-#include <list>
-#include <map>
-#include <memory>
-#include <string>
-#include <iostream>
-#include "IR.h"
-#include "IRBuilder.h"
-
-namespace sysy {
-
-/**
- * use删除operand,以免扰乱后续分析
- * instr: 要删除的指令
- */
-void SysYOptPre::usedelete(Instruction *instr) {
-  for (auto &use : instr->getOperands()) {
-    Value* val = use->getValue();
-    // std::cout << delete << val->getName() << std::endl;
-    val->removeUse(use);
-  }
-}
-
-
-// 删除br后的无用指令
-void SysYOptPre::SysYDelInstAfterBr() {
-  auto &functions = pModule->getFunctions();
-  for (auto &function : functions) {
-    auto basicBlocks = function.second->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 (Branch) 
-          usedelete(iter->get());
-        else if ((*iter)->isTerminator()){
-          Branch = true;
-          Branchiter = iter;
-        }
-      }
-      if (Branchiter != instructions.end()) ++Branchiter;
-      while (Branchiter != instructions.end()) 
-        Branchiter = instructions.erase(Branchiter);
-      
-      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()) {
-          BasicBlock* branchBlock = dynamic_cast<BasicBlock *>(thelastinstinst->get()->getOperand(0));
-          basicBlock->addSuccessor(branchBlock);
-          branchBlock->addPredecessor(basicBlock.get());
-        } else if (thelastinstinst->get()->isConditional()) {
-          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());
-          elseBlock->addPredecessor(basicBlock.get());
-        }
-      }
-    }
-  }
-}
-
-
-void SysYOptPre::SysYBlockMerge() {
-  auto &functions = pModule->getFunctions(); //std::map<std::string, std::unique_ptr<Function>>
-  for (auto &function : functions) {
-    // auto basicBlocks = function.second->getBasicBlocks();
-    auto &func = function.second;
-    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];
-          auto nextarguments = nextBlock->getArguments();
-          // 删除br指令
-          if (block->getNumInstructions() != 0) {
-            auto thelastinstinst = block->end();
-            (--thelastinstinst);
-            if (thelastinstinst->get()->isUnconditional()) {
-              usedelete(thelastinstinst->get());
-              block->getInstructions().erase(thelastinstinst);
-            } else if (thelastinstinst->get()->isConditional()) {
-              // 如果是条件分支，判断条件是否相同，主要优化相同布尔表达式
-              if (thelastinstinst->get()->getOperand(1)->getName() == thelastinstinst->get()->getOperand(1)->getName()) {
-                usedelete(thelastinstinst->get());
-                block->getInstructions().erase(thelastinstinst);
-              }
-            }
-          }
-          // 将后继块的指令移动到当前块
-          // 并将后继块的父指针改为当前块
-          for (auto institer = nextBlock->begin(); institer != nextBlock->end();) {
-            institer->get()->setParent(block);
-            block->getInstructions().emplace_back(institer->release());
-            institer = nextBlock->getInstructions().erase(institer);   
-          }
-          // 合并参数
-          // TODO：是否需要去重?
-          for (auto &argm : nextarguments) {
-            argm->setParent(block);
-            block->insertArgument(argm);
-          }
-          // 更新前驱后继关系，类似树节点操作
-          block->removeSuccessor(nextBlock);
-          nextBlock->removePredecessor(block);
-          std::list<BasicBlock *> succshoulddel;
-          for (auto &succ : nextBlock->getSuccessors()) {
-            block->addSuccessor(succ);
-            succ->replacePredecessor(nextBlock, block);
-            succshoulddel.push_back(succ);
-          }
-          for (auto del : succshoulddel) {
-            nextBlock->removeSuccessor(del);
-          }
-
-          func->removeBasicBlock(nextBlock);
-
-        } else {
-          blockiter++;
-        }
-      } else {
-        blockiter++;
-      }
-    }
-  }
-}
-
-// 删除无前驱块，兼容SSA后的处理
-void SysYOptPre::SysYDelNoPreBLock() {
-  
-  auto &functions = pModule->getFunctions(); // std::map<std::string, std::unique_ptr<sysy::Function>>
-  for (auto &function : functions) {
-    auto &func = function.second;
-
-    for (auto &block : func->getBasicBlocks()) {
-      block->setreachableFalse();
-    }
-    // 对函数基本块做一个拓扑排序，排查不可达基本块
-    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);
-        }
-      }
-    }
-
-    // 删除不可达基本块指令
-    for (auto blockIter = func->getBasicBlocks().begin(); blockIter != func->getBasicBlocks().end();blockIter++) {
-      
-      if (!blockIter->get()->getreachable()) 
-        for (auto &iterInst : blockIter->get()->getInstructions()) 
-          usedelete(iterInst.get());
-    
-    }
-
-    
-    for (auto blockIter = func->getBasicBlocks().begin(); blockIter != func->getBasicBlocks().end();) {
-      if (!blockIter->get()->getreachable()) {
-        for (auto succblock : blockIter->get()->getSuccessors()) {
-          int indexphi = 1;
-          for (auto pred : succblock->getPredecessors()) {
-            if (pred == blockIter->get()) {
-              break;
-            }
-            indexphi++;
-          }
-          for (auto &phiinst : succblock->getInstructions()) {
-            if (phiinst->getKind() != Instruction::kPhi) {
-              break;
-            }
-            phiinst->removeOperand(indexphi);
-          }
-        }
-        // 删除不可达基本块，注意迭代器不可达问题
-        func->removeBasicBlock((blockIter++)->get());
-      } else {
-        blockIter++;
-      }
-    }
-  }
-}
-
-void SysYOptPre::SysYDelEmptyBlock() {
-  auto &functions = pModule->getFunctions();
-  for (auto &function : functions) {
-    // 收集不可达基本块
-    // 这里的不可达基本块是指没有实际指令的基本块
-    // 当一个基本块没有实际指令例如只有phi指令和一个uncondbr指令时，也会被视作不可达
-    auto basicBlocks = function.second->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)
-          EmptyBlocks[basicBlock.get()] = basicBlock->getSuccessors().front();
-      }
-      
-      
-    }
-    // 更新基本块信息，增加必要指令
-    for (auto &basicBlock : basicBlocks) {
-      // 把空块转换成只有跳转指令的不可达块
-      if (distance(basicBlock->begin(), basicBlock->end()) == 0) {
-        if (basicBlock->getNumSuccessors() == 0) {
-          continue;
-        }
-        if (basicBlock->getNumSuccessors() > 1) {
-          assert("");
-        }
-        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.find(dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0))) !=
-               EmptyBlocks.end()) {
-          thelastBlockOld = dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0));
-          thelastinst->get()->replaceOperand(0, EmptyBlocks[thelastBlockOld]);
-        }
-
-        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());
-
-        if (thelastBlockOld != nullptr) {
-          int indexphi = 0;
-          for (auto &pred : dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0))->getPredecessors()) {
-            if (pred == thelastBlockOld) {
-              break;
-            }
-            indexphi++;
-          }
-
-          // 更新phi指令的操作数
-          // 移除thelastBlockOld对应的phi操作数
-          for (auto &InstInNew : dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0))->getInstructions()) {
-            if (InstInNew->isPhi()) {
-              dynamic_cast<PhiInst *>(InstInNew.get())->removeOperand(indexphi + 1);
-            } 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));
-
-        BasicBlock *thelastBlockOld = nullptr;
-        while (EmptyBlocks.find(dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1))) !=
-               EmptyBlocks.end()) {
-          thelastBlockOld = dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1));
-          thelastinst->get()->replaceOperand(
-              1, EmptyBlocks[dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1))]);
-        }
-        basicBlock->removeSuccessor(OldThenBlock);
-        OldThenBlock->removePredecessor(basicBlock.get());
-        // 处理 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));
-          usedelete(thelastinst->get());
-          thelastinst = basicBlock->getInstructions().erase(thelastinst);
-          pBuilder->setPosition(basicBlock.get(), basicBlock->end());
-          pBuilder->createUncondBrInst(thebrBlock, {});
-          continue;
-        }
-        basicBlock->addSuccessor(dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1)));
-        dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1))->addPredecessor(basicBlock.get());
-        // auto indexInNew = dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0))->getPredecessors().
-
-        if (thelastBlockOld != nullptr) {
-          int indexphi = 0;
-          for (auto &pred : dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1))->getPredecessors()) {
-            if (pred == thelastBlockOld) {
-              break;
-            }
-            indexphi++;
-          }
-
-          for (auto &InstInNew : dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1))->getInstructions()) {
-            if (InstInNew->isPhi()) {
-              dynamic_cast<PhiInst *>(InstInNew.get())->removeOperand(indexphi + 1);
-            } else {
-              break;
-            }
-          }
-        }
-
-        thelastBlockOld = nullptr;
-        while (EmptyBlocks.find(dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2))) !=
-               EmptyBlocks.end()) {
-          thelastBlockOld = dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2));
-          thelastinst->get()->replaceOperand(
-              2, EmptyBlocks[dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2))]);
-        }
-        basicBlock->removeSuccessor(OldElseBlock);
-        OldElseBlock->removePredecessor(basicBlock.get());
-        // 处理 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));
-          usedelete(thelastinst->get());
-          thelastinst = basicBlock->getInstructions().erase(thelastinst);
-          pBuilder->setPosition(basicBlock.get(), basicBlock->end());
-          pBuilder->createUncondBrInst(thebrBlock, {});
-          continue;
-        }
-        basicBlock->addSuccessor(dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2)));
-        dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2))->addPredecessor(basicBlock.get());
-
-        if (thelastBlockOld != nullptr) {
-          int indexphi = 0;
-          for (auto &pred : dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2))->getPredecessors()) {
-            if (pred == thelastBlockOld) {
-              break;
-            }
-            indexphi++;
-          }
-          for (auto &InstInNew : dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2))->getInstructions()) {
-            if (InstInNew->isPhi()) {
-              dynamic_cast<PhiInst *>(InstInNew.get())->removeOperand(indexphi + 1);
-            } else {
-              break;
-            }
-          }
-        }
-      } else {
-        if (basicBlock->getNumSuccessors() == 1) {
-          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());
-          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 = function.second->getBasicBlocks().begin(); iter != function.second->getBasicBlocks().end();) {
-      
-      if (EmptyBlocks.find(iter->get()) != EmptyBlocks.end()) {
-        // EntryBlock跳过
-        if (iter->get() == function.second->getEntryBlock()) {
-          ++iter;
-          continue;
-        }
-
-        for (auto &iterInst : iter->get()->getInstructions()) 
-          usedelete(iterInst.get());
-        // 删除不可达基本块的phi指令的操作数
-        for (auto &succ : iter->get()->getSuccessors()) {
-          int index = 0;
-          for (auto &pred : succ->getPredecessors()) {
-            if (pred == iter->get()) {
-              break;
-            }
-            index++;
-          }
-
-          for (auto &instinsucc : succ->getInstructions()) {
-            if (instinsucc->isPhi()) {
-              dynamic_cast<PhiInst *>(instinsucc.get())->removeOperand(index);
-            } else {
-              break;
-            }
-          }
-        }
-
-        function.second->removeBasicBlock((iter++)->get());
-      } else {
-        ++iter;
-      }
-    }
-  }
-}
-
-// 如果函数没有返回指令，则添加一个默认返回指令(主要解决void函数没有返回指令的问题)
-void SysYOptPre::SysYAddReturn() {
-  auto &functions = pModule->getFunctions();
-  for (auto &function : functions) {
-    auto &func = function.second;
-    auto basicBlocks = func->getBasicBlocks();
-    for (auto &block : basicBlocks) {
-      if (block->getNumSuccessors() == 0) {
-        // 如果基本块没有后继块，则添加一个返回指令
-        if (block->getNumInstructions() == 0) {
-          pBuilder->setPosition(block.get(), block->end());
-          pBuilder->createReturnInst();
-        }
-        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;
-
-          pBuilder->setPosition(block.get(), block->end());
-          // TODO: 如果int float函数缺少返回值是否需要报错
-          if (func->getReturnType()->isInt()) {
-            pBuilder->createReturnInst(ConstantValue::get(0));
-          } else if (func->getReturnType()->isFloat()) {
-            pBuilder->createReturnInst(ConstantValue::get(0.0F));
-          } else {
-            pBuilder->createReturnInst();
-          }
-        }
-      }
-    }
-  }
-}
-
-}  // namespace sysy
--- a/src/SysYIRPassManager.cpp
+++ b/src/SysYIRPassManager.cpp
@ -0,0 +1,36 @@
+// PassManager.cpp
+#include "SysYIRPassManager.h"
+#include <iostream>
+
+namespace sysy {
+
+void PassManager::run(Module& M) {
+  // 首先运行Module级别的Pass
+  for (auto& pass : modulePasses) {
+    std::cout << "Running Module Pass: " << pass->getPassName() << std::endl;
+    pass->runOnModule(M);
+  }
+
+  // 然后对每个函数运行Function级别的Pass
+  auto& functions = M.getFunctions();
+  for (auto& pair : functions) {
+    Function& F = *(pair.second); // 获取Function的引用
+    std::cout << "  Processing Function: " << F.getName() << std::endl;
+
+    // 在每个函数上运行FunctionPasses
+    bool changedInFunction;
+    do {
+      changedInFunction = false;
+      for (auto& pass : functionPasses) {
+        // 对于FunctionPasses，可以考虑一个迭代执行的循环，直到稳定
+        std::cout << "    Running Function Pass: " << pass->getPassName() << std::endl;
+        changedInFunction |= pass->runOnFunction(F);
+      }
+    } while (changedInFunction); // 循环直到函数稳定，这模拟了您SysYCFGOpt的while(changed)逻辑
+  }
+
+  // 分析Pass的运行可以在其他Pass需要时触发，或者在特定的PassManager阶段触发
+  // 对于依赖于分析结果的Pass，可以在其run方法中通过PassManager::getAnalysis()来获取
+}
+
+} // namespace sysy
--- a/src/SysYIRPrinter.cpp
+++ b/src/SysYIRPrinter.cpp
@ -3,12 +3,11 @@
 #include <fstream>
 #include <iostream>
 #include <string>
-#include "IR.h"
+#include "IR.h" // 确保IR.h包含了ArrayType、GetElementPtrInst等的定义

 namespace sysy {

 void SysYPrinter::printIR() {
-
  const auto &functions = pModule->getFunctions();

  //TODO: Print target datalayout and triple (minimal required by LLVM)
@ -36,11 +35,18 @@ std::string SysYPrinter::getTypeString(Type *type) {
    return "i32";
  } else if (type->isFloat()) {
    return "float";
-    
  } else if (auto ptrType = dynamic_cast<PointerType*>(type)) {
+    // 递归打印指针指向的类型，然后加上 '*'
    return getTypeString(ptrType->getBaseType()) + "*";
-  } else if (auto ptrType = dynamic_cast<FunctionType*>(type)) {
-    return getTypeString(ptrType->getReturnType());
+  } else if (auto funcType = dynamic_cast<FunctionType*>(type)) {
+    // 对于函数类型，打印其返回类型
+    // 注意：这里可能需要更完整的函数签名打印，取决于你的IR表示方式
+    // 比如：`retType (paramType1, paramType2, ...)`
+    // 但为了简化和LLVM IR兼容性，通常在定义时完整打印
+    return getTypeString(funcType->getReturnType());
+  } else if (auto arrayType = dynamic_cast<ArrayType*>(type)) { // 新增：处理数组类型
+    // 打印格式为 [num_elements x element_type]
+    return "[" + std::to_string(arrayType->getNumElements()) + " x " + getTypeString(arrayType->getElementType()) + "]";
  }
  assert(false && "Unsupported type");
  return "";
@ -51,15 +57,23 @@ std::string SysYPrinter::getValueName(Value *value) {
    return "@" + global->getName();
  } else if (auto inst = dynamic_cast<Instruction*>(value)) {
    return "%" + inst->getName();
-  } else if (auto constVal = dynamic_cast<ConstantValue*>(value)) {
-    if (constVal->isFloat()) {
+  } else if (auto constInt = dynamic_cast<ConstantInteger*>(value)) { // 优先匹配具体的常量类型
+    return std::to_string(constInt->getInt());
+  } else if (auto constFloat = dynamic_cast<ConstantFloating*>(value)) { // 优先匹配具体的常量类型
+    return std::to_string(constFloat->getFloat());
+  } else if (auto constUndef = dynamic_cast<UndefinedValue*>(value)) { // 如果有Undef类型
+    return "undef";
+  } else if (auto constVal = dynamic_cast<ConstantValue*>(value)) { // fallback for generic ConstantValue
+    // 这里的逻辑可能需要根据你ConstantValue的实际设计调整
+    // 确保它能处理所有可能的ConstantValue
+    if (constVal->getType()->isFloat()) {
        return std::to_string(constVal->getFloat());
    }
    return std::to_string(constVal->getInt());
  } else if (auto constVar = dynamic_cast<ConstantVariable*>(value)) {
-    return constVar->getName();
+    return constVar->getName(); // 假设ConstantVariable有自己的名字或通过getByIndices获取值
  }
-  assert(false && "Unknown value type");
+  assert(false && "Unknown value type or unable to get value name");
  return "";
 }

@ -77,44 +91,35 @@ void SysYPrinter::printGlobalVariable() {
  for (const auto &global : globals) {
    std::cout << "@" << global->getName() << " = global ";
    
-    auto baseType = dynamic_cast<PointerType *>(global->getType())->getBaseType();
-    printType(baseType);
-    
-    if (global->getNumDims() > 0) {
-      // Array type
-      std::cout << " [";
-      for (unsigned i = 0; i < global->getNumDims(); i++) {
-        if (i > 0) std::cout << " x ";
-        std::cout << getValueName(global->getDim(i));
-      }
-      std::cout << "]";
-    }
+    // 全局变量的类型是一个指针，指向其基类型 (可能是 ArrayType 或 Integer/FloatType)
+    auto globalVarBaseType = dynamic_cast<PointerType *>(global->getType())->getBaseType();
+    printType(globalVarBaseType); // 打印全局变量的实际类型 (例如 i32 或 [10 x i32])
    
    std::cout << " ";
    
-    if (global->getNumDims() > 0) {
-      // Array initializer
-      std::cout << "[";
-      auto values = global->getInitValues();
-      auto counterValues = values.getValues();
-      auto counterNumbers = values.getNumbers();
+    // 检查是否是数组类型 (通过检查 globalVarBaseType 是否是 ArrayType)
+    if (globalVarBaseType->isArray()) {
+      // 数组初始化器
+      std::cout << "["; // LLVM IR 数组初始化器格式: [type value, type value, ...]
+      auto values = global->getInitValues(); // 假设 getInitValues() 返回一个 ValueCounter
+      const std::vector<sysy::Value *> &counterValues = values.getValues(); // 获取所有值
      
-      for (size_t i = 0; i < counterNumbers.size(); i++) {
+      for (size_t i = 0; i < counterValues.size(); i++) {
        if (i > 0) std::cout << ", ";
-        if (baseType->isFloat()) {
-          std::cout << "float " << dynamic_cast<ConstantValue*>(counterValues[i])->getFloat();
-        } else {
-          std::cout << "i32 " << dynamic_cast<ConstantValue*>(counterValues[i])->getInt();
-        }
+        // 打印元素类型，这个元素类型应该是数组的最终元素类型，例如 i32 或 float
+        // 可以从 globalVarBaseType 逐层剥离得到最终元素类型，但这里简化为直接从值获取
+        printType(counterValues[i]->getType());
+        std::cout << " ";
+        printValue(counterValues[i]);
      }
      std::cout << "]";
    } else {
-      // Scalar initializer
-      if (baseType->isFloat()) {
-        std::cout << "float " << dynamic_cast<ConstantValue*>(global->getByIndex(0))->getFloat();
-      } else {
-        std::cout << "i32 " << dynamic_cast<ConstantValue*>(global->getByIndex(0))->getInt();
-      }
+      // 标量初始化器
+      // 假设标量全局变量的初始化值通过 getByIndex(0) 获取
+      Value* initVal = global->getByIndex(0);
+      printType(initVal->getType()); // 打印标量值的类型
+      std::cout << " ";
+      printValue(initVal); // 打印标量值
    }
    
    std::cout << ", align 4" << std::endl;
@ -209,19 +214,19 @@ void SysYPrinter::printInst(Instruction *pInst) {
        case Kind::kFDiv: std::cout << "fdiv"; break;
        case Kind::kICmpEQ: std::cout << "icmp eq"; break;
        case Kind::kICmpNE: std::cout << "icmp ne"; break;
-        case Kind::kICmpLT: std::cout << "icmp slt"; break;
+        case Kind::kICmpLT: std::cout << "icmp slt"; break; // LLVM uses slt/sgt for signed less/greater than
        case Kind::kICmpGT: std::cout << "icmp sgt"; break;
        case Kind::kICmpLE: std::cout << "icmp sle"; break;
        case Kind::kICmpGE: std::cout << "icmp sge"; break;
-        case Kind::kFCmpEQ: std::cout << "fcmp oeq"; break;
-        case Kind::kFCmpNE: std::cout << "fcmp one"; break;
-        case Kind::kFCmpLT: std::cout << "fcmp olt"; break;
-        case Kind::kFCmpGT: std::cout << "fcmp ogt"; break;
-        case Kind::kFCmpLE: std::cout << "fcmp ole"; break;
-        case Kind::kFCmpGE: std::cout << "fcmp oge"; break;
+        case Kind::kFCmpEQ: std::cout << "fcmp oeq"; break; // oeq for ordered equal
+        case Kind::kFCmpNE: std::cout << "fcmp one"; break; // one for ordered not equal
+        case Kind::kFCmpLT: std::cout << "fcmp olt"; break; // olt for ordered less than
+        case Kind::kFCmpGT: std::cout << "fcmp ogt"; break; // ogt for ordered greater than
+        case Kind::kFCmpLE: std::cout << "fcmp ole"; break; // ole for ordered less than or equal
+        case Kind::kFCmpGE: std::cout << "fcmp oge"; break; // oge for ordered greater than or equal
        case Kind::kAnd: std::cout << "and"; break;
        case Kind::kOr: std::cout << "or"; break;
-        default: break;
+        default: break; // Should not reach here
      }
      
      // Types and operands
@ -238,7 +243,6 @@ void SysYPrinter::printInst(Instruction *pInst) {
    case Kind::kNeg:
    case Kind::kNot:
    case Kind::kFNeg:
-    case Kind::kFNot:
    case Kind::kFtoI:
    case Kind::kBitFtoI:
    case Kind::kItoF:
@ -250,31 +254,39 @@ void SysYPrinter::printInst(Instruction *pInst) {
      }
      
      switch (pInst->getKind()) {
-        case Kind::kNeg: std::cout << "sub "; break;
-        case Kind::kNot: std::cout << "not "; break;
-        case Kind::kFNeg: std::cout << "fneg "; break;
-        case Kind::kFNot: std::cout << "fneg "; break; // FNot not standard, map to fneg
-        case Kind::kFtoI: std::cout << "fptosi "; break;
-        case Kind::kBitFtoI: std::cout << "bitcast "; break;
-        case Kind::kItoF: std::cout << "sitofp "; break;
-        case Kind::kBitItoF: std::cout << "bitcast "; break;
-        default: break;
+        case Kind::kNeg: std::cout << "sub "; break; // integer negation is `sub i32 0, operand`
+        case Kind::kNot: std::cout << "xor "; break; // logical/bitwise NOT is `xor i32 -1, operand` or `xor i1 true, operand`
+        case Kind::kFNeg: std::cout << "fneg "; break; // float negation
+        case Kind::kFtoI: std::cout << "fptosi "; break; // float to signed integer
+        case Kind::kBitFtoI: std::cout << "bitcast "; break; // bitcast float to int
+        case Kind::kItoF: std::cout << "sitofp "; break; // signed integer to float
+        case Kind::kBitItoF: std::cout << "bitcast "; break; // bitcast int to float
+        default: break; // Should not reach here
      }
      
-      printType(unyInst->getType());
+      printType(unyInst->getOperand()->getType()); // Print operand type
      std::cout << " ";
      
-      // Special handling for negation
-      if (pInst->getKind() == Kind::kNeg || pInst->getKind() == Kind::kNot) {
-        std::cout << "i32 0, ";
+      // Special handling for integer negation and logical NOT
+      if (pInst->getKind() == Kind::kNeg) {
+        std::cout << "0, "; // for 'sub i32 0, operand'
+      } else if (pInst->getKind() == Kind::kNot) {
+        // For logical NOT (i1 -> i1), use 'xor i1 true, operand'
+        // For bitwise NOT (i32 -> i32), use 'xor i32 -1, operand'
+        if (unyInst->getOperand()->getType()->isInt()) { // Assuming i32 for bitwise NOT
+            std::cout << "NOT, "; // or specific bitmask for NOT
+        } else { // Assuming i1 for logical NOT
+            std::cout << "true, ";
+        }
      }
      
      printValue(pInst->getOperand(0));
      
-      // For bitcast, need to specify destination type
-      if (pInst->getKind() == Kind::kBitFtoI || pInst->getKind() == Kind::kBitItoF) {
+      // For type conversions (fptosi, sitofp, bitcast), need to specify destination type
+      if (pInst->getKind() == Kind::kFtoI || pInst->getKind() == Kind::kItoF ||
+          pInst->getKind() == Kind::kBitFtoI || pInst->getKind() == Kind::kBitItoF) {
        std::cout << " to ";
-        printType(unyInst->getType());
+        printType(unyInst->getType()); // Print result type
      }
      
      std::cout << std::endl;
@ -289,7 +301,7 @@ void SysYPrinter::printInst(Instruction *pInst) {
      }
      
      std::cout << "call ";
-      printType(callInst->getType());
+      printType(callInst->getType()); // Return type of the call
      std::cout << " @" << function->getName() << "(";
      
      auto params = callInst->getArguments();
@ -297,9 +309,9 @@ void SysYPrinter::printInst(Instruction *pInst) {
      for (auto &param : params) {
        if (!first) std::cout << ", ";
        first = false;
-        printType(param->getValue()->getType());
+        printType(param->getValue()->getType()); // Type of argument
        std::cout << " ";
-        printValue(param->getValue());
+        printValue(param->getValue()); // Value of argument
      }
      
      std::cout << ")" << std::endl;
@ -307,7 +319,7 @@ void SysYPrinter::printInst(Instruction *pInst) {
    
    case Kind::kCondBr: {
      auto condBrInst = dynamic_cast<CondBrInst *>(pInst);
-      std::cout << "br i1 ";
+      std::cout << "br i1 "; // Condition type should be i1
      printValue(condBrInst->getCondition());
      std::cout << ", label %" << condBrInst->getThenBlock()->getName();
      std::cout << ", label %" << condBrInst->getElseBlock()->getName();
@ -337,14 +349,17 @@ void SysYPrinter::printInst(Instruction *pInst) {
      auto allocaInst = dynamic_cast<AllocaInst *>(pInst);
      std::cout << "%" << allocaInst->getName() << " = alloca ";
      
-      auto baseType = dynamic_cast<PointerType *>(allocaInst->getType())->getBaseType();
-      printType(baseType);
+      // AllocaInst 的类型现在应该是一个 PointerType，指向正确的 ArrayType 或 ScalarType
+      // 例如：alloca i32, align 4  或者 alloca [10 x i32], align 4
+      auto allocatedType = dynamic_cast<PointerType *>(allocaInst->getType())->getBaseType();
+      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());
+          printType(Type::getIntType()); // 维度大小通常是 i32 类型
          std::cout << " ";
          printValue(allocaInst->getDim(i));
        }
@ -356,17 +371,18 @@ void SysYPrinter::printInst(Instruction *pInst) {
    case Kind::kLoad: {
      auto loadInst = dynamic_cast<LoadInst *>(pInst);
      std::cout << "%" << loadInst->getName() << " = load ";
-      printType(loadInst->getType());
+      printType(loadInst->getType()); // 加载的结果类型
      std::cout << ", ";
-      printType(loadInst->getPointer()->getType());
+      printType(loadInst->getPointer()->getType()); // 指针类型
      std::cout << " ";
-      printValue(loadInst->getPointer());
+      printValue(loadInst->getPointer()); // 要加载的地址
      
+      // 仍然打印索引信息，如果存在的话
      if (loadInst->getNumIndices() > 0) {
-        std::cout << ", ";
+        std::cout << ", indices "; // 或者其他分隔符，取决于你期望的格式
        for (size_t i = 0; i < loadInst->getNumIndices(); i++) {
            if (i > 0) std::cout << ", ";
-          printType(Type::getIntType());
+            printType(loadInst->getIndex(i)->getType());
            std::cout << " ";
            printValue(loadInst->getIndex(i));
        }
@ -375,44 +391,23 @@ void SysYPrinter::printInst(Instruction *pInst) {
      std::cout << ", align 4" << std::endl;
    } break;
    
-    case Kind::kLa: {
-      auto laInst = dynamic_cast<LaInst *>(pInst);
-      std::cout << "%" << laInst->getName() << " = getelementptr inbounds ";
-      
-      auto ptrType = dynamic_cast<PointerType*>(laInst->getPointer()->getType());
-      printType(ptrType->getBaseType());
-      std::cout << ", ";
-      printType(laInst->getPointer()->getType());
-      std::cout << " ";
-      printValue(laInst->getPointer());
-      std::cout << ", ";
-      
-      for (size_t i = 0; i < laInst->getNumIndices(); i++) {
-        if (i > 0) std::cout << ", ";
-        printType(Type::getIntType());
-        std::cout << " ";
-        printValue(laInst->getIndex(i));
-      }
-      
-      std::cout << std::endl;
-    } break;
-    
    case Kind::kStore: {
      auto storeInst = dynamic_cast<StoreInst *>(pInst);
      std::cout << "store ";
-      printType(storeInst->getValue()->getType());
+      printType(storeInst->getValue()->getType()); // 要存储的值的类型
      std::cout << " ";
-      printValue(storeInst->getValue());
+      printValue(storeInst->getValue()); // 要存储的值
      std::cout << ", ";
-      printType(storeInst->getPointer()->getType());
+      printType(storeInst->getPointer()->getType()); // 目标指针的类型
      std::cout << " ";
-      printValue(storeInst->getPointer());
+      printValue(storeInst->getPointer()); // 目标地址
      
+      // 仍然打印索引信息，如果存在的话
      if (storeInst->getNumIndices() > 0) {
-        std::cout << ", ";
+        std::cout << ", indices "; // 或者其他分隔符
        for (size_t i = 0; i < storeInst->getNumIndices(); i++) {
            if (i > 0) std::cout << ", ";
-          printType(Type::getIntType());
+            printType(storeInst->getIndex(i)->getType());
            std::cout << " ";
            printValue(storeInst->getIndex(i));
        }
@ -421,6 +416,30 @@ void SysYPrinter::printInst(Instruction *pInst) {
      std::cout << ", align 4" << std::endl;
    } break;

+    case Kind::kGetElementPtr: { // 新增：GetElementPtrInst 打印
+      auto gepInst = dynamic_cast<GetElementPtrInst*>(pInst);
+      std::cout << "%" << gepInst->getName() << " = getelementptr inbounds "; // 假设总是 inbounds
+      
+      // GEP 的第一个操作数是基指针，其类型是一个指向聚合类型的指针
+      // 第一个参数是基指针所指向的聚合类型的类型 (e.g., [10 x i32])
+      auto basePtrType = dynamic_cast<PointerType*>(gepInst->getBasePointer()->getType());
+      printType(basePtrType->getBaseType()); // 打印基指针指向的类型
+      
+      std::cout << ", ";
+      printType(gepInst->getBasePointer()->getType()); // 打印基指针自身的类型 (e.g., [10 x i32]*)
+      std::cout << " ";
+      printValue(gepInst->getBasePointer()); // 打印基指针
+      
+      // 打印所有索引
+      for (auto indexVal : gepInst->getIndices()) { // 使用 getIndices() 迭代器
+        std::cout << ", ";
+        printType(indexVal->getValue()->getType()); // 打印索引的类型 (通常是 i32)
+        std::cout << " ";
+        printValue(indexVal->getValue()); // 打印索引值
+      }
+      std::cout << std::endl;
+    } break;
+    
    case Kind::kMemset: {
      auto memsetInst = dynamic_cast<MemsetInst *>(pInst);
      std::cout << "call void @llvm.memset.p0.";
@ -433,49 +452,38 @@ void SysYPrinter::printInst(Instruction *pInst) {
      printValue(memsetInst->getValue());
      std::cout << ", i32 ";
      printValue(memsetInst->getSize());
-      std::cout << ", i1 false)" << std::endl;
+      std::cout << ", i1 false)" << std::endl; // alignment for memset is typically i1
    } break;
    
    case Kind::kPhi: {
      auto phiInst = dynamic_cast<PhiInst *>(pInst);
-      printValue(phiInst->getOperand(0));
-      std::cout << " = phi ";
-      printType(phiInst->getType());
+      // Phi 指令的名称通常是结果变量
+      std::cout << "%" << phiInst->getName() << " = phi ";
+      printType(phiInst->getType()); // Phi 结果类型
      
-      for (unsigned i = 1; i < phiInst->getNumOperands(); i++) {
-        if (i > 0) std::cout << ", ";
+      // Phi 指令的操作数是成对的 [value, basic_block]
+      // 这里假设 getOperands() 返回的是 (val1, block1, val2, block2...)
+      // 如果你的 PhiInst 存储方式是 getIncomingValues() 和 getIncomingBlocks()，请相应调整
+      // LLVM IR 格式: phi type [value1, block1], [value2, block2]
+      bool firstPair = true;
+      for (unsigned i = 0; i < phiInst->getNumOperands() / 2; ++i) { // 遍历成对的操作数
+        if (!firstPair) std::cout << ", ";
+        firstPair = false;
        std::cout << "[ ";
-        printValue(phiInst->getOperand(i));
+        printValue(phiInst->getOperand(i * 2)); // value
+        std::cout << ", %";
+        printValue(phiInst->getOperand(i * 2 + 1)); // block
        std::cout << " ]";
      }
      std::cout << std::endl;
    } break;
    
-    case Kind::kGetSubArray: {
-      auto getSubArrayInst = dynamic_cast<GetSubArrayInst *>(pInst);
-      std::cout << "%" << getSubArrayInst->getName() << " = getelementptr inbounds ";
-      
-      auto ptrType = dynamic_cast<PointerType*>(getSubArrayInst->getFatherArray()->getType());
-      printType(ptrType->getBaseType());
-      std::cout << ", ";
-      printType(getSubArrayInst->getFatherArray()->getType());
-      std::cout << " ";
-      printValue(getSubArrayInst->getFatherArray());
-      std::cout << ", ";
-      bool firstIndex = true;
-      for (auto &index : getSubArrayInst->getIndices()) {
-        if (!firstIndex) std::cout << ", ";
-        firstIndex = false;
-        printType(Type::getIntType());
-        std::cout << " ";
-        printValue(index->getValue());
-      }
-      
-      std::cout << std::endl;
-    } break;
+    // 以下两个 Kind 应该删除或替换为 kGEP
+    // case Kind::kLa: { /* REMOVED */ } break;
+    // case Kind::kGetSubArray: { /* REMOVED */ } break;
    
    default:
-      assert(false && "Unsupported instruction kind");
+      assert(false && "Unsupported instruction kind in SysYPrinter");
      break;
  }
 }
--- a/src/include/DeadCodeElimination.h
+++ b/src/include/DeadCodeElimination.h
@ -3,6 +3,7 @@
 #include "IR.h"
 #include "SysYIRAnalyser.h"
 #include "SysYIRPrinter.h"
+#include "SysYIROptUtils.h"

 namespace sysy {

@ -31,9 +32,5 @@ class DeadCodeElimination {
  void eliminateDeadGlobals(bool& changed);   // 消除无用全局变量
  void eliminateDeadIndirectiveAllocas(Function* func, bool& changed);  // 消除无用间接内存分配(phi节点)
  void eliminateDeadRedundantLoadStore(Function* func, bool& changed);  // 消除冗余加载和存储
-  bool isGlobal(Value *val);
-  bool isArr(Value *val);
-  void usedelete(Instruction *instr);
-
 };
 }  // namespace sysy
--- a/src/include/IR.h
+++ b/src/include/IR.h
@ -49,6 +49,7 @@ class Type {
    kLabel,
    kPointer,
    kFunction,
+    kArray,
  };

  Kind kind;  ///< 表示具体类型的变量
@ -65,6 +66,7 @@ class Type {
  static Type* getPointerType(Type *baseType);  ///< 返回表示指向baseType类型的Pointer类型的Type指针
  static Type* getFunctionType(Type *returnType, const std::vector<Type *> &paramTypes = {});
  ///< 返回表示返回类型为returnType,形参类型列表为paramTypes的函数类型的Type指针
+  static Type* getArrayType(Type *elementType, unsigned numElements);

 public:
  Kind getKind() const { return kind; }                  ///< 返回Type对象代表原始标量类型
@ -74,6 +76,7 @@ class Type {
  bool isLabel() const { return kind == kLabel; }        ///< 判定是否为Label类型
  bool isPointer() const { return kind == kPointer; }    ///< 判定是否为Pointer类型
  bool isFunction() const { return kind == kFunction; }  ///< 判定是否为Function类型
+  bool isArray() const { return kind == Kind::kArray; }
  unsigned getSize() const;                              ///< 返回类型所占的空间大小(字节)
  /// 尝试将一个变量转换为给定的Type及其派生类类型的变量
  template <typename T>
@ -115,6 +118,22 @@ class FunctionType : public Type {
  unsigned getNumParams() const { return paramTypes.size(); }  ///< 获取形参数量
 };

+class ArrayType : public Type {
+ public:
+  // elements：数组的元素类型 (例如，int[3] 的 elementType 是 int)
+  // numElements：该维度的大小 (例如，int[3] 的 numElements 是 3)
+  static ArrayType *get(Type *elementType, unsigned numElements);
+
+  Type *getElementType() const { return elementType; }
+  unsigned getNumElements() const { return numElements; }
+
+ protected:
+  ArrayType(Type *elementType, unsigned numElements)
+      : Type(Kind::kArray), elementType(elementType), numElements(numElements) {}
+  Type *elementType;
+  unsigned numElements; // 当前维度的大小
+};
+
 /*!
 * @}
 */
@ -268,6 +287,51 @@ class ValueCounter {
  }  ///< 清空ValueCounter
 };

+
+// --- Refactored ConstantValue and related classes start here ---
+
+using ConstantValVariant = std::variant<int, float>;
+
+// Helper for hashing std::variant
+struct VariantHash {
+  template <class T>
+  std::size_t operator()(const T& val) const {
+    return std::hash<T>{}(val);
+  }
+  std::size_t operator()(const ConstantValVariant& v) const {
+    return std::visit(*this, v);
+  }
+};
+
+struct ConstantValueKey {
+  Type* type;
+  ConstantValVariant val;
+
+  bool operator==(const ConstantValueKey& other) const {
+    // Assuming Type objects are canonicalized, or add Type::isSame()
+    // If Type::isSame() is not available and Type objects are not canonicalized,
+    // this comparison might not be robust enough for structural equivalence of types.
+    return type == other.type && val == other.val;
+  }
+};
+
+struct ConstantValueHash {
+  std::size_t operator()(const ConstantValueKey& key) const {
+    std::size_t typeHash = std::hash<Type*>{}(key.type);
+    std::size_t valHash = VariantHash{}(key.val);
+    // A simple way to combine hashes
+    return typeHash ^ (valHash << 1);
+  }
+};
+
+struct ConstantValueEqual {
+  bool operator()(const ConstantValueKey& lhs, const ConstantValueKey& rhs) const {
+    // Assuming Type objects are canonicalized (e.g., Type::getIntType() always returns same pointer)
+    // If not, and Type::isSame() is intended, it should be added to Type class.
+    return lhs.type == rhs.type && lhs.val == rhs.val;
+  }
+};
+
 /*!
 * Static constants known at compile time.
 *
@ -276,45 +340,135 @@ class ValueCounter {
 * `ConstantValue`并不由指令定义, 也不使用任何Value。它的类型为int/float。
 */

+template<class T> struct always_false : std::false_type {};
+template<class T> constexpr bool always_false_v = always_false<T>::value;

 class ConstantValue : public Value {
 protected:
-  /// 定义字面量类型的聚合类型
-  union {
-    int iScalar;
-    float fScalar;
+  static std::unordered_map<ConstantValueKey, ConstantValue*, ConstantValueHash, ConstantValueEqual> mConstantPool;
+
+public:
+  explicit ConstantValue(Type* type, const std::string& name = "") : Value(type, name) {}
+  virtual ~ConstantValue() = default;
+
+  virtual size_t hash() const = 0;
+  virtual ConstantValVariant getVal() const = 0;
+
+  // Static factory method to get a canonical ConstantValue from the pool
+  static ConstantValue* get(Type* type, ConstantValVariant val);
+
+  // Helper methods to access constant values with appropriate casting
+  int getInt() const {
+    assert(getType()->isInt() && "Calling getInt() on non-integer type");
+    return std::get<int>(getVal());
+  }
+  float getFloat() const {
+    assert(getType()->isFloat() && "Calling getFloat() on non-float type");
+    return std::get<float>(getVal());
+  }
+
+  template<typename T>
+  T getVal() const {
+    if constexpr (std::is_same_v<T, int>) {
+      return getInt();
+    } else if constexpr (std::is_same_v<T, float>) {
+      return getFloat();
+    } else {
+      // This ensures a compilation error if an unsupported type is used
+      static_assert(always_false_v<T>, "Unsupported type for ConstantValue::getValue()");
+    }
+  }
+
+  virtual bool isZero() const = 0;
+  virtual bool isOne() const = 0;
 };

+class ConstantInteger : public ConstantValue {
+  int constVal;
+public:
+  explicit ConstantInteger(Type* type, int val, const std::string& name = "")
+      : ConstantValue(type, name), constVal(val) {}
+
+  size_t hash() const override {
+      std::size_t typeHash = std::hash<Type*>{}(getType());
+      std::size_t valHash = std::hash<int>{}(constVal);
+      return typeHash ^ (valHash << 1);
+  }
+  int getInt() const { return constVal; }
+  ConstantValVariant getVal() const override { return constVal; }
+
+  static ConstantInteger* get(Type* type, int val);
+  static ConstantInteger* get(int val) { return get(Type::getIntType(), val); }
+
+  ConstantInteger* getNeg() const {
+    assert(getType()->isInt() && "Cannot negate non-integer constant");
+    return ConstantInteger::get(-constVal);
+  }
+
+  bool isZero() const override { return constVal == 0; }
+  bool isOne() const override { return constVal == 1; }
+};
+
+class ConstantFloating : public ConstantValue {
+  float constFVal;
+public:
+  explicit ConstantFloating(Type* type, float val, const std::string& name = "")
+      : ConstantValue(type, name), constFVal(val) {}
+
+  size_t hash() const override {
+    std::size_t typeHash = std::hash<Type*>{}(getType());
+    std::size_t valHash = std::hash<float>{}(constFVal);
+    return typeHash ^ (valHash << 1);
+  }
+  float getFloat() const { return constFVal; }
+  ConstantValVariant getVal() const override { return constFVal; }
+
+  static ConstantFloating* get(Type* type, float val);
+  static ConstantFloating* get(float val) { return get(Type::getFloatType(), val); }
+
+  ConstantFloating* getNeg() const {
+    assert(getType()->isFloat() && "Cannot negate non-float constant");
+    return ConstantFloating::get(-constFVal);
+  }
+
+  bool isZero() const override { return constFVal == 0.0f; }
+  bool isOne() const override { return constFVal == 1.0f; }
+};
+
+class UndefinedValue : public ConstantValue {
+private:
+  static std::unordered_map<Type*, UndefinedValue*> UndefValues;
+
 protected:
-  explicit ConstantValue(int value, const std::string &name = "") : Value(Type::getIntType(), name), iScalar(value) {}
-  explicit ConstantValue(float value, const std::string &name = "")
-      : Value(Type::getFloatType(), name), fScalar(value) {}
+  explicit UndefinedValue(Type* type, const std::string& name = "")
+      : ConstantValue(type, name) {
+    assert(!type->isVoid() && "Cannot create UndefinedValue of void type!");
+  }

 public:
-  static ConstantValue* get(int value);    ///< 获取一个int类型的ConstValue *，其值为value
-  static ConstantValue* get(float value);  ///< 获取一个float类型的ConstValue *，其值为value
+  static UndefinedValue* get(Type* type);

- public:
-  int getInt() const {
-    assert(isInt());
-    return iScalar;
-  }  ///< 返回int类型的值
-  float getFloat() const {
-    assert(isFloat());
-    return fScalar;
-  }  ///< 返回float类型的值
-  template <typename T>
-  T getValue() const {
-    if (std::is_same<T, int>::value && isInt()) {
-      return getInt();
+  size_t hash() const override {
+    return std::hash<Type*>{}(getType());
  }
-    if (std::is_same<T, float>::value && isFloat()) {
-      return getFloat();
+
+  ConstantValVariant getVal() const override {
+    if (getType()->isInt()) {
+      return 0; // Return 0 for undefined integer
+    } else if (getType()->isFloat()) {
+      return 0.0f; // Return 0.0f for undefined float
    }
-    throw std::bad_cast();  // 或者其他适当的异常处理
-  }                         ///< 返回值，getInt和getFloat统一化，整数返回整形，浮点返回浮点型
+    assert(false && "UndefinedValue has unexpected type for getValue()");
+    return 0; // Should not be reached
+  }
+
+  bool isZero() const override { return false; }
+  bool isOne() const override { return false; }
 };

+// --- End of refactored ConstantValue and related classes ---
+
+
 class Instruction;
 class Function;
 class BasicBlock;
@ -467,49 +621,6 @@ class User : public Value {
  void setOperand(unsigned index, Value *value);      ///< 设置操作数
 };

-class GetSubArrayInst;
-/**
- * 左值 具有地址的对象
- */
-class LVal {
-  friend class GetSubArrayInst;
-
- protected:
-  LVal *fatherLVal{};                              ///< 父左值
-  std::list<std::unique_ptr<LVal>> childrenLVals;  ///< 子左值
-  GetSubArrayInst *defineInst{};                   /// 定义该左值的GetSubArray指令
-
- protected:
-  LVal() = default;
-
- public:
-  virtual ~LVal() = default;
-  virtual std::vector<Value *> getLValDims() const = 0;  ///< 获取左值的维度
-  virtual unsigned getLValNumDims() const  = 0;           ///< 获取左值的维度数量
-
- public:
-  LVal* getFatherLVal() const { return fatherLVal; }  ///< 获取父左值
-  const std::list<std::unique_ptr<LVal>>& getChildrenLVals() const {
-    return childrenLVals;
-  }  ///< 获取子左值列表
-  LVal* getAncestorLVal() const {
-    auto curLVal = const_cast<LVal *>(this);
-    while (curLVal->getFatherLVal() != nullptr) {
-      curLVal = curLVal->getFatherLVal();
-    }
-    return curLVal;
-  }                                                                  ///< 获取祖先左值
-  void setFatherLVal(LVal *father) { fatherLVal = father; }          ///< 设置父左值
-  void setDefineInst(GetSubArrayInst *inst) { defineInst = inst; }   ///< 设置定义指令
-  void addChild(LVal *child) { childrenLVals.emplace_back(child); }  ///< 添加子左值
-  void removeChild(LVal *child) {
-    auto iter = std::find_if(childrenLVals.begin(), childrenLVals.end(),
-                             [child](const std::unique_ptr<LVal> &ptr) { return ptr.get() == child; });
-    childrenLVals.erase(iter);
-  }                                                                       ///< 移除子左值
-  GetSubArrayInst* getDefineInst() const { return defineInst; }  ///< 获取定义指令
-};
-
 /*!
 * Base of all concrete instruction types.
 */
@ -559,15 +670,15 @@ class Instruction : public User {
    kAlloca = 0x1UL << 33,
    kLoad = 0x1UL << 34,
    kStore = 0x1UL << 35,
-    kLa = 0x1UL << 36,
+    kGetElementPtr = 0x1UL << 36,
    kMemset = 0x1UL << 37,
-    kGetSubArray = 0x1UL << 38,
-    // constant
-    kConstant = 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
+    kBitFtoI = 0x1UL << 41,
  };

 protected:
@ -658,14 +769,12 @@ public:
        return "Load";
      case kStore:
        return "Store";
-      case kLa:
-        return "La";
+      case kGetElementPtr:
+        return "GetElementPtr";
      case kMemset:
        return "Memset";
      case kPhi:
        return "Phi";
-      case kGetSubArray:
-        return "GetSubArray";
      default:
        return "Unknown";
    }
@ -718,9 +827,8 @@ public:
  bool isAlloca() const { return kind == kAlloca; }
  bool isLoad() const { return kind == kLoad; }
  bool isStore() const { return kind == kStore; }
-  bool isLa() const { return kind == kLa; }
+  bool isGetElementPtr() const { return kind == kGetElementPtr; }
  bool isMemset() const { return kind == kMemset; }
-  bool isGetSubArray() const { return kind == kGetSubArray; }
  bool isCall() const { return kind == kCall; }
  bool isReturn() const { return kind == kReturn; }
  bool isDefine() const {
@ -732,47 +840,54 @@ public:
 class Function;
 //! Function call.

-class LaInst : public Instruction {
-  friend class Function;
-  friend class IRBuilder;
-
- protected:
-  explicit LaInst(Value *pointer, const std::vector<Value *> &indices = {}, BasicBlock *parent = nullptr,
-                  const std::string &name = "")
-      : Instruction(Kind::kLa, pointer->getType(), parent, name) {
-    assert(pointer);
-    addOperand(pointer);
-    addOperands(indices);
-  }
-
- public:
-  unsigned getNumIndices() const { return getNumOperands() - 1; }  ///< 获取索引长度
-  Value* getPointer() const { return getOperand(0); }             ///< 获取目标变量的Value指针
-  auto getIndices() const { return make_range(std::next(operand_begin()), operand_end()); }  ///< 获取索引列表
-  Value* getIndex(unsigned index) const { return getOperand(index + 1); }  ///< 获取位置为index的索引分量
-};
-
 class PhiInst : public Instruction {
  friend class IRBuilder;
  friend class Function;
-  friend class SysySSA;

 protected:
-  Value *map_val;  // Phi的旧值

-  PhiInst(Type *type, Value *lhs, const std::vector<Value *> &rhs, Value *mval, BasicBlock *parent,
+  std::unordered_map<BasicBlock *, Value *> blk2val;  ///< 存储每个基本块对应的值
+  unsigned vsize;  ///< 存储值的数量
+
+  PhiInst(Type *type, 
+          const std::vector<Value *> &rhs = {}, 
+          const std::vector<BasicBlock*> &Blocks = {},
+          BasicBlock *parent = nullptr,
          const std::string &name = "")
-      : Instruction(Kind::kPhi, type, parent, name) {
-    map_val = mval;
-    addOperand(lhs);
-    addOperands(rhs);
+      : 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 < rhs.size(); ++i) {
+      addOperand(rhs[i]);
+      blk2val[Blocks[i]] = rhs[i];
+    }
  }

 public:
-  Value* getMapVal() { return map_val; }
-  Value* getPointer() const { return getOperand(0); }
+  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; }  ///< 获取传入值的数量
+  void addIncoming(Value *value, BasicBlock *block) {
+    assert(value && block && "PhiInst: value and block must not be null");
+    addOperand(value);
+    addOperand(block);
+    blk2val[block] = value;
+    vsize++;
+  }  ///< 添加传入值和对应的基本块
+
+  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()); }
-  Value* getValue(unsigned index) const { return getOperand(index + 1); }
 };


@ -884,7 +999,7 @@ public:
    }
  }  ///< 根据指令类型进行二元计算，eval template模板实现
  static BinaryInst* create(Kind kind, Type *type, Value *lhs, Value *rhs, BasicBlock *parent, const std::string &name = "") {
-        // 后端处理数组访存操作时需要创建计算地址的指令，需要在外部构造 BinaryInst 对象，所以写了个public的方法。
+        // 后端处理数组访存操作时需要创建计算地址的指令，需要在外部构造 BinaryInst 对象
        return new BinaryInst(kind, type, lhs, rhs, parent, name);
  }
 }; // class BinaryInst
@ -972,7 +1087,7 @@ public:
 }; // class CondBrInst

 //! Allocate memory for stack variables, used for non-global variable declartion
-class AllocaInst : public Instruction , public LVal {
+class AllocaInst : public Instruction {
  friend class IRBuilder;
  friend class Function;
 protected:
@ -983,14 +1098,6 @@ protected:
  }

 public:
-  std::vector<Value *> getLValDims() const override {
-    std::vector<Value *> dims;
-    for (const auto &dim : getOperands()) {
-      dims.emplace_back(dim->getValue());
-    }
-    return dims;
-  }  ///< 获取作为左值的维度数组
-  unsigned getLValNumDims() const override { return getNumOperands(); }
  
  int getNumDims() const { return getNumOperands(); }
  auto getDims() const { return getOperands(); }
@ -999,37 +1106,40 @@ public:
 }; // class AllocaInst


-class GetSubArrayInst : public Instruction {
-  friend class IRBuilder;
-  friend class Function;
+class GetElementPtrInst : public Instruction {
+  friend class IRBuilder; // 如果您有IRBuilder来创建指令，需要friend

- public:
-  GetSubArrayInst(LVal *fatherArray, LVal *childArray, const std::vector<Value *> &indices,
+protected:
+  // GEP的构造函数：
+  // resultType: GEP计算出的地址的类型 (通常是指向目标元素类型的指针)
+  // basePointer: 基指针 (第一个操作数)
+  // indices: 索引列表 (后续操作数)
+  GetElementPtrInst(Value *basePointer,
+                      const std::vector<Value *> &indices = {},
                      BasicBlock *parent = nullptr, const std::string &name = "")
-      : Instruction(Kind::kGetSubArray, Type::getVoidType(), parent, name) {
-    auto predicate = [childArray](const std::unique_ptr<LVal> &child) -> bool { return child.get() == childArray; };
-    if (std::find_if(fatherArray->childrenLVals.begin(), fatherArray->childrenLVals.end(), predicate) ==
-        fatherArray->childrenLVals.end()) {
-      fatherArray->childrenLVals.emplace_back(childArray);
-    }
-    childArray->fatherLVal = fatherArray;
-    childArray->defineInst = this;
-    auto fatherArrayValue = dynamic_cast<Value *>(fatherArray);
-    auto childArrayValue = dynamic_cast<Value *>(childArray);
-    assert(fatherArrayValue);
-    assert(childArrayValue);
-    addOperand(fatherArrayValue);
-    addOperand(childArrayValue);
-    addOperands(indices);
+      : Instruction(Kind::kGetElementPtr, basePointer->getType(), parent, name) {
+    assert(basePointer && "GEP base pointer cannot be null!");
+    // TODO : 安全检查
+    assert(basePointer->getType()->isPointer() );
+    addOperand(basePointer); // 第一个操作数是基指针
+    addOperands(indices);    // 随后的操作数是索引
  }

 public:
-  Value* getFatherArray() const { return getOperand(0); }                              ///< 获取父数组
-  Value* getChildArray() const { return getOperand(1); }                               ///< 获取子数组
-  LVal* getFatherLVal() const { return dynamic_cast<LVal *>(getOperand(0)); }          ///< 获取父左值
-  LVal* getChildLVal() const { return dynamic_cast<LVal *>(getOperand(1)); }           ///< 获取子左值
-  auto getIndices() const { return make_range(std::next(operand_begin(), 2), operand_end()); }  ///< 获取索引
-  unsigned getNumIndices() const { return getNumOperands() - 2; }                       ///< 获取索引数量
+  Value* getBasePointer() const { return getOperand(0); }
+  unsigned getNumIndices() const { return getNumOperands() - 1; }
+  auto getIndices() const { return make_range(std::next(operand_begin()), operand_end());}
+  Value* getIndex(unsigned index) const {
+    assert(index < getNumIndices() && "Index out of bounds for GEP!");
+    return getOperand(index + 1);
+  }
+
+  // 静态工厂方法，用于创建GEP指令 (如果需要外部直接创建而非通过IRBuilder)
+  static GetElementPtrInst* create(Type *resultType, Value *basePointer,
+                                    const std::vector<Value *> &indices = {},
+                                    BasicBlock *parent = nullptr, const std::string &name = "") {
+    return new GetElementPtrInst(basePointer, indices, parent, name);
+  }
 };

 //! Load a value from memory address specified by a pointer value
@ -1053,22 +1163,7 @@ public:
    return make_range(std::next(operand_begin()), operand_end());
  }
  Value* getIndex(int index) const { return getOperand(index + 1); }
-  std::list<Value *> getAncestorIndices() const {
-    std::list<Value *> indices;
-    for (const auto &index : getIndices()) {
-      indices.emplace_back(index->getValue());
-    }
-    auto curPointer = dynamic_cast<LVal *>(getPointer());
-    while (curPointer->getFatherLVal() != nullptr) {
-      auto inserter = std::next(indices.begin());
-      for (const auto &index : curPointer->getDefineInst()->getIndices()) {
-        indices.insert(inserter, index->getValue());
-      }
-      curPointer = curPointer->getFatherLVal();
-    }
  
-    return indices;
-  }  ///< 获取相对于祖先数组的索引列表
 }; // class LoadInst

 //! Store a value to memory address specified by a pointer value
@ -1094,22 +1189,6 @@ public:
    return make_range(std::next(operand_begin(), 2), operand_end());
  }
  Value* getIndex(int index) const { return getOperand(index + 2); }
-  std::list<Value *> getAncestorIndices() const {
-    std::list<Value *> indices;
-    for (const auto &index : getIndices()) {
-      indices.emplace_back(index->getValue());
-    }
-    auto curPointer = dynamic_cast<LVal *>(getPointer());
-    while (curPointer->getFatherLVal() != nullptr) {
-      auto inserter = std::next(indices.begin());
-      for (const auto &index : curPointer->getDefineInst()->getIndices()) {
-        indices.insert(inserter, index->getValue());
-      }
-      curPointer = curPointer->getFatherLVal();
-    }
-
-    return indices;
-  }  ///< 获取相对于祖先数组的索引列表

 }; // class StoreInst

@ -1211,7 +1290,7 @@ protected:
 };

 //! Global value declared at file scope
-class GlobalValue : public User, public LVal {
+class GlobalValue : public User {
  friend class Module;

 protected:
@ -1230,28 +1309,21 @@ protected:
    if (init.size() == 0) {
      unsigned num = 1;
      for (unsigned i = 0; i < numDims; i++) {
-        num *= dynamic_cast<ConstantValue *>(dims[i])->getInt();
+        // 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(ConstantValue::get(0.0F), num);
+        init.push_back(ConstantFloating::get(0.0F), num); // Use new constant factory
      } else {
-        init.push_back(ConstantValue::get(0), num);
+        init.push_back(ConstantInteger::get(0), num); // Use new constant factory
      }
    }
    initValues = init;
  }

 public:
-  unsigned getLValNumDims() const override { return numDims; }  ///< 获取作为左值的维度数量
-  std::vector<Value *> getLValDims() const override {
-    std::vector<Value *> dims;
-    for (const auto &dim : getOperands()) {
-      dims.emplace_back(dim->getValue());
-    }
-
-    return dims;
-  }  ///< 获取作为左值的维度列表
-
  unsigned getNumDims() const  { return numDims; }                     ///< 获取维度数量
  Value* getDim(unsigned index) const { return getOperand(index); }  ///< 获取位置为index的维度
  auto getDims() const { return getOperands(); }                              ///< 获取维度列表
@ -1261,8 +1333,11 @@ public:
   Value* getByIndices(const std::vector<Value *> &indices) const  {
    int index = 0;
    for (size_t i = 0; i < indices.size(); i++) {
-      index = dynamic_cast<ConstantValue *>(getDim(i))->getInt() * index +
-              dynamic_cast<ConstantValue *>(indices[i])->getInt();
+      // Ensure dims[i] and indices[i] are ConstantInteger and retrieve their values correctly
+      auto dim_val = dynamic_cast<ConstantInteger*>(getDim(i));
+      auto idx_val = dynamic_cast<ConstantInteger*>(indices[i]);
+      assert(dim_val && idx_val && "Dims and indices must be constant integers");
+      index = dim_val->getInt() * index + idx_val->getInt();
    }
    return getByIndex(index);
  }  ///< 通过多维索引indices获取初始值
@ -1270,7 +1345,7 @@ public:
 }; // class GlobalValue


-class ConstantVariable : public User, public LVal {
+class ConstantVariable : public User {
  friend class Module;

 protected:
@ -1289,22 +1364,16 @@ class ConstantVariable : public User, public LVal {
  }

 public:
-  unsigned getLValNumDims() const override { return numDims; }  ///< 获取作为左值的维度数量
-  std::vector<Value *> getLValDims() const override {
-    std::vector<Value *> dims;
-    for (const auto &dim : getOperands()) {
-      dims.emplace_back(dim->getValue());
-    }
-
-    return dims;
-  }  ///< 获取作为左值的维度列表
  Value* getByIndex(unsigned index) const { return initValues.getValue(index); }  ///< 通过一维位置index获取值
  Value* getByIndices(const std::vector<Value *> &indices) const {
    int index = 0;
    // 计算偏移量
    for (size_t i = 0; i < indices.size(); i++) {
-      index = dynamic_cast<ConstantValue *>(getDim(i))->getInt() * index +
-              dynamic_cast<ConstantValue *>(indices[i])->getInt();
+      // Ensure dims[i] and indices[i] are ConstantInteger and retrieve their values correctly
+      auto dim_val = dynamic_cast<ConstantInteger*>(getDim(i));
+      auto idx_val = dynamic_cast<ConstantInteger*>(indices[i]);
+      assert(dim_val && idx_val && "Dims and indices must be constant integers");
+      index = dim_val->getInt() * index + idx_val->getInt();
    }

    return getByIndex(index);
--- a/src/include/IRBuilder.h
+++ b/src/include/IRBuilder.h
@ -280,46 +280,6 @@ class IRBuilder {
    block->getInstructions().emplace(position, inst);
    return inst;
  }  ///< 创建load指令
-  LaInst * createLaInst(Value *pointer, 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 LaInst(pointer, indices, block, newName);
-    assert(inst);
-    block->getInstructions().emplace(position, inst);
-    return inst;
-  }  ///< 创建la指令
-  GetSubArrayInst * createGetSubArray(LVal *fatherArray, const std::vector<Value *> &indices, const std::string &name = "") {
-    assert(fatherArray->getLValNumDims() > indices.size());
-    std::vector<Value *> subDims;
-    auto dims = fatherArray->getLValDims();
-    auto iter = std::next(dims.begin(), indices.size());
-    while (iter != dims.end()) {
-      subDims.emplace_back(*iter);
-      iter++;
-    }
-
-    std::string childArrayName;
-    std::stringstream ss;
-    ss << "A"
-       << "%" << tmpIndex;
-    childArrayName = ss.str();
-    tmpIndex++;
-
-    auto fatherArrayValue = dynamic_cast<Value *>(fatherArray);
-    auto childArray = new AllocaInst(fatherArrayValue->getType(), subDims, block, childArrayName);
-    auto inst = new GetSubArrayInst(fatherArray, childArray, indices, block, childArrayName);
-    assert(inst);
-    block->getInstructions().emplace(position, inst);
-    return inst;
-  }  ///< 创建获取部分数组指令
  MemsetInst * createMemsetInst(Value *pointer, Value *begin, Value *size, Value *value, const std::string &name = "") {
    auto inst = new MemsetInst(pointer, begin, size, value, block, name);
    assert(inst);
@ -333,17 +293,31 @@ class IRBuilder {
    block->getInstructions().emplace(position, inst);
    return inst;
  }  ///< 创建store指令
-  PhiInst * createPhiInst(Type *type, Value *lhs, BasicBlock *parent, const std::string &name = "") {
-    auto predNum = parent->getNumPredecessors();
-    std::vector<Value *> rhs;
-    for (size_t i = 0; i < predNum; i++) {
-      rhs.push_back(lhs);
-    }
-    auto inst = new PhiInst(type, lhs, rhs, lhs, parent, name);
+  PhiInst * createPhiInst(Type *type, const std::vector<Value*> &vals = {}, const std::vector<BasicBlock*> &blks = {}, const std::string &name = "") {
+    auto predNum = block->getNumPredecessors();
+    auto inst = new PhiInst(type, vals, blks, block, name);
    assert(inst);
-    parent->getInstructions().emplace(parent->begin(), inst);
+    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;
+  }
 };

 }  // namespace sysy
--- a/src/include/Mem2Reg.h
+++ b/src/include/Mem2Reg.h
@ -1,59 +1,79 @@
-#pragma once
+// 假设 Mem2Reg.h 看起来像这样 (你需要根据实际情况调整)
+#ifndef SYSY_MEM2REG_H
+#define SYSY_MEM2REG_H

-#include <list>
-#include <memory>
-#include <stack>
+#include <vector>
 #include <unordered_map>
 #include <unordered_set>
+#include <stack>
+#include <queue> // For computeIteratedDomFrontiers
+
+// Include your IR and analysis headers
 #include "IR.h"
 #include "IRBuilder.h"
 #include "SysYIRAnalyser.h"
+#include "SysYIROptUtils.h"

 namespace sysy {
-/**
- * 实现静态单变量赋值核心类 mem2reg
- */
+
 class Mem2Reg {
 private:
  Module* pModule;
  IRBuilder* pBuilder;
-  ControlFlowAnalysis *controlFlowAnalysis;  // 控制流分析
-  ActiveVarAnalysis *activeVarAnalysis;  // 活跃变量分析
-  DataFlowAnalysisUtils dataFlowAnalysisUtils;
+  ControlFlowAnalysis* controlFlowAnalysis;
+  ActiveVarAnalysis* activeVarAnalysis;
+  DataFlowAnalysisUtils dataFlowAnalysisUtils; // If this is part of Mem2Reg or an external helper

 public:
-  Mem2Reg(Module *pMoudle, IRBuilder *pBuilder, 
-          ControlFlowAnalysis *pCFA = nullptr, ActiveVarAnalysis *pAVA = nullptr) :
-    pModule(pMoudle), pBuilder(pBuilder), controlFlowAnalysis(pCFA), activeVarAnalysis(pAVA), dataFlowAnalysisUtils()
-   {}  // 初始化函数
+  Mem2Reg(Module* module, IRBuilder* builder, ControlFlowAnalysis* cfa, ActiveVarAnalysis* ava)
+    : pModule(module), pBuilder(builder), controlFlowAnalysis(cfa), activeVarAnalysis(ava) {}
+    // Constructor initializes members
+  void run();

-  void mem2regPipeline();  ///< mem2reg
+  // --- 新增的私有成员变量和方法，用于SSA转换上下文 ---
+  // 这是核心，用于存储 SSA 转换过程中的状态
+  std::vector<AllocaInst*> currentFunctionAllocas; // 当前函数中所有可提升的 alloca
+  // alloca -> set of BasicBlocks where it's defined (stored into)
+  std::unordered_map<AllocaInst*, std::unordered_set<BasicBlock*>> allocaDefsBlock; 
+  // alloca -> set of BasicBlocks where it's used (loaded from)
+  std::unordered_map<AllocaInst*, std::unordered_set<BasicBlock*>> allocaUsesBlock; 

-private:
+  // BasicBlock -> Map of (PhiInst, Original AllocaInst)
+  // 用于在 rename 阶段通过 phi 指令找到它代表的原始 alloca
+  std::unordered_map<BasicBlock*, std::unordered_map<PhiInst*, AllocaInst*>> phiMap;
+  std::vector<PhiInst*> allPhiInstructions; // 收集所有创建的 Phi 指令以便后续简化和清理

-  // phi节点的插入需要计算IDF
-  std::unordered_set<BasicBlock *> computeIterDf(const std::unordered_set<BasicBlock *> &blocks);  ///< 计算定义块集合的迭代支配边界
+  // --- 核心 SSA 转换辅助函数 ---
+  // 计算给定定义块集合的迭代支配边界
+  std::unordered_set<BasicBlock*> computeIteratedDomFrontiers(const std::unordered_set<BasicBlock*>& blocks);

-  auto computeValue2Blocks() -> void;  ///< 计算value2block的映射(不包括数组和global)
+  // 分析一个 alloca 的所有 uses，填充 allocaDefsBlock 和 allocaUsesBlock
+  void allocaAnalysis(AllocaInst* alloca);

-  auto preOptimize1() -> void;  ///< llvm memtoreg预优化1: 删除不含load的alloc和store
-  auto preOptimize2() -> void;  ///< llvm memtoreg预优化2: 针对某个变量的Defblocks只有一个块的情况
-  auto preOptimize3() -> void;  ///< llvm memtoreg预优化3: 针对某个变量的所有读写都在同一个块中的情况
+  // 判断一个 alloca 是否可以被提升为寄存器 (无地址逃逸，标量类型)
+  bool is_promoted(AllocaInst* alloca);

-  auto insertPhi() -> void;  ///< 为所有变量的迭代支配边界插入phi结点
+  // 在迭代支配边界处插入 Phi 指令
+  void insertPhiNodes(Function* func);

-  auto rename(BasicBlock *block, std::unordered_map<Value *, int> &count,
-              std::unordered_map<Value *, std::stack<Instruction *>> &stacks) -> void;  ///< 单个块的重命名
-  auto renameAll() -> void;                                                             ///< 重命名所有块
+  // 递归地重命名基本块中的变量并填充 Phi 指令
+  // 这里的 `count` 和 `stacks` 是临时的，用于 DFS 过程中传递状态
+  void renameBlock(BasicBlock* block, 
+                      std::unordered_map<AllocaInst*, Value*>& currentIncomings,
+                      std::unordered_set<BasicBlock*>& visitedBlocks); // 修改为传递 map 和 set

-  // private helper function.
-private:
-  auto getPredIndex(BasicBlock *n, BasicBlock *s) -> int;  ///< 获取前驱索引
-  auto cascade(Instruction *instr, bool &changed, Function *func, BasicBlock *block,
-               std::list<std::unique_ptr<Instruction>> &instrs) -> void;  ///< 消除级联关系
-  auto isGlobal(Value *val) -> bool;                                      ///< 判断是否是全局变量
-  auto isArr(Value *val) -> bool;                                         ///< 判断是否是数组
-  auto usedelete(Instruction *instr) -> void;                             ///< 删除指令相关的value-use-user关系
+  // 简化冗余的 Phi 指令 (当所有输入都相同时)
+  void simplifyphi(PhiInst* phi);
+
+  // 获取前驱块在后继块前驱列表中的索引，用于 Phi 指令入边
+  int getPredIndex(BasicBlock* pred, BasicBlock* succ);
+
+  // --- Mem2Reg 的主要工作流函数 ---
+  // 对单个函数执行内存到寄存器的提升
+  bool promoteMemoryToRegisters(Function* func);

 };
+
 } // namespace sysy
+
+#endif // SYSY_MEM2REG_H
--- a/src/include/RISCv64Passes.h
+++ b/src/include/RISCv64Passes.h
@ -1,4 +1,3 @@
-// RISCv64Passes.h
 #ifndef RISCV64_PASSES_H
 #define RISCV64_PASSES_H

@ -6,12 +5,56 @@

 namespace sysy {

-// 此处为未来优化Pass的基类或独立类定义
-// 例如:
-// class PeepholeOptimizer {
-// public:
-//     void runOnMachineFunction(MachineFunction* mfunc);
-// };
+/**
+ * @class Pass
+ * @brief 所有优化Pass的抽象基类 (可选，但推荐)
+ * * 定义一个通用的接口，所有优化都应该实现它。
+ */
+class Pass {
+public:
+    virtual ~Pass() = default;
+    virtual void runOnMachineFunction(MachineFunction* mfunc) = 0;
+};
+
+
+// --- 寄存器分配前优化 ---
+
+/**
+ * @class PreRA_Scheduler
+ * @brief 寄存器分配前的指令调度器
+ * * 在虚拟寄存器上进行操作，此时调度自由度最大，
+ * 主要目标是隐藏指令延迟，提高流水线效率。
+ */
+class PreRA_Scheduler : public Pass {
+public:
+    void runOnMachineFunction(MachineFunction* mfunc) override;
+};
+
+
+// --- 寄存器分配后优化 ---
+
+/**
+ * @class PeepholeOptimizer
+ * @brief 窥孔优化器
+ * * 在已分配物理寄存器的指令流上，通过一个小的滑动窗口来查找
+ * 并替换掉一些冗余或低效的指令模式。
+ */
+class PeepholeOptimizer : public Pass {
+public:
+    void runOnMachineFunction(MachineFunction* mfunc) override;
+};
+
+/**
+ * @class PostRA_Scheduler
+ * @brief 寄存器分配后的局部指令调度器
+ * * 主要目标是优化寄存器分配器插入的spill/fill代码(lw/sw)，
+ * 尝试将加载指令提前，以隐藏其访存延迟。
+ */
+class PostRA_Scheduler : public Pass {
+public:
+    void runOnMachineFunction(MachineFunction* mfunc) override;
+};
+

 } // namespace sysy

--- a/src/include/Reg2Mem.h
+++ b/src/include/Reg2Mem.h
@ -2,6 +2,7 @@

 #include "IR.h"
 #include "IRBuilder.h"
+#include "SysYIROptUtils.h"

 namespace sysy {
 /**
@ -16,8 +17,6 @@ public:
  Reg2Mem(Module *pMoudle, IRBuilder *pBuilder) : pModule(pMoudle), pBuilder(pBuilder) {}

  void DeletePhiInst();
-  // 删除UD关系, 因为删除了phi指令会修改ud关系
-  void usedelete(Instruction *instr);
 };

 } // namespace sysy
--- a/src/include/SCCP.h
+++ b/src/include/SCCP.h
@ -0,0 +1,196 @@
+#pragma once
+
+#include "IR.h"
+
+namespace sysy {
+
+// 稀疏条件常量传播类
+// 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过程中进行常量传播和控制流简化。
+
+//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;
+
+class SCCP {
+private:
+  Module *pModule;
+
+public:
+  SCCP(Module *pMoudle) : pModule(pMoudle) {}
+
+  void run();
+  bool PropagateConstants(Function *function);
+  bool SimplifyControlFlow(Function *function);
+  void ProcessInstruction(Instruction *inst);
+  void ProcessEdge(const std::pair<BasicBlock *, BasicBlock *> &edge);
+  void RemoveDeadBlock(BasicBlock *bb);
+  void UpdateState(Value *v, LatticeValue newState);
+  LatticeValue Meet(LatticeValue a, LatticeValue b);
+  LatticeValue GetValueState(Value *v);
+};
+
+}  // namespace sysy
--- a/src/include/SysYFormatter.h
+++ b/src/include/SysYFormatter.h
@ -1,340 +0,0 @@
-#pragma once
-
-#include "SysYBaseVisitor.h"
-#include "SysYParser.h"
-#include <ostream>
-
-namespace sysy {
-
-class SysYFormatter : public SysYBaseVisitor {
-protected:
-  std::ostream &os;
-  int indent = 0;
-
-public:
-  SysYFormatter(std::ostream &os) : os(os), indent(0) {}
-
-protected:
-  struct Indentor {
-    static constexpr int TabSize = 2;
-    int &indent;
-    Indentor(int &indent) : indent(indent) { indent += TabSize; }
-    ~Indentor() { indent -= TabSize; }
-  };
-  std::ostream &space() { return os << std::string(indent, ' '); }
-  template <typename T>
-  std::ostream &interleave(const T &container, const std::string sep = ", ") {
-    auto b = container.begin(), e = container.end();
-    (*b)->accept(this);
-    for (b = std::next(b); b != e; b = std::next(b)) {
-      os << sep;
-      (*b)->accept(this);
-    }
-    return os;
-  }
-
-public:
-  //   virtual std::any visitModule(SysYParser::ModuleContext *ctx) override {
-  //     return visitChildren(ctx);
-  //   }
-
-  virtual std::any visitBtype(SysYParser::BtypeContext *ctx) override {
-    os << ctx->getText();
-    return 0;
-  }
-
-  virtual std::any visitDecl(SysYParser::DeclContext *ctx) override {
-    space();
-    if (ctx->CONST())
-      os << ctx->CONST()->getText() << ' ';
-    ctx->btype()->accept(this);
-    os << ' ';
-    interleave(ctx->varDef(), ", ") << ';' << '\n';
-    return 0;
-  }
-
-  virtual std::any visitVarDef(SysYParser::VarDefContext *ctx) override {
-    ctx->lValue()->accept(this);
-    if (ctx->initValue()) {
-      os << ' ' << '=' << ' ';
-      ctx->initValue()->accept(this);
-    }
-    return 0;
-  }
-
-  virtual std::any visitInitValue(SysYParser::InitValueContext *ctx) override {
-    if (not ctx->exp()) {
-      os << '{';
-      auto values = ctx->initValue();
-      if (values.size())
-        interleave(values, ", ");
-      os << '}';
-    }
-    return 0;
-  }
-
-  virtual std::any visitFunc(SysYParser::FuncContext *ctx) override {
-    ctx->funcType()->accept(this);
-    os << ' ' << ctx->ID()->getText() << '(';
-    if (ctx->funcFParams())
-      ctx->funcFParams()->accept(this);
-    os << ')' << ' ';
-    ctx->blockStmt()->accept(this);
-    os << '\n';
-    return 0;
-  }
-
-  virtual std::any visitFuncType(SysYParser::FuncTypeContext *ctx) override {
-    os << ctx->getText();
-    return 0;
-  }
-
-  virtual std::any
-  visitFuncFParams(SysYParser::FuncFParamsContext *ctx) override {
-    interleave(ctx->funcFParam(), ", ");
-    return 0;
-  }
-
-  virtual std::any
-  visitFuncFParam(SysYParser::FuncFParamContext *ctx) override {
-    ctx->btype()->accept(this);
-    os << ' ' << ctx->ID()->getText();
-    if (not ctx->LBRACKET().empty()) {
-      os << '[';
-      auto exp = ctx->exp();
-      if (not exp.empty()) {
-        os << '[';
-        interleave(exp, "][") << ']';
-      }
-    }
-    return 0;
-  }
-
-  virtual std::any visitBlockStmt(SysYParser::BlockStmtContext *ctx) override {
-    os << '{' << '\n';
-    {
-      Indentor indentor(indent);
-      auto items = ctx->blockItem();
-      if (not items.empty())
-        interleave(items, "");
-    }
-    space() << ctx->RBRACE()->getText() << '\n';
-    return 0;
-  }
-
-  //   virtual std::any visitBlockItem(SysYParser::BlockItemContext *ctx)
-  //   override {
-  //     return visitChildren(ctx);
-  //   }
-
-  //   virtual std::any visitStmt(SysYParser::StmtContext *ctx) override {
-  //     return visitChildren(ctx);
-  //   }
-
-  virtual std::any
-  visitAssignStmt(SysYParser::AssignStmtContext *ctx) override {
-    space();
-    ctx->lValue()->accept(this);
-    os << " = ";
-    ctx->exp()->accept(this);
-    os << ';' << '\n';
-    return 0;
-  }
-
-  virtual std::any visitExpStmt(SysYParser::ExpStmtContext *ctx) override {
-    space();
-    ctx->exp()->accept(this);
-    os << ';' << '\n';
-    return 0;
-  }
-
-  void wrapBlock(SysYParser::StmtContext *stmt) {
-    bool isBlock = stmt->blockStmt();
-    if (isBlock) {
-      stmt->accept(this);
-    } else {
-      os << "{\n";
-      {
-        Indentor indentor(indent);
-        stmt->accept(this);
-      }
-      space() << "}\n";
-    }
-  };
-  virtual std::any visitIfStmt(SysYParser::IfStmtContext *ctx) override {
-    space();
-    os << ctx->IF()->getText() << " (";
-    ctx->exp()->accept(this);
-    os << ") ";
-    auto stmt = ctx->stmt();
-    auto ifStmt = stmt[0];
-    wrapBlock(ifStmt);
-    if (stmt.size() == 2) {
-      auto elseStmt = stmt[1];
-      wrapBlock(elseStmt);
-    }
-    return 0;
-  }
-
-  virtual std::any visitWhileStmt(SysYParser::WhileStmtContext *ctx) override {
-    space();
-    os << ctx->WHILE()->getText() << " (";
-    ctx->exp()->accept(this);
-    os << ") ";
-    wrapBlock(ctx->stmt());
-    return 0;
-  }
-
-  virtual std::any visitBreakStmt(SysYParser::BreakStmtContext *ctx) override {
-    space() << ctx->BREAK()->getText() << ';' << '\n';
-    return 0;
-  }
-
-  virtual std::any
-  visitContinueStmt(SysYParser::ContinueStmtContext *ctx) override {
-    space() << ctx->CONTINUE()->getText() << ';' << '\n';
-    return 0;
-  }
-
-  virtual std::any
-  visitReturnStmt(SysYParser::ReturnStmtContext *ctx) override {
-    space() << ctx->RETURN()->getText();
-    if (ctx->exp()) {
-      os << ' ';
-      ctx->exp()->accept(this);
-    }
-    os << ';' << '\n';
-    return 0;
-  }
-
-  //   virtual std::any visitEmptyStmt(SysYParser::EmptyStmtContext *ctx)
-  //   override {
-  //     return visitChildren(ctx);
-  //   }
-
-  virtual std::any
-  visitRelationExp(SysYParser::RelationExpContext *ctx) override {
-    auto lhs = ctx->exp(0);
-    auto rhs = ctx->exp(1);
-    std::string op =
-        ctx->LT() ? "<" : (ctx->LE() ? "<=" : (ctx->GT() ? ">" : ">="));
-    lhs->accept(this);
-    os << ' ' << op << ' ';
-    rhs->accept(this);
-    return 0;
-  }
-
-  virtual std::any
-  visitMultiplicativeExp(SysYParser::MultiplicativeExpContext *ctx) override {
-    auto lhs = ctx->exp(0);
-    auto rhs = ctx->exp(1);
-    std::string op = ctx->MUL() ? "*" : (ctx->DIV() ? "/" : "%");
-    lhs->accept(this);
-    os << ' ' << op << ' ';
-    rhs->accept(this);
-    return 0;
-  }
-
-  //   virtual std::any visitLValueExp(SysYParser::LValueExpContext *ctx)
-  //   override {
-  //     return visitChildren(ctx);
-  //   }
-
-  //   virtual std::any visitNumberExp(SysYParser::NumberExpContext *ctx)
-  //   override {
-  //     return visitChildren(ctx);
-  //   }
-
-  virtual std::any visitAndExp(SysYParser::AndExpContext *ctx) override {
-    ctx->exp(0)->accept(this);
-    os << " && ";
-    ctx->exp(1)->accept(this);
-    return 0;
-  }
-
-  virtual std::any visitUnaryExp(SysYParser::UnaryExpContext *ctx) override {
-    std::string op = ctx->ADD() ? "+" : (ctx->SUB() ? "-" : "!");
-    os << op;
-    ctx->exp()->accept(this);
-    return 0;
-  }
-
-  virtual std::any visitParenExp(SysYParser::ParenExpContext *ctx) override {
-    os << '(';
-    ctx->exp()->accept(this);
-    os << ')';
-    return 0;
-  }
-
-  virtual std::any visitStringExp(SysYParser::StringExpContext *ctx) override {
-    return visitChildren(ctx);
-  }
-
-  virtual std::any visitOrExp(SysYParser::OrExpContext *ctx) override {
-    ctx->exp(0)->accept(this);
-    os << " || ";
-    ctx->exp(1)->accept(this);
-    return 0;
-  }
-
-  //   virtual std::any visitCallExp(SysYParser::CallExpContext *ctx) override {
-  //     return visitChildren(ctx);
-  //   }
-
-  virtual std::any
-  visitAdditiveExp(SysYParser::AdditiveExpContext *ctx) override {
-    auto lhs = ctx->exp(0);
-    auto rhs = ctx->exp(1);
-    std::string op = ctx->ADD() ? "+" : "-";
-    lhs->accept(this);
-    os << ' ' << op << ' ';
-    rhs->accept(this);
-    return 0;
-  }
-
-  virtual std::any visitEqualExp(SysYParser::EqualExpContext *ctx) override {
-    auto lhs = ctx->exp(0);
-    auto rhs = ctx->exp(1);
-    std::string op = ctx->EQ() ? "==" : "!=";
-    lhs->accept(this);
-    os << ' ' << op << ' ';
-    rhs->accept(this);
-    return 0;
-  }
-
-  virtual std::any visitCall(SysYParser::CallContext *ctx) override {
-    os << ctx->ID()->getText() << '(';
-    if (ctx->funcRParams())
-      ctx->funcRParams()->accept(this);
-    os << ')';
-    return 0;
-  }
-
-  virtual std::any visitLValue(SysYParser::LValueContext *ctx) override {
-    os << ctx->ID()->getText();
-    auto exp = ctx->exp();
-    if (not exp.empty()) {
-      os << '[';
-      interleave(exp, "][") << ']';
-    }
-    return 0;
-  }
-
-  virtual std::any visitNumber(SysYParser::NumberContext *ctx) override {
-    os << ctx->getText();
-    return 0;
-  }
-
-  virtual std::any visitString(SysYParser::StringContext *ctx) override {
-    os << ctx->getText();
-    return 0;
-  }
-
-  virtual std::any
-  visitFuncRParams(SysYParser::FuncRParamsContext *ctx) override {
-    interleave(ctx->exp(), ", ");
-    return 0;
-  }
-};
-
-} // namespace sysy
--- a/src/include/SysYIRCFGOpt.h
+++ b/src/include/SysYIRCFGOpt.h
@ -0,0 +1,60 @@
+#pragma once
+
+#include "IR.h"
+#include "IRBuilder.h"
+
+namespace sysy {
+
+// 优化前对SysY IR的预处理，也可以视作部分CFG优化
+// 主要包括删除无用指令、合并基本块、删除空块等
+// 这些操作可以在SysY IR生成时就完成，但为了简化IR生成过程，
+// 这里将其放在SysY IR生成后进行预处理
+// 同时兼容phi节点的处理，可以再mem2reg后再次调用优化
+
+//TODO: 可增加的CFG优化和方法
+// - 检查基本块跳转关系正确性
+// - 简化条件分支（Branch Simplification），如条件恒真/恒假转为直接跳转
+// - 合并连续的跳转指令（Jump Threading）在合并不可达块中似乎已经实现了
+// - 基本块重排序（Block Reordering），提升局部性
+
+class SysYCFGOpt {
+ private:
+  Module *pModule;
+  IRBuilder *pBuilder;
+
+ public:
+  SysYCFGOpt(Module *pMoudle, IRBuilder *pBuilder) : pModule(pMoudle), pBuilder(pBuilder) {}
+
+  void SysYOptimizateAfterIR(){
+    
+    auto &functions = pModule->getFunctions();
+    for (auto &function : functions) {
+      bool changed = false;
+      while(changed){
+        changed = false;
+        changed |= SysYCondBr2Br(function.second.get(), pBuilder);
+        // 删除br后面的无用指令
+        changed |= SysYDelInstAfterBr(function.second.get());
+        // 合并空基本块
+        changed |= SysYBlockMerge(function.second.get());
+        // 删除无前驱块
+        changed |= SysYDelNoPreBLock(function.second.get());
+        // 删除空块
+        changed |= SysYDelEmptyBlock(function.second.get(), pBuilder);
+        // 添加return指令
+        changed |= SysYAddReturn(function.second.get(), pBuilder);
+      }
+    }
+  }
+
+public:
+  static bool SysYDelInstAfterBr(Function *func); // 删除br后面的指令
+  static bool SysYDelEmptyBlock(Function *func, IRBuilder* pBuilder); // 空块删除
+  static bool SysYDelNoPreBLock(Function *func); // 删除无前驱块（不可达块）
+  static bool SysYBlockMerge(Function *func);    // 合并基本块(主要针对嵌套if while的exit块，
+                            // 也可以修改IR生成实现回填机制
+  static bool SysYAddReturn(Function *func, IRBuilder* pBuilder);     // 添加return指令(主要针对Void函数)
+  static bool SysYCondBr2Br(Function *func, IRBuilder* pBuilder);  // 条件分支(已知cond的值)转换为无条件分支
+};
+
+}  // namespace sysy
--- a/src/include/SysYIRGenerator.h
+++ b/src/include/SysYIRGenerator.h
@ -62,12 +62,11 @@ private:
 public:
  SysYIRGenerator() = default;

-  bool HasReturnInst;
-
 public:
  Module *get() const { return module.get(); }
  IRBuilder *getBuilder(){ return &builder; }
 public:
+
  std::any visitCompUnit(SysYParser::CompUnitContext *ctx) override;

  std::any visitGlobalConstDecl(SysYParser::GlobalConstDeclContext *ctx) override;
@ -134,6 +133,11 @@ public:
  
  // std::any visitConstExp(SysYParser::ConstExpContext *ctx) override;

+public:
+  // 获取GEP指令的地址
+  Value* getGEPAddressInst(Value* basePointer, const std::vector<Value*>& indices);
+  // 构建数组类型
+  Type* buildArrayType(Type* baseType, const std::vector<Value*>& dims);

 }; // class SysYIRGenerator

--- a/src/include/SysYIROptPre.h
+++ b/src/include/SysYIROptPre.h
@ -1,37 +0,0 @@
-#pragma once
-
-#include "IR.h"
-#include "IRBuilder.h"
-
-namespace sysy {
-
-// 优化前对SysY IR的预处理，也可以视作部分CFG优化
-// 主要包括删除无用指令、合并基本块、删除空块等
-// 这些操作可以在SysY IR生成时就完成，但为了简化IR生成过程，
-// 这里将其放在SysY IR生成后进行预处理
-// 同时兼容phi节点的处理，可以再mem2reg后再次调用优化
-class SysYOptPre {
- private:
-  Module *pModule;
-  IRBuilder *pBuilder;
-
- public:
-  SysYOptPre(Module *pMoudle, IRBuilder *pBuilder) : pModule(pMoudle), pBuilder(pBuilder) {}
-
-  void SysYOptimizateAfterIR(){
-    SysYDelInstAfterBr();
-    SysYBlockMerge();
-    SysYDelNoPreBLock();
-    SysYDelEmptyBlock();
-    SysYAddReturn();
-  }
-  void SysYDelInstAfterBr(); // 删除br后面的指令
-  void SysYDelEmptyBlock(); // 空块删除
-  void SysYDelNoPreBLock(); // 删除无前驱块
-  void SysYBlockMerge();    // 合并基本块(主要针对嵌套if while的exit块，
-                            // 也可以修改IR生成实现回填机制
-  void SysYAddReturn();     // 添加return指令(主要针对Void函数)
-  void usedelete(Instruction *instr); // use删除
-};
-
-}  // namespace sysy
--- a/src/include/SysYIROptUtils.h
+++ b/src/include/SysYIROptUtils.h
@ -0,0 +1,33 @@
+#pragma once
+
+#include "IR.h"
+
+namespace sysy {
+
+// 优化工具类，包含一些通用的优化方法
+// 这些方法可以在不同的优化 pass 中复用
+// 例如：删除use关系,判断是否是全局变量等
+class SysYIROptUtils{
+
+public:
+  // 删除use关系
+  static void usedelete(Instruction *instr) {
+    for (auto &use : instr->getOperands()) {
+      Value* val = use->getValue();
+      val->removeUse(use);
+    }
+  }
+
+  // 判断是否是全局变量
+  static bool isGlobal(Value *val) {
+    auto gval = dynamic_cast<GlobalValue *>(val);
+    return gval != nullptr;
+  }
+  // 判断是否是数组
+  static bool isArr(Value *val) {
+    auto aval = dynamic_cast<AllocaInst *>(val);
+  return aval != nullptr && aval->getNumDims() != 0;
+  }
+};
+
+}// namespace sysy
--- a/src/include/SysYIRPass.h
+++ b/src/include/SysYIRPass.h
@ -0,0 +1,59 @@
+#pragma once
+
+#include "IR.h"
+
+namespace sysy {
+
+// 前置声明
+class FunctionPass;
+class ModulePass;
+class AnalysisPass;
+class PassManager;
+
+// 抽象基类 Pass
+class Pass {
+public:
+    enum PassKind {
+        PK_Function,
+        PK_Module,
+        PK_Analysis
+    };
+
+    Pass(PassKind kind, const std::string& name) : Kind(kind), Name(name) {}
+    virtual ~Pass() = default;
+
+    PassKind getPassKind() const { return Kind; }
+    const std::string& getPassName() const { return Name; }
+
+    // 每个Pass需要实现此方法来执行其逻辑
+    // 具体的run方法将根据Pass类型在FunctionPass和ModulePass中定义
+protected:
+    PassKind Kind;
+    std::string Name;
+};
+
+// 针对函数的优化遍
+class FunctionPass : public Pass {
+public:
+    FunctionPass(const std::string& name) : Pass(PK_Function, name) {}
+    // 真正的优化逻辑将在此方法中实现
+    virtual bool runOnFunction(Function& F) = 0;
+};
+
+// 针对模块的优化遍
+class ModulePass : public Pass {
+public:
+    ModulePass(const std::string& name) : Pass(PK_Module, name) {}
+    // 真正的优化逻辑将在此方法中实现
+    virtual bool runOnModule(Module& M) = 0;
+};
+
+// 分析遍
+class AnalysisPass : public Pass {
+public:
+    AnalysisPass(const std::string& name) : Pass(PK_Analysis, name) {}
+    // 分析遍通常需要一个模块或函数作为输入，并计算出分析结果
+    // 具体分析结果的存储和访问方式需要设计
+};
+
+} // namespace sysy
--- a/src/include/SysYIRPassManager.h
+++ b/src/include/SysYIRPassManager.h
@ -0,0 +1,58 @@
+// PassManager.h
+#pragma once
+
+#include <vector>
+#include <memory>
+#include <typeindex> // For std::type_index
+#include <unordered_map>
+#include "SysYIRPass.h"
+#include "IR.h" // 假设你的IR.h定义了Module, Function等
+
+namespace sysy {
+
+class PassManager {
+public:
+	PassManager() = default;
+
+	// 添加一个FunctionPass
+	void addPass(std::unique_ptr<FunctionPass> pass) {
+		functionPasses.push_back(std::move(pass));
+	}
+
+	// 添加一个ModulePass
+	void addPass(std::unique_ptr<ModulePass> pass) {
+		modulePasses.push_back(std::move(pass));
+	}
+
+	// 添加一个AnalysisPass
+	template<typename T, typename... Args>
+	T* addAnalysisPass(Args&&... args) {
+		static_assert(std::is_base_of<AnalysisPass, T>::value, "T must derive from AnalysisPass");
+		auto analysis = std::make_unique<T>(std::forward<Args>(args)...);
+		T* rawPtr = analysis.get();
+		analysisPasses[std::type_index(typeid(T))] = std::move(analysis);
+		return rawPtr;
+	}
+
+	// 获取分析结果（用于其他Pass访问）
+	template<typename T>
+	T* getAnalysis() {
+		static_assert(std::is_base_of<AnalysisPass, T>::value, "T must derive from AnalysisPass");
+		auto it = analysisPasses.find(std::type_index(typeid(T)));
+		if (it != analysisPasses.end()) {
+			return static_cast<T*>(it->second.get());
+		}
+		return nullptr; // 或者抛出异常
+	}
+
+	// 运行所有注册的遍
+	void run(Module& M);
+
+private:
+	std::vector<std::unique_ptr<FunctionPass>> functionPasses;
+	std::vector<std::unique_ptr<ModulePass>> modulePasses;
+	std::unordered_map<std::type_index, std::unique_ptr<AnalysisPass>> analysisPasses;
+	// 未来可以添加AnalysisPass的缓存机制
+};
+
+} // namespace sysy
--- a/src/sysyc.cpp
+++ b/src/sysyc.cpp
@ -13,13 +13,13 @@ using namespace antlr4;

 #include "SysYIRGenerator.h"
 #include "SysYIRPrinter.h"
-#include "SysYIROptPre.h"
+#include "SysYIRCFGOpt.h"
 #include "RISCv64Backend.h"
-#include "SysYIRAnalyser.h"
-#include "DeadCodeElimination.h"
+// #include "SysYIRAnalyser.h"
+// #include "DeadCodeElimination.h"
 #include "AddressCalculationExpansion.h"
-#include "Mem2Reg.h"
-#include "Reg2Mem.h"
+// #include "Mem2Reg.h"
+// #include "Reg2Mem.h"

 using namespace sysy;

@ -132,13 +132,13 @@ int main(int argc, char **argv) {
    DEBUG = 1; // 这里可能需要更精细地控制 DEBUG 的开启时机和范围
  }
  // 默认优化 pass (在所有优化级别都会执行)
-  SysYOptPre optPre(moduleIR, builder);
-  optPre.SysYOptimizateAfterIR(); 
+  SysYCFGOpt cfgopt(moduleIR, builder);
+  cfgopt.SysYOptimizateAfterIR(); 

-  ControlFlowAnalysis cfa(moduleIR);
-  cfa.init();
-  ActiveVarAnalysis ava;
-  ava.init(moduleIR);
+  // ControlFlowAnalysis cfa(moduleIR);
+  // cfa.init();
+  // ActiveVarAnalysis ava;
+  // ava.init(moduleIR);

  if (DEBUG) {
    cout << "=== After CFA & AVA (Default) ===\n";
@ -174,32 +174,32 @@ int main(int argc, char **argv) {
    // MyCustomOpt2 opt2_pass(moduleIR, builder, &cfa); // 假设需要CFA
    // opt2_pass.run();
    // ... 更多 -O1 特有的优化
-    DeadCodeElimination dce(moduleIR, &cfa, &ava);
-    dce.runDCEPipeline();
-    if (DEBUG) {
-      cout << "=== After 1st DCE (Default) ===\n";
-      SysYPrinter(moduleIR).printIR();
-    }
+    // DeadCodeElimination dce(moduleIR, &cfa, &ava);
+    // dce.runDCEPipeline();
+    // if (DEBUG) {
+    //   cout << "=== After 1st DCE (Default) ===\n";
+    //   SysYPrinter(moduleIR).printIR();
+    // }

-    Mem2Reg mem2reg(moduleIR, builder, &cfa, &ava);
-    mem2reg.mem2regPipeline();
-    if (DEBUG) {
-      cout << "=== After Mem2Reg (Default) ===\n";
-      SysYPrinter(moduleIR).printIR();
-    }
+    // Mem2Reg mem2reg(moduleIR, builder, &cfa, &ava);
+    // mem2reg.mem2regPipeline();
+    // if (DEBUG) {
+    //   cout << "=== After Mem2Reg (Default) ===\n";
+    //   SysYPrinter(moduleIR).printIR();
+    // }

-    Reg2Mem reg2mem(moduleIR, builder);
-    reg2mem.DeletePhiInst();
-    if (DEBUG) {
-      cout << "=== After Reg2Mem (Default) ===\n";
-      SysYPrinter(moduleIR).printIR();
-    }
+    // Reg2Mem reg2mem(moduleIR, builder);
+    // reg2mem.DeletePhiInst();
+    // if (DEBUG) {
+    //   cout << "=== After Reg2Mem (Default) ===\n";
+    //   SysYPrinter(moduleIR).printIR();
+    // }

-    dce.runDCEPipeline(); // 第二次 DCE (默认)
-    if (DEBUG) {
-      cout << "=== After 2nd DCE (Default) ===\n";
-      SysYPrinter(moduleIR).printIR();
-    }
+    // dce.runDCEPipeline(); // 第二次 DCE (默认)
+    // if (DEBUG) {
+    //   cout << "=== After 2nd DCE (Default) ===\n";
+    //   SysYPrinter(moduleIR).printIR();
+    // }
  } else {
    if (DEBUG) cout << "No additional middle-end optimizations applied for -O" << optLevel << ".\n";
  }
--- a/test_script/runit.sh
+++ b/test_script/runit.sh
@ -9,7 +9,7 @@ TESTDATA_DIR="${SCRIPT_DIR}/../testdata"
 BUILD_BIN_DIR="${SCRIPT_DIR}/../build/bin"
 LIB_DIR="${SCRIPT_DIR}/../lib"
 # TMP_DIR="${SCRIPT_DIR}/tmp"
-TMP_DIR="/home/ladev987/paraComp/debug/share_folder/tmp"
+TMP_DIR="${SCRIPT_DIR}/tmp"

 # 定义编译器和模拟器
 SYSYC="${BUILD_BIN_DIR}/sysyc"
Author	SHA1	Message	Date
rain2133	88604c1f94	[IR]消除Falltrhough现象 [IR]优化生成Ret指令逻辑 [README]添加TODO表	2025-07-20 18:23:48 +08:00
rain2133	de696b2b53	[IR]重构数组地址相关指令增加GEP指令以及相关方法新增数组Array Type 删除无用指令(GetSubArray,LA) 删除冗余类定义(Lval) 修复中间代码生成逻辑测试通过所以test目录下的文件 TODO:后端展开数组计算地址仅需要针对GEP指令展开	2025-07-20 15:33:58 +08:00
rain2133	18e7cbd413	Merge branch 'backend' into SCCP	2025-07-20 13:00:15 +08:00
rain2133	20cd16bf52	暂存2	2025-07-20 12:54:19 +08:00
Lixuanwang	80dee78f04	[backend]引入后端pass管理器	2025-07-20 12:45:52 +08:00
Lixuanwang	d7fb017550	Merge branch 'backend-llir' into backend	2025-07-19 18:00:42 +08:00
Lixuanwang	c4b18a70db	[backend]准备合并backend-llir	2025-07-19 17:59:45 +08:00
rain2133	0d5748e9c5	[IR]修复初始化数组指令的逻辑，更新IR常量定义。	2025-07-19 16:18:05 +08:00
rain2133	36cfd2f64d	先将SCCP中重构IR的部分移植到backend	2025-07-19 15:00:04 +08:00
rain2133	8f1e477e73	暂存	2025-07-19 14:23:57 +08:00
rain2133	10b011a1de	[fix]修复部分常量构建，[Pass]建立Pass基类和管理器，预重构优化遍结构	2025-07-18 21:28:36 +08:00
rain2133	34b5a93aaf	[Mem2Reg]重构SSA提升	2025-07-18 18:17:45 +08:00
rain2133	a5d97185e1	[IR]修复IR报错，调整结构。	2025-07-18 18:17:22 +08:00
rain2133	fdc946c1b5	[IR]重构常量定义，引入undefvalue定义，修改常量方法使用尽量适配旧版	2025-07-18 16:40:16 +08:00
rain2133	725da2858d	[IR]指令构造器更新	2025-07-17 21:34:19 +08:00
rain2133	631ef80de2	[IR]phi指令重构，将block信息加入并提供新方法，后续需更改phi相关指令构建逻辑	2025-07-17 19:01:02 +08:00
rain2133	77fae4d662	[CFG]增加分支优化，为SCCP调用做铺垫，预备修改phi定义	2025-07-17 16:50:09 +08:00
rain2133	009f54863e	[CFG]CFG优化方法转换为静态方法，方便其他优化遍调用，TODO：简化条件分支	2025-07-17 15:54:37 +08:00
rain2133	f7e318e623	[SCCP]初步构建SCCP，.cpp仍不完善暂不commit	2025-07-16 22:01:37 +08:00
rain2133	00348c1931	修改CFG优化的文件名，修改phidel标签	2025-07-16 22:01:37 +08:00
rain2133	5a6cfbee1e	[SysYIROptUtils]增加通用优化工具类，修改相关代码	2025-07-16 22:01:37 +08:00