Unreachable code RAUW from UndefValue to PoisonValue [NFC]

[ManuelJBrito]

Summary

Replacing the following instances of UndefValue with PoisonValue, where the UndefValue is used as an arbitrary value.

llvm/lib/Transforms/Utils/ScalarEvolutionExpander.cpp

• @cleanup if the result is not used then the inserted instructions are removed, RAUW arbitrary value

llvm/lib/Transforms/Utils/BasicBlockUtils.cpp

• @FoldSingleEntryPHINodes when we have a self referential single entry phi node, RAUW arbitrary value

llvm/lib/Transforms/Utils/CallGraphUpdater.cpp

• @finalize Remove all references to removed functions RAUW arbitrary value

llvm/tools/bugpoint/CrashDebugger.cpp

• @TestInts the program is cloned and instructions are removed to narrow down source of crash, RAUW arbitrary value

llvm/lib/CodeGen/WinEHPrepare.cpp

• @demotePHIsOnFunclets RAUW arbitrary value for lingering uses of removed PHI nodes

llvm/lib/CodeGen/WinEHPrepare.cpp

for (Instruction &I : make_early_inc_range(BB)) {
         insertPHIStores(PN, SpillSlot);
 
       PHINodes.push_back(PN);
     }
   }
 
   for (auto *PN : PHINodes) {
     // There may be lingering uses on other EH PHIs being removed
-    PN->replaceAllUsesWith(UndefValue::get(PN->getType()));
+    PN->replaceAllUsesWith(PoisonValue::get(PN->getType()));
     PN->eraseFromParent();
   }
 }
 
 void WinEHPrepare::cloneCommonBlocks(Function &F) {
   // We need to clone all blocks which belong to multiple funclets.  Values are
   // remapped throughout the funclet to propagate both the new instructions
   // *and* the new basic blocks themselves.

llvm/lib/Transforms/Utils/BasicBlockUtils.cpp

bool llvm::FoldSingleEntryPHINodes(BasicBlock *BB,
                                    MemoryDependenceResults *MemDep) {
   if (!isa<PHINode>(BB->begin()))
     return false;
 
   while (PHINode *PN = dyn_cast<PHINode>(BB->begin())) {
     if (PN->getIncomingValue(0) != PN)
       PN->replaceAllUsesWith(PN->getIncomingValue(0));
     else
-      PN->replaceAllUsesWith(UndefValue::get(PN->getType()));
+      PN->replaceAllUsesWith(PoisonValue::get(PN->getType()));
 
     if (MemDep)
       MemDep->removeInstruction(PN);  // Memdep updates AA itself.
 
     PN->eraseFromParent();
   }
   return true;
 }

llvm/lib/Transforms/Utils/CallGraphUpdater.cpp

bool CallGraphUpdater::finalize() {
   if (CG) {
     // First remove all references, e.g., outgoing via called functions. This is
     // necessary as we can delete functions that have circular references.
     for (Function *DeadFn : DeadFunctions) {
       DeadFn->removeDeadConstantUsers();
       CallGraphNode *DeadCGN = (*CG)[DeadFn];
       DeadCGN->removeAllCalledFunctions();
       CG->getExternalCallingNode()->removeAnyCallEdgeTo(DeadCGN);
-      DeadFn->replaceAllUsesWith(UndefValue::get(DeadFn->getType()));
+      DeadFn->replaceAllUsesWith(PoisonValue::get(DeadFn->getType()));
     }
 
     // Then remove the node and function from the module.
     for (Function *DeadFn : DeadFunctions) {
       CallGraphNode *DeadCGN = CG->getOrInsertFunction(DeadFn);
       assert(DeadCGN->getNumReferences() == 0 &&
              "References should have been handled by now");
       delete CG->removeFunctionFromModule(DeadCGN);
     }
   } else {
     // This is the code path for the new lazy call graph and for the case were
     // no call graph was provided.
     for (Function *DeadFn : DeadFunctions) {
       DeadFn->removeDeadConstantUsers();
-      DeadFn->replaceAllUsesWith(UndefValue::get(DeadFn->getType()));
+      DeadFn->replaceAllUsesWith(PoisonValue::get(DeadFn->getType()));
 
       if (LCG && !ReplacedFunctions.count(DeadFn)) {
         // Taken mostly from the inliner:
         LazyCallGraph::Node &N = LCG->get(*DeadFn);
         auto *DeadSCC = LCG->lookupSCC(N);
         assert(DeadSCC && DeadSCC->size() == 1 &&
                &DeadSCC->begin()->getFunction() == DeadFn);
         auto &DeadRC = DeadSCC->getOuterRefSCC();

llvm/lib/Transforms/Utils/ScalarEvolutionExpander.cpp

assert(all_of(I->users(),
                   [&InsertedSet](Value *U) {
                     return InsertedSet.contains(cast<Instruction>(U));
                   }) &&
            "removed instruction should only be used by instructions inserted "
            "during expansion");
 #endif
     assert(!I->getType()->isVoidTy() &&
            "inserted instruction should have non-void types");
-    I->replaceAllUsesWith(UndefValue::get(I->getType()));
+    I->replaceAllUsesWith(PoisonValue::get(I->getType()));
     I->eraseFromParent();
   }
 }

llvm/tools/bugpoint/CrashDebugger.cpp

bool ReduceCrashingInstructions::TestInsts(
 
   for (Module::iterator MI = M->begin(), ME = M->end(); MI != ME; ++MI)
     for (Function::iterator FI = MI->begin(), FE = MI->end(); FI != FE; ++FI)
       for (Instruction &Inst : llvm::make_early_inc_range(*FI)) {
         if (!Instructions.count(&Inst) && !Inst.isTerminator() &&
             !Inst.isEHPad() && !Inst.getType()->isTokenTy() &&
             !Inst.isSwiftError()) {
           if (!Inst.getType()->isVoidTy())
-            Inst.replaceAllUsesWith(UndefValue::get(Inst.getType()));
+            Inst.replaceAllUsesWith(PoisonValue::get(Inst.getType()));
           Inst.eraseFromParent();
         }
       }
 
   // Verify that this is still valid.
   legacy::PassManager Passes;
   Passes.add(createVerifierPass(/*FatalErrors=*/false));
   Passes.run(*M);