Track visited PHI nodes

this fixes the hang in cam4.

Author: c-rhodes

llvm/include/llvm/Transforms/InstCombine/InstCombiner.h

@@ -99,6 +99,11 @@ class LLVM_LIBRARY_VISIBILITY InstCombiner {
   SmallDenseSet<std::pair<const BasicBlock *, const BasicBlock *>, 8> BackEdges;
   bool ComputedBackEdges = false;
 
+  /// Phis for which we already attempted to fold a freeze away. If a freeze is
+  /// reintroduced on one of these phis we avoid repeating the transform to
+  /// prevent endless combine cycles.
+  SmallPtrSet<PHINode *, 16> FreezePhisVisited;
+
 public:
   InstCombiner(InstructionWorklist &Worklist, BuilderTy &Builder, Function &F,
                AAResults *AA, AssumptionCache &AC, TargetLibraryInfo &TLI,

llvm/lib/Transforms/InstCombine/InstCombineInternal.h

@@ -181,7 +181,8 @@ class LLVM_LIBRARY_VISIBILITY InstCombinerImpl final
   Instruction *visitExtractValueInst(ExtractValueInst &EV);
   Instruction *visitLandingPadInst(LandingPadInst &LI);
   Instruction *visitVAEndInst(VAEndInst &I);
-  Value *pushFreezeToPreventPoisonFromPropagating(FreezeInst &FI);
+  Value *pushFreezeToPreventPoisonFromPropagating(FreezeInst &FI,
+                                                  bool PushThruPhis = false);
   bool freezeOtherUses(FreezeInst &FI);
   Instruction *foldFreezeIntoRecurrence(FreezeInst &I, PHINode *PN);
   Instruction *visitFreeze(FreezeInst &I);

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

@@ -5014,7 +5014,8 @@ Instruction *InstCombinerImpl::visitLandingPadInst(LandingPadInst &LI) {
 }
 
 Value *
-InstCombinerImpl::pushFreezeToPreventPoisonFromPropagating(FreezeInst &OrigFI) {
+InstCombinerImpl::pushFreezeToPreventPoisonFromPropagating(FreezeInst &OrigFI,
+                                                           bool PushThruPhis) {
   // Try to push freeze through instructions that propagate but don't produce
   // poison as far as possible. If an operand of freeze does not produce poison
   // then push the freeze through to the operands that are not guaranteed
@@ -5027,8 +5028,8 @@ InstCombinerImpl::pushFreezeToPreventPoisonFromPropagating(FreezeInst &OrigFI) {
   //   Op1.fr = Freeze(Op1)
   //   ... = Inst(Op1.fr, NonPoisonOps...)
 
-  auto CanPushFreeze = [this](Value *V) {
-    if (!isa<Instruction>(V))
+  auto CanPushFreeze = [&](Value *V) {
+    if (!isa<Instruction>(V) || (isa<PHINode>(V) && !PushThruPhis))
       return false;
 
     if (auto *PN = dyn_cast<PHINode>(V)) {
@@ -5231,15 +5232,19 @@ Instruction *InstCombinerImpl::visitFreeze(FreezeInst &I) {
   if (Value *V = simplifyFreezeInst(Op0, SQ.getWithInstruction(&I)))
     return replaceInstUsesWith(I, V);
 
+  bool PushThruPhis = false;
   // freeze (phi const, x) --> phi const, (freeze x)
   if (auto *PN = dyn_cast<PHINode>(Op0)) {
     if (Instruction *NV = foldOpIntoPhi(I, PN))
       return NV;
-    if (Instruction *NV = foldFreezeIntoRecurrence(I, PN))
-      return NV;
+    if (FreezePhisVisited.insert(PN).second) {
+      PushThruPhis = true;
+      if (Instruction *NV = foldFreezeIntoRecurrence(I, PN))
+        return NV;
+    }
   }
 
-  if (Value *NI = pushFreezeToPreventPoisonFromPropagating(I))
+  if (Value *NI = pushFreezeToPreventPoisonFromPropagating(I, PushThruPhis))
     return replaceInstUsesWith(I, NI);
 
   // If I is freeze(undef), check its uses and fold it to a fixed constant.