LICM: Don't crash when an instruction is used by an unreachable BB

[majnemer]

Summary

BBs might contain non-LCSSA'd values after the LCSSA pass is run if they
are unreachable from the entry block.

Normally, the users of the instruction would be PHIs but the unreachable
BBs have normal users; rewrite their uses to be undef values.

An alternative fix could involve fixing this at LCSSA but that would
require this invariant to hold after subsequent transforms. If a BB
created an unreachable block, they would be in violation of this.

This fixes PR19798.

[chandlerc]

Minor code tweak. Otherwise looks good.

lib/Transforms/Scalar/LICM.cpp

601

I think this would be more clear as:

if (!DT->isReachableFromEntry(User->getParent())) {
  User->replaceUsesOfWith(...);
  continue;
}

That localizes the unreachable -> undef logic and reduces the indent for the rest.

[majnemer]

Closed by commit rL216911 (authored by @majnemer).

lib/Transforms/Scalar/LICM.cpp

#endif
 
   // Clones of this instruction. Don't create more than one per exit block!
   SmallDenseMap<BasicBlock *, Instruction *, 32> SunkCopies;
 
   // If this instruction is only used outside of the loop, then all users are
   // PHI nodes in exit blocks due to LCSSA form. Just RAUW them with clones of
   // the instruction.
   while (!I.use_empty()) {
+    Instruction *User = I.user_back();
+    if (DT->isReachableFromEntry(User->getParent())) {
       // The user must be a PHI node.
-    PHINode *PN = cast<PHINode>(I.user_back());
+      PHINode *PN = cast<PHINode>(User);
 
       BasicBlock *ExitBlock = PN->getParent();
       assert(ExitBlockSet.count(ExitBlock) &&
              "The LCSSA PHI is not in an exit block!");
 
       Instruction *New;
       auto It = SunkCopies.find(ExitBlock);
       if (It != SunkCopies.end())
         New = It->second;
       else
         New = SunkCopies[ExitBlock] =
             CloneInstructionInExitBlock(I, *ExitBlock, *PN);
 
       PN->replaceAllUsesWith(New);
       PN->eraseFromParent();
+    } else {
+      User->replaceUsesOfWith(&I, UndefValue::get(I.getType()));
+    }
   }
 
   CurAST->deleteValue(&I);
   I.eraseFromParent();
 }
 
 /// hoist - When an instruction is found to only use loop invariant operands
 /// that is safe to hoist, this instruction is called to do the dirty work.

test/Transforms/LICM/PR19798.ll

+; RUN: opt -licm -S < %s | FileCheck %s
+
+define void @f() {
+; CHECK-LABEL: @f(
+entry:
+  br label %bb0
+
+bb0:
+  %tobool7 = icmp eq i1 undef, undef
+  br label %bb1
+
+bb1:
+  br i1 undef, label %bb0, label %bb0
+
+unreachable:
+; CHECK-LABEL: unreachable:
+; CHECK:   br i1 undef, label %unreachable, label %unreachable
+  br i1 %tobool7, label %unreachable, label %unreachable
+
+bb3:
+  unreachable
+}