#include "Peephole.h"
#include <functional>

namespace sysy {

char PeepholeOptimizer::ID = 0;

bool PeepholeOptimizer::runOnFunction(Function *F, AnalysisManager& AM) {
    // This pass works on MachineFunction level, not IR level
    return false;
}

void PeepholeOptimizer::runOnMachineFunction(MachineFunction *mfunc) {
  if (!mfunc)
    return;
  using namespace sysy;

  // areRegsEqual: 检查两个寄存器操作数是否相等（考虑虚拟和物理寄存器）。
  auto areRegsEqual = [](RegOperand *r1, RegOperand *r2) {
    if (!r1 || !r2 || r1->isVirtual() != r2->isVirtual()) {
      return false;
    }
    if (r1->isVirtual()) {
      return r1->getVRegNum() == r2->getVRegNum();
    } else {
      return r1->getPReg() == r2->getPReg();
    }
  };

  // 改进的 isRegUsedLater 函数 - 更完整和准确的实现
  auto isRegUsedLater =
      [&](const std::vector<std::unique_ptr<MachineInstr>> &instrs,
          RegOperand *reg, size_t start_idx) -> bool {
    for (size_t j = start_idx; j < instrs.size(); ++j) {
      auto *instr = instrs[j].get();
      auto opcode = instr->getOpcode();

      // 检查所有操作数
      for (size_t k = 0; k < instr->getOperands().size(); ++k) {
        bool isDefOperand = false;

        // 更完整的定义操作数判断逻辑
        if (k == 0) { // 第一个操作数通常是目标寄存器
          switch (opcode) {
          // 算术和逻辑指令 - 第一个操作数是定义
          case RVOpcodes::MV:
          case RVOpcodes::ADDI:
          case RVOpcodes::SLLI:
          case RVOpcodes::SRLI:
          case RVOpcodes::SRAI:
          case RVOpcodes::SLTI:
          case RVOpcodes::SLTIU:
          case RVOpcodes::XORI:
          case RVOpcodes::ORI:
          case RVOpcodes::ANDI:
          case RVOpcodes::ADD:
          case RVOpcodes::SUB:
          case RVOpcodes::SLL:
          case RVOpcodes::SLT:
          case RVOpcodes::SLTU:
          case RVOpcodes::XOR:
          case RVOpcodes::SRL:
          case RVOpcodes::SRA:
          case RVOpcodes::OR:
          case RVOpcodes::AND:
          case RVOpcodes::MUL:
          case RVOpcodes::DIV:
          case RVOpcodes::REM:
          case RVOpcodes::LW:
          case RVOpcodes::LH:
          case RVOpcodes::LB:
          case RVOpcodes::LHU:
          case RVOpcodes::LBU:

          // 存储指令 - 第一个操作数是使用（要存储的值）
          case RVOpcodes::SW:
          case RVOpcodes::SH:
          case RVOpcodes::SB:
          // 分支指令 - 第一个操作数是使用
          case RVOpcodes::BEQ:
          case RVOpcodes::BNE:
          case RVOpcodes::BLT:
          case RVOpcodes::BGE:
          case RVOpcodes::BLTU:
          case RVOpcodes::BGEU:
          // 跳转指令 - 可能使用寄存器
          case RVOpcodes::JALR:
            isDefOperand = false;
            break;

          default:
            // 对于未知指令，保守地假设第一个操作数可能是使用
            isDefOperand = false;
            break;
          }
        }

        // 如果不是定义操作数，检查是否使用了目标寄存器
        if (!isDefOperand) {
          if (instr->getOperands()[k]->getKind() == MachineOperand::KIND_REG) {
            auto *use_reg =
                static_cast<RegOperand *>(instr->getOperands()[k].get());
            if (areRegsEqual(reg, use_reg))
              return true;
          }
          // 检查内存操作数中的基址寄存器
          if (instr->getOperands()[k]->getKind() == MachineOperand::KIND_MEM) {
            auto *mem =
                static_cast<MemOperand *>(instr->getOperands()[k].get());
            if (areRegsEqual(reg, mem->getBase()))
              return true;
          }
        }
      }
    }
    return false;
  };

  // 检查寄存器是否在指令中被重新定义（用于更精确的分析）
  auto isRegRedefinedAt =
      [](MachineInstr *instr, RegOperand *reg,
         const std::function<bool(RegOperand *, RegOperand *)> &areRegsEqual)
      -> bool {
    if (instr->getOperands().empty())
      return false;

    auto opcode = instr->getOpcode();
    // 只有当第一个操作数是定义操作数时才检查
    switch (opcode) {
    case RVOpcodes::MV:
    case RVOpcodes::ADDI:
    case RVOpcodes::ADD:
    case RVOpcodes::SUB:
    case RVOpcodes::MUL:
    case RVOpcodes::LW:
      // ... 其他定义指令
      if (instr->getOperands()[0]->getKind() == MachineOperand::KIND_REG) {
        auto *def_reg =
            static_cast<RegOperand *>(instr->getOperands()[0].get());
        return areRegsEqual(reg, def_reg);
      }
      break;
    default:
      break;
    }
    return false;
  };

  // 检查是否为存储-加载模式，支持不同大小的访问
  auto isStoreLoadPattern = [](MachineInstr *store_instr,
                               MachineInstr *load_instr) -> bool {
    auto store_op = store_instr->getOpcode();
    auto load_op = load_instr->getOpcode();

    // 检查存储-加载对应关系
    return (store_op == RVOpcodes::SW && load_op == RVOpcodes::LW) || // 32位
           (store_op == RVOpcodes::SH &&
            load_op == RVOpcodes::LH) || // 16位有符号
           (store_op == RVOpcodes::SH &&
            load_op == RVOpcodes::LHU) || // 16位无符号
           (store_op == RVOpcodes::SB &&
            load_op == RVOpcodes::LB) || // 8位有符号
           (store_op == RVOpcodes::SB &&
            load_op == RVOpcodes::LBU) ||                           // 8位无符号
           (store_op == RVOpcodes::SD && load_op == RVOpcodes::LD); // 64位
  };

  // 检查两个内存访问是否访问相同的内存位置
  auto areMemoryAccessesEqual =
      [&areRegsEqual](MachineInstr *store_instr, MemOperand *store_mem,
                      MachineInstr *load_instr, MemOperand *load_mem) -> bool {
    // 基址寄存器必须相同
    if (!areRegsEqual(store_mem->getBase(), load_mem->getBase())) {
      return false;
    }

    // 偏移量必须相同
    if (store_mem->getOffset()->getValue() !=
        load_mem->getOffset()->getValue()) {
      return false;
    }

    // 检查访问大小是否兼容
    auto store_op = store_instr->getOpcode();
    auto load_op = load_instr->getOpcode();

    // 获取访问大小（字节数）
    auto getAccessSize = [](RVOpcodes opcode) -> int {
      switch (opcode) {
      case RVOpcodes::LB:
      case RVOpcodes::LBU:
      case RVOpcodes::SB:
        return 1; // 8位
      case RVOpcodes::LH:
      case RVOpcodes::LHU:
      case RVOpcodes::SH:
        return 2; // 16位
      case RVOpcodes::LW:
      case RVOpcodes::SW:
        return 4; // 32位
      case RVOpcodes::LD:
      case RVOpcodes::SD:
        return 8; // 64位
      default:
        return -1; // 未知
      }
    };

    int store_size = getAccessSize(store_op);
    int load_size = getAccessSize(load_op);

    // 只有访问大小完全匹配时才能进行优化
    // 这避免了部分重叠访问的复杂情况
    return store_size > 0 && store_size == load_size;
  };

  // 简单的内存别名分析：检查两个内存访问之间是否可能有冲突的内存操作
  auto isMemoryAccessSafe =
      [&](const std::vector<std::unique_ptr<MachineInstr>> &instrs,
          size_t store_idx, size_t load_idx, MemOperand *mem) -> bool {
    // 检查存储和加载之间是否有可能影响内存的指令
    for (size_t j = store_idx + 1; j < load_idx; ++j) {
      auto *between_instr = instrs[j].get();
      auto between_op = between_instr->getOpcode();

      // 检查是否有其他内存写入操作
      switch (between_op) {
      case RVOpcodes::SW:
      case RVOpcodes::SH:
      case RVOpcodes::SB:
      case RVOpcodes::SD: {
        // 如果有其他存储操作，需要检查是否可能访问相同的内存
        if (between_instr->getOperands().size() >= 2 &&
            between_instr->getOperands()[1]->getKind() ==
                MachineOperand::KIND_MEM) {

          auto *other_mem =
              static_cast<MemOperand *>(between_instr->getOperands()[1].get());

          // 保守的别名分析：如果使用不同的基址寄存器，假设可能别名
          if (!areRegsEqual(mem->getBase(), other_mem->getBase())) {
            return false; // 可能的别名，不安全
          }

          // 如果基址相同但偏移量不同，检查是否重叠
          int64_t offset1 = mem->getOffset()->getValue();
          int64_t offset2 = other_mem->getOffset()->getValue();

          // 获取访问大小来检查重叠
          auto getAccessSize = [](RVOpcodes opcode) -> int {
            switch (opcode) {
            case RVOpcodes::SB:
              return 1;
            case RVOpcodes::SH:
              return 2;
            case RVOpcodes::SW:
              return 4;
            case RVOpcodes::SD:
              return 8;
            default:
              return 4; // 默认假设4字节
            }
          };

          int size1 = getAccessSize(RVOpcodes::SW); // 从原存储指令推断
          int size2 = getAccessSize(between_op);

          // 检查内存区域是否重叠
          bool overlaps =
              !(offset1 + size1 <= offset2 || offset2 + size2 <= offset1);
          if (overlaps) {
            return false; // 内存重叠，不安全
          }
        }
        break;
      }

      // 函数调用可能有副作用
      case RVOpcodes::JAL:
      case RVOpcodes::JALR:
        return false; // 函数调用可能修改内存，不安全

      // 原子操作或其他可能修改内存的指令
      // 根据具体的RISC-V扩展添加更多指令
      default:
        // 对于未知指令，采用保守策略
        // 可以根据具体需求调整
        break;
      }
    }

    return true; // 没有发现潜在的内存冲突
  };

  // isPowerOfTwo: 检查数值是否为2的幂次，并返回其指数。
  auto isPowerOfTwo = [](int64_t n) -> int {
    if (n <= 0 || (n & (n - 1)) != 0)
      return -1;
    int shift = 0;
    while (n > 1) {
      n >>= 1;
      shift++;
    }
    return shift;
  };

  for (auto &mbb_uptr : mfunc->getBlocks()) {
    auto &mbb = *mbb_uptr;
    auto &instrs = mbb.getInstructions();
    if (instrs.size() < 2)
      continue; // 基本块至少需要两条指令进行窥孔

    // 遍历指令序列进行窥孔优化
    for (size_t i = 0; i + 1 < instrs.size();) {
      auto *mi1 = instrs[i].get();
      auto *mi2 = instrs[i + 1].get();
      bool changed = false;

      // 1. 消除冗余交换移动: mv a, b; mv b, a  -> mv a, b
      if (mi1->getOpcode() == RVOpcodes::MV &&
          mi2->getOpcode() == RVOpcodes::MV) {
        if (mi1->getOperands().size() == 2 && mi2->getOperands().size() == 2) {
          if (mi1->getOperands()[0]->getKind() == MachineOperand::KIND_REG &&
              mi1->getOperands()[1]->getKind() == MachineOperand::KIND_REG &&
              mi2->getOperands()[0]->getKind() == MachineOperand::KIND_REG &&
              mi2->getOperands()[1]->getKind() == MachineOperand::KIND_REG) {
            auto *dst1 = static_cast<RegOperand *>(mi1->getOperands()[0].get());
            auto *src1 = static_cast<RegOperand *>(mi1->getOperands()[1].get());
            auto *dst2 = static_cast<RegOperand *>(mi2->getOperands()[0].get());
            auto *src2 = static_cast<RegOperand *>(mi2->getOperands()[1].get());
            if (areRegsEqual(dst1, src2) && areRegsEqual(src1, dst2)) {
              instrs.erase(instrs.begin() + i + 1); // 移除第二条指令
              changed = true;
            }
          }
        }
      }
      // 2. 冗余加载消除: sw t0, offset(base); lw t1, offset(base) -> 替换或消除
      // lw 添加ld sd支持
      else if (isStoreLoadPattern(mi1, mi2)) {
        if (mi1->getOperands().size() == 2 && mi2->getOperands().size() == 2) {
          if (mi1->getOperands()[0]->getKind() == MachineOperand::KIND_REG &&
              mi1->getOperands()[1]->getKind() == MachineOperand::KIND_MEM &&
              mi2->getOperands()[0]->getKind() == MachineOperand::KIND_REG &&
              mi2->getOperands()[1]->getKind() == MachineOperand::KIND_MEM) {

            auto *store_val =
                static_cast<RegOperand *>(mi1->getOperands()[0].get());
            auto *store_mem =
                static_cast<MemOperand *>(mi1->getOperands()[1].get());
            auto *load_val =
                static_cast<RegOperand *>(mi2->getOperands()[0].get());
            auto *load_mem =
                static_cast<MemOperand *>(mi2->getOperands()[1].get());

            // 检查内存访问是否匹配（基址、偏移量和访问大小）
            if (areMemoryAccessesEqual(mi1, store_mem, mi2, load_mem)) {
              // 进行简单的内存别名分析
              if (isMemoryAccessSafe(instrs, i, i + 1, store_mem)) {
                if (areRegsEqual(store_val, load_val)) {
                  // sw r1, mem; lw r1, mem -> 消除冗余的lw
                  instrs.erase(instrs.begin() + i + 1);
                  changed = true;
                } else {
                  // sw r1, mem; lw r2, mem -> 替换lw为mv r2, r1
                  auto newInstr = std::make_unique<MachineInstr>(RVOpcodes::MV);
                  newInstr->addOperand(std::make_unique<RegOperand>(*load_val));
                  newInstr->addOperand(
                      std::make_unique<RegOperand>(*store_val));
                  instrs[i + 1] = std::move(newInstr);
                  changed = true;
                }
              }
            }
          }
        }
      }
      // 3. 强度削减: mul y, x, 2^n -> slli y, x, n
      else if (mi1->getOpcode() == RVOpcodes::MUL &&
               mi1->getOperands().size() == 3) {
        auto *dst_op = mi1->getOperands()[0].get();
        auto *src1_op = mi1->getOperands()[1].get();
        auto *src2_op = mi1->getOperands()[2].get();

        if (dst_op->getKind() == MachineOperand::KIND_REG) {
          auto *dst_reg = static_cast<RegOperand *>(dst_op);
          RegOperand *src_reg = nullptr;
          int shift = -1;

          if (src1_op->getKind() == MachineOperand::KIND_REG &&
              src2_op->getKind() == MachineOperand::KIND_IMM) {
            shift =
                isPowerOfTwo(static_cast<ImmOperand *>(src2_op)->getValue());
            if (shift >= 0)
              src_reg = static_cast<RegOperand *>(src1_op);
          } else if (src1_op->getKind() == MachineOperand::KIND_IMM &&
                     src2_op->getKind() == MachineOperand::KIND_REG) {
            shift =
                isPowerOfTwo(static_cast<ImmOperand *>(src1_op)->getValue());
            if (shift >= 0)
              src_reg = static_cast<RegOperand *>(src2_op);
          }

          if (src_reg && shift >= 0 &&
              shift <= 31) { // RISC-V 移位量限制 (0-31)
            auto newInstr = std::make_unique<MachineInstr>(RVOpcodes::SLLI);
            newInstr->addOperand(std::make_unique<RegOperand>(*dst_reg));
            newInstr->addOperand(std::make_unique<RegOperand>(*src_reg));
            newInstr->addOperand(std::make_unique<ImmOperand>(shift));
            instrs[i] = std::move(newInstr);
            changed = true;
          }
        }
      }
      // 4. 地址计算优化: addi dst, base, imm1; lw/sw val, imm2(dst) -> lw/sw
      // val, (imm1+imm2)(base)
      else if (mi1->getOpcode() == RVOpcodes::ADDI &&
               mi1->getOperands().size() == 3) {
        auto opcode2 = mi2->getOpcode();
        if (opcode2 == RVOpcodes::LW || opcode2 == RVOpcodes::SW) {
          if (mi2->getOperands().size() == 2 &&
              mi2->getOperands()[1]->getKind() == MachineOperand::KIND_MEM &&
              mi1->getOperands()[0]->getKind() == MachineOperand::KIND_REG &&
              mi1->getOperands()[1]->getKind() == MachineOperand::KIND_REG &&
              mi1->getOperands()[2]->getKind() == MachineOperand::KIND_IMM) {

            auto *addi_dst =
                static_cast<RegOperand *>(mi1->getOperands()[0].get());
            auto *addi_base =
                static_cast<RegOperand *>(mi1->getOperands()[1].get());
            auto *addi_imm =
                static_cast<ImmOperand *>(mi1->getOperands()[2].get());

            auto *mem_op =
                static_cast<MemOperand *>(mi2->getOperands()[1].get());
            auto *mem_base = mem_op->getBase();
            auto *mem_imm = mem_op->getOffset();

            // 检查 ADDI 的目标寄存器是否是内存操作的基址
            if (areRegsEqual(addi_dst, mem_base)) {
              // 改进的使用检查：考虑寄存器可能在后续被重新定义的情况
              bool canOptimize = true;

              // 检查从 i+2 开始的指令
              for (size_t j = i + 2; j < instrs.size(); ++j) {
                auto *later_instr = instrs[j].get();

                // 如果寄存器被重新定义，那么它后面的使用就不相关了
                if (isRegRedefinedAt(later_instr, addi_dst, areRegsEqual)) {
                  break; // 寄存器被重新定义，可以安全优化
                }

                // 如果寄存器被使用，则不能优化
                if (isRegUsedLater(instrs, addi_dst, j)) {
                  canOptimize = false;
                  break;
                }
              }

              if (canOptimize) {
                int64_t new_offset = addi_imm->getValue() + mem_imm->getValue();
                // 检查新偏移量是否符合 RISC-V 12位有符号立即数范围
                if (new_offset >= -2048 && new_offset <= 2047) {
                  auto new_mem_op = std::make_unique<MemOperand>(
                      std::make_unique<RegOperand>(*addi_base),
                      std::make_unique<ImmOperand>(new_offset));
                  mi2->getOperands()[1] = std::move(new_mem_op);
                  instrs.erase(instrs.begin() + i);
                  changed = true;
                }
              }
            }
          }
        }
      }
      // 5. 冗余移动指令消除: mv x, y; op z, x, ... -> op z, y, ... (如果 x
      // 之后不再使用)
      else if (mi1->getOpcode() == RVOpcodes::MV &&
               mi1->getOperands().size() == 2) {
        if (mi1->getOperands()[0]->getKind() == MachineOperand::KIND_REG &&
            mi1->getOperands()[1]->getKind() == MachineOperand::KIND_REG) {

          auto *mv_dst = static_cast<RegOperand *>(mi1->getOperands()[0].get());
          auto *mv_src = static_cast<RegOperand *>(mi1->getOperands()[1].get());

          // 检查第二条指令是否使用了 mv 的目标寄存器
          std::vector<size_t> use_positions;
          for (size_t k = 1; k < mi2->getOperands().size(); ++k) {
            if (mi2->getOperands()[k]->getKind() == MachineOperand::KIND_REG) {
              auto *use_reg =
                  static_cast<RegOperand *>(mi2->getOperands()[k].get());
              if (areRegsEqual(mv_dst, use_reg)) {
                use_positions.push_back(k);
              }
            }
            // 也检查内存操作数中的基址寄存器
            else if (mi2->getOperands()[k]->getKind() ==
                     MachineOperand::KIND_MEM) {
              auto *mem =
                  static_cast<MemOperand *>(mi2->getOperands()[k].get());
              if (areRegsEqual(mv_dst, mem->getBase())) {
                // 对于内存操作数，我们需要创建新的MemOperand
                auto new_mem = std::make_unique<MemOperand>(
                    std::make_unique<RegOperand>(*mv_src),
                    std::make_unique<ImmOperand>(mem->getOffset()->getValue()));
                mi2->getOperands()[k] = std::move(new_mem);
                use_positions.push_back(k); // 标记已处理
              }
            }
          }

          if (!use_positions.empty()) {
            // 改进的后续使用检查
            bool canOptimize = true;
            for (size_t j = i + 2; j < instrs.size(); ++j) {
              auto *later_instr = instrs[j].get();

              // 如果寄存器被重新定义，后续使用就不相关了
              if (isRegRedefinedAt(later_instr, mv_dst, areRegsEqual)) {
                break;
              }

              // 检查是否还有其他使用
              if (isRegUsedLater(instrs, mv_dst, j)) {
                canOptimize = false;
                break;
              }
            }

            if (canOptimize) {
              // 替换所有寄存器使用（内存操作数已在上面处理）
              for (size_t pos : use_positions) {
                if (mi2->getOperands()[pos]->getKind() ==
                    MachineOperand::KIND_REG) {
                  mi2->getOperands()[pos] =
                      std::make_unique<RegOperand>(*mv_src);
                }
              }
              instrs.erase(instrs.begin() + i);
              changed = true;
            }
          }
        }
      }
      // 6. 连续加法指令合并: addi t1, t0, imm1; addi t2, t1, imm2 -> addi t2,
      // t0, (imm1+imm2)
      else if (mi1->getOpcode() == RVOpcodes::ADDI &&
               mi2->getOpcode() == RVOpcodes::ADDI) {
        if (mi1->getOperands().size() == 3 && mi2->getOperands().size() == 3) {
          if (mi1->getOperands()[0]->getKind() == MachineOperand::KIND_REG &&
              mi1->getOperands()[1]->getKind() == MachineOperand::KIND_REG &&
              mi1->getOperands()[2]->getKind() == MachineOperand::KIND_IMM &&
              mi2->getOperands()[0]->getKind() == MachineOperand::KIND_REG &&
              mi2->getOperands()[1]->getKind() == MachineOperand::KIND_REG &&
              mi2->getOperands()[2]->getKind() == MachineOperand::KIND_IMM) {

            auto *addi1_dst =
                static_cast<RegOperand *>(mi1->getOperands()[0].get());
            auto *addi1_src =
                static_cast<RegOperand *>(mi1->getOperands()[1].get());
            auto *addi1_imm =
                static_cast<ImmOperand *>(mi1->getOperands()[2].get());

            auto *addi2_dst =
                static_cast<RegOperand *>(mi2->getOperands()[0].get());
            auto *addi2_src =
                static_cast<RegOperand *>(mi2->getOperands()[1].get());
            auto *addi2_imm =
                static_cast<ImmOperand *>(mi2->getOperands()[2].get());

            // 检查第一个ADDI的目标是否是第二个ADDI的源
            if (areRegsEqual(addi1_dst, addi2_src)) {
              // 改进的中间寄存器使用检查
              bool canOptimize = true;
              for (size_t j = i + 2; j < instrs.size(); ++j) {
                auto *later_instr = instrs[j].get();

                // 如果中间寄存器被重新定义，后续使用不相关
                if (isRegRedefinedAt(later_instr, addi1_dst, areRegsEqual)) {
                  break;
                }

                // 检查是否有其他使用
                if (isRegUsedLater(instrs, addi1_dst, j)) {
                  canOptimize = false;
                  break;
                }
              }

              if (canOptimize) {
                int64_t new_imm = addi1_imm->getValue() + addi2_imm->getValue();
                // 检查新立即数范围
                if (new_imm >= -2048 && new_imm <= 2047) {
                  auto newInstr =
                      std::make_unique<MachineInstr>(RVOpcodes::ADDI);
                  newInstr->addOperand(
                      std::make_unique<RegOperand>(*addi2_dst));
                  newInstr->addOperand(
                      std::make_unique<RegOperand>(*addi1_src));
                  newInstr->addOperand(std::make_unique<ImmOperand>(new_imm));
                  instrs[i + 1] = std::move(newInstr);
                  instrs.erase(instrs.begin() + i);
                  changed = true;
                }
              }
            }
          }
        }
      }

      // 7. ADD with zero optimization: add r1, r2, zero -> mv r1, r2
      else if (mi1->getOpcode() == RVOpcodes::ADD &&
               mi1->getOperands().size() == 3) {
        if (mi1->getOperands()[0]->getKind() == MachineOperand::KIND_REG &&
            mi1->getOperands()[1]->getKind() == MachineOperand::KIND_REG &&
            mi1->getOperands()[2]->getKind() == MachineOperand::KIND_REG) {

          auto *add_dst =
              static_cast<RegOperand *>(mi1->getOperands()[0].get());
          auto *add_src1 =
              static_cast<RegOperand *>(mi1->getOperands()[1].get());
          auto *add_src2 =
              static_cast<RegOperand *>(mi1->getOperands()[2].get());

          // 检查第二个源操作数是否为ZERO寄存器
          if (!add_src2->isVirtual() &&
              add_src2->getPReg() == PhysicalReg::ZERO) {
            // 创建新的 MV 指令
            auto newInstr = std::make_unique<MachineInstr>(RVOpcodes::MV);
            newInstr->addOperand(std::make_unique<RegOperand>(*add_dst));
            newInstr->addOperand(std::make_unique<RegOperand>(*add_src1));
            instrs[i] = std::move(newInstr);
            changed = true;
          }
        }
      }

      // 根据是否发生变化调整遍历索引
      if (!changed) {
        ++i; // 没有优化，继续检查下一对指令
      } else {
        // 发生变化，适当回退以捕获新的优化机会。
        // 这是一种安全的回退策略，可以触发连锁优化，且不会导致无限循环。
        if (i > 0) {
          --i;
        }
      }
    }
  }
}

} // namespace sysy