NewGVN: Make sure we don't incorrectly use PredicateInfo when doing PHI of ops

[• dberlin]

Summary

When we backtranslate expressions, we can't use the predicateinfo, since we are evaluating them in a different context.

[• dberlin]

Add testcase

[davide]

llvm/trunk/lib/Transforms/Scalar/NewGVN.cpp

1788 ↗

(On Diff #113573)

Oh, this was where I saw that code.

lib/Transforms/Scalar/NewGVN.cpp

const Expression *NewGVN::performSymbolicCmpEvaluation(Instruction *I) const {
   // See if our operands have predicate info, so that we may be able to derive
   // something from a previous comparison.
   for (const auto &Op : CI->operands()) {
     auto *PI = PredInfo->getPredicateInfoFor(Op);
     if (const auto *PBranch = dyn_cast_or_null<PredicateBranch>(PI)) {
       if (PI == LastPredInfo)
         continue;
       LastPredInfo = PI;
-
-      // TODO: Along the false edge, we may know more things too, like icmp of
+      // In phi of ops cases, we may have predicate info that we are evaluating
+      // in a different context.
+      if (!DT->dominates(PBranch->To, getBlockForValue(I)))
+        continue;
+      // TODO: Along the false edge, we may know more things too, like
+      // icmp of
       // same operands is false.
-      // TODO: We only handle actual comparison conditions below, not and/or.
+      // TODO: We only handle actual comparison conditions below, not
+      // and/or.
       auto *BranchCond = dyn_cast<CmpInst>(PBranch->Condition);
       if (!BranchCond)
         continue;
       auto *BranchOp0 = lookupOperandLeader(BranchCond->getOperand(0));
       auto *BranchOp1 = lookupOperandLeader(BranchCond->getOperand(1));
       auto BranchPredicate = BranchCond->getPredicate();
       if (shouldSwapOperands(BranchOp0, BranchOp1)) {
         std::swap(BranchOp0, BranchOp1);
for (auto PredBB : OpPHI->blocks()) {
           // leader for us or not.
           addAdditionalUsers(Op, I);
         }
         // Make sure it's marked as a temporary instruction.
         AllTempInstructions.insert(ValueOp);
         // and make sure anything that tries to add it's DFS number is
         // redirected to the instruction we are making a phi of ops
         // for.
+        TempToBlock.insert({ValueOp, PredBB});
         InstrDFS.insert({ValueOp, IDFSNum});
         const Expression *E = performSymbolicEvaluation(ValueOp, Visited);
         InstrDFS.erase(ValueOp);
         AllTempInstructions.erase(ValueOp);
         ValueOp->deleteValue();
+        TempToBlock.erase(ValueOp);
         if (MemAccess)
           TempToMemory.erase(ValueOp);
         if (!E)
           return nullptr;
         FoundVal = findPhiOfOpsLeader(E, PredBB);
         if (!FoundVal) {
           ExpressionToPhiOfOps[E].insert(I);
           return nullptr;