LLVM中如何将循环PHINode的操作数类型从32位修改为64位

• 滥用mutateType修改操作数类型：mutateType会直接修改目标Value自身的类型，你遍历指令所有操作数时，会误修改全局共享的常量（比如常量1）的类型，导致所有引用该常量的无关指令（比如你提到的%add7）的操作数类型被意外修改，出现操作数类型不匹配的错误。
• 遍历逻辑错误：你没有沿着目标PHI的use-def链精准遍历，而是修改了目标指令的所有操作数，不管操作数是否和要修改的循环IV相关；且只递归了两层用户，没有覆盖完整的引用链，容易出现遗漏。
• 未处理PHI入参的类型匹配问题：PHI节点要求所有入参的类型和自身类型一致，你的修改逻辑没有针对性处理PHI每个入参的类型，而是盲目改所有操作数的类型，很容易破坏IR的类型一致性。
• mutateType本身不适用于这类场景：这个API是底层修改接口，直接改值类型会破坏整个IR的类型系统约束，正确的类型转换应该通过创建新的同语义不同类型的指令、替换旧引用来实现，而不是直接修改原有值的类型。

你可以按照以下步骤实现IV类型的安全转换：

1. 先获取目标32位循环IV的PHINode，在同位置创建一个新的i64类型的PHINode，继承原PHI的所有入参来源。
2. 初始化新PHI的入参：对每个入参，如果是常量，直接创建对应值的i64常量；如果是指令值，先临时占位，后续处理完对应指令后再补全。
3. 沿着原PHI的use-def链递归遍历所有引用：
   • 对add类的IV增量指令：创建新的i64类型的add指令，操作数替换为对应64位的值，继承原指令的所有元数据（比如nuw/nsw标记）。
   • 对icmp类的循环退出判断指令：创建新的i64类型的icmp指令，两个操作数都替换为对应64位的值。
   • 对其他引用了32位IV的指令：如果需要保留32位运算，插入trunc指令把64位IV截断为32位；如果是IV相关的运算，统一替换为64位版本。
4. 用新的64位指令替换所有旧的32位指令的引用，之后删除旧的32位PHI、旧的32位运算指令。
5. 最后验证整个循环的IR类型一致，没有操作数类型不匹配的错误。

static void ChangePHINodeWidthTo64(Loop *OuterLoop, ScalarEvolution *SE) {
  PHINode *OldPHI = OuterLoop->getInductionVariable(*SE);
  if (!OldPHI || OldPHI->getType()->getIntegerBitWidth() != 32)
    return;
  
  LLVMContext &Ctx = OldPHI->getContext();
  Type *I64Ty = Type::getInt64Ty(Ctx);
  
  // 第一步：创建新的64位PHI
  PHINode *NewPHI = PHINode::Create(I64Ty, OldPHI->getNumIncomingValues(), 
                                    OldPHI->getName(), OldPHI);
  // 先填常量入参
  for (unsigned i = 0; i < OldPHI->getNumIncomingValues(); ++i) {
    Value *InVal = OldPHI->getIncomingValue(i);
    BasicBlock *InBB = OldPHI->getIncomingBlock(i);
    if (ConstantInt *CI = dyn_cast<ConstantInt>(InVal)) {
      NewPHI->addIncoming(ConstantInt::get(I64Ty, CI->getSExtValue()), InBB);
    } else {
      // 指令入参后面处理，先占位
      NewPHI->addIncoming(UndefValue::get(I64Ty), InBB);
    }
  }

  // 第二步：遍历OldPHI的所有用户处理
  DenseMap<Value*, Value*> OldToNewMap;
  OldToNewMap[OldPHI] = NewPHI;

  SmallVector<Instruction*, 8> Worklist;
  for (User *U : OldPHI->users()) {
    Worklist.push_back(cast<Instruction>(U));
  }

  while (!Worklist.empty()) {
    Instruction *OldInst = Worklist.pop_back_val();
    if (OldToNewMap.count(OldInst))
      continue;

    // 处理add指令（比如%inc16）
    if (BinaryOperator *BO = dyn_cast<BinaryOperator>(OldInst)) {
      if (BO->getOpcode() == Instruction::Add) {
        Value *LHS = BO->getOperand(0);
        Value *RHS = BO->getOperand(1);
        // 替换操作数为64位版本
        if (OldToNewMap.count(LHS))
          LHS = OldToNewMap[LHS];
        if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS))
          RHS = ConstantInt::get(I64Ty, CI->getSExtValue());
        
        BinaryOperator *NewBO = BinaryOperator::Create(BO->getOpcode(), LHS, RHS, 
                                                      BO->getName(), OldInst);
        NewBO->copyIRFlags(BO);
        OldToNewMap[OldInst] = NewBO;
        // 把这个新指令的用户加入工作队列
        for (User *U : OldInst->users())
          Worklist.push_back(cast<Instruction>(U));
        continue;
      }
    }

    // 处理icmp指令
    if (ICmpInst *CI = dyn_cast<ICmpInst>(OldInst)) {
      Value *LHS = CI->getOperand(0);
      Value *RHS = CI->getOperand(1);
      if (OldToNewMap.count(LHS))
        LHS = OldToNewMap[LHS];
      if (ConstantInt *C = dyn_cast<ConstantInt>(RHS))
        RHS = ConstantInt::get(I64Ty, C->getSExtValue());
      
      ICmpInst *NewCI = new ICmpInst(OldInst, CI->getPredicate(), LHS, RHS);
      OldToNewMap[OldInst] = NewCI;
      for (User *U : OldInst->users())
        Worklist.push_back(cast<Instruction>(U));
      continue;
    }

    // 处理br指令的操作数，不需要改br本身，只要替换操作数就行
    if (BranchInst *BI = dyn_cast<BranchInst>(OldInst)) {
      for (unsigned i = 0; i < BI->getNumOperands(); ++i) {
        if (OldToNewMap.count(BI->getOperand(i)))
          BI->setOperand(i, OldToNewMap[BI->getOperand(i)]);
      }
      continue;
    }
  }

  // 第三步：补全新PHI的指令入参
  for (unsigned i = 0; i < NewPHI->getNumIncomingValues(); ++i) {
    Value *OldInVal = OldPHI->getIncomingValue(i);
    if (OldToNewMap.count(OldInVal)) {
      NewPHI->setIncomingValue(i, OldToNewMap[OldInVal]);
    }
  }

  // 第四步：替换所有引用，删除旧指令
  OldPHI->replaceAllUsesWith(NewPHI);
  for (auto &Pair : OldToNewMap) {
    if (Instruction *OldI = dyn_cast<Instruction>(Pair.first)) {
      OldI->replaceAllUsesWith(Pair.second);
      OldI->eraseFromParent();
    }
  }
  OldPHI->eraseFromParent();
}

以上是最简实现示例，你可以根据自己的场景扩展支持更多指令类型，遇到非IV相关的32位引用可以插入trunc指令做类型转换保证IR合法性。

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