[InstCombine] Use poison constant to represent the result of unreachable instrs

[aqjune]

Summary

This patch updates InstCombine to use poison constant to represent the resulting value of (either semantically or syntactically) unreachable instrs, or a don't-care value of an unreachable store instruction.

This allows more aggressive folding of unused results, as shown in llvm/test/Transforms/InstCombine/getelementptr.ll .

[aqjune]

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

717

Oops, this part does not belong to this patch; I'll remove this

[aqjune]

Remove the update at createOverflowTuple

[aqjune]

rebase

[nikic]

LGTM, but please drop the "use poison instead of undef" comments -- I don't think using poison instead of undef for dead code requires any explicit justification.

llvm/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp

1445

Might want to check for PoisonValue here, to canonicalize a pre-existing undef operand.

[aqjune]

Address comments

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

static CallInst *canonicalizeConstantArg0ToArg1(CallInst &Call) {
   return nullptr;
 }
 
 /// Creates a result tuple for an overflow intrinsic \p II with a given
 /// \p Result and a constant \p Overflow value.
 static Instruction *createOverflowTuple(IntrinsicInst *II, Value *Result,
                                         Constant *Overflow) {
   Constant *V[] = {UndefValue::get(Result->getType()), Overflow};
   StructType *ST = cast<StructType>(II->getType());
   Constant *Struct = ConstantStruct::get(ST, V);
   return InsertValueInst::Create(Struct, Result, 0);
 }
 
 Instruction *
 InstCombinerImpl::foldIntrinsicWithOverflowCommon(IntrinsicInst *II) {
   WithOverflowInst *WO = cast<WithOverflowInst>(II);
   Value *OperationResult = nullptr;
if ((CalleeF->getCallingConv() != Call.getCallingConv() &&
          !(Call.getCallingConv() == llvm::CallingConv::C &&
            TargetLibraryInfoImpl::isCallingConvCCompatible(CalleeF))) &&
         // Only do this for calls to a function with a body.  A prototype may
         // not actually end up matching the implementation's calling conv for a
         // variety of reasons (e.g. it may be written in assembly).
         !CalleeF->isDeclaration()) {
       Instruction *OldCall = &Call;
       CreateNonTerminatorUnreachable(OldCall);
-      // If OldCall does not return void then replaceInstUsesWith undef.
+      // If OldCall does not return void then replaceInstUsesWith poison.
       // This allows ValueHandlers and custom metadata to adjust itself.
       if (!OldCall->getType()->isVoidTy())
-        replaceInstUsesWith(*OldCall, UndefValue::get(OldCall->getType()));
+        // Use poison instead of undef because poison can be aggressively
+        // folded.
+        replaceInstUsesWith(*OldCall, PoisonValue::get(OldCall->getType()));
       if (isa<CallInst>(OldCall))
         return eraseInstFromFunction(*OldCall);
 
       // We cannot remove an invoke or a callbr, because it would change thexi
       // CFG, just change the callee to a null pointer.
       cast<CallBase>(OldCall)->setCalledFunction(
           CalleeF->getFunctionType(),
           Constant::getNullValue(CalleeF->getType()));
       return nullptr;
     }
   }
 
+  // Calling a null function pointer is undefined if a null address isn't
+  // dereferenceable.
   if ((isa<ConstantPointerNull>(Callee) &&
        !NullPointerIsDefined(Call.getFunction())) ||
       isa<UndefValue>(Callee)) {
-    // If Call does not return void then replaceInstUsesWith undef.
+    // If Call does not return void then replaceInstUsesWith poison.
+    // Use poison value instead of undef because it can be aggressively folded.
     // This allows ValueHandlers and custom metadata to adjust itself.
     if (!Call.getType()->isVoidTy())
-      replaceInstUsesWith(Call, UndefValue::get(Call.getType()));
+      replaceInstUsesWith(Call, PoisonValue::get(Call.getType()));
 
     if (Call.isTerminator()) {
       // Can't remove an invoke or callbr because we cannot change the CFG.
       return nullptr;
     }
 
     // This instruction is not reachable, just remove it.
     CreateNonTerminatorUnreachable(&Call);

llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp

for (unsigned j = 0, e = OldPN->getNumOperands(); j != e; ++j) {
         NewV = ConstantExpr::getBitCast(C, DestTy);
       } else if (auto *LI = dyn_cast<LoadInst>(V)) {
         // Explicitly perform load combine to make sure no opposing transform
         // can remove the bitcast in the meantime and trigger an infinite loop.
         Builder.SetInsertPoint(LI);
         NewV = combineLoadToNewType(*LI, DestTy);
         // Remove the old load and its use in the old phi, which itself becomes
         // dead once the whole transform finishes.
-        replaceInstUsesWith(*LI, UndefValue::get(LI->getType()));
+        // Use poison instead of undef because it can be aggressively folded.
+        replaceInstUsesWith(*LI, PoisonValue::get(LI->getType()));
         eraseInstFromFunction(*LI);
       } else if (auto *BCI = dyn_cast<BitCastInst>(V)) {
         NewV = BCI->getOperand(0);
       } else if (auto *PrevPN = dyn_cast<PHINode>(V)) {
         NewV = NewPNodes[PrevPN];
       }
       assert(NewV);
       NewPN->addIncoming(NewV, OldPN->getIncomingBlock(j));

llvm/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp

Instruction *InstCombinerImpl::visitLoadInst(LoadInst &LI) {
   // load(gep null, ...) -> unreachable
   // load null/undef -> unreachable
   // TODO: Consider a target hook for valid address spaces for this xforms.
   if (canSimplifyNullLoadOrGEP(LI, Op)) {
     // Insert a new store to null instruction before the load to indicate
     // that this code is not reachable.  We do this instead of inserting
     // an unreachable instruction directly because we cannot modify the
     // CFG.
-    StoreInst *SI = new StoreInst(UndefValue::get(LI.getType()),
+    // Use poison value instead of undef because using poison allows more
+    // aggressive folding.
+    StoreInst *SI = new StoreInst(PoisonValue::get(LI.getType()),
                                   Constant::getNullValue(Op->getType()), &LI);
     SI->setDebugLoc(LI.getDebugLoc());
-    return replaceInstUsesWith(LI, UndefValue::get(LI.getType()));
+    return replaceInstUsesWith(LI, PoisonValue::get(LI.getType()));
   }
 
   if (Op->hasOneUse()) {
     // Change select and PHI nodes to select values instead of addresses: this
     // helps alias analysis out a lot, allows many others simplifications, and
     // exposes redundancy in the code.
     //
     // Note that we cannot do the transformation unless we know that the
static bool removeBitcastsFromLoadStoreOnMinMax(InstCombinerImpl &IC,
   IC.Builder.SetInsertPoint(LI);
   LoadInst *NewLI = IC.combineLoadToNewType(*LI, CmpLoadTy);
   // Replace all the stores with stores of the newly loaded value.
   for (auto *UI : LI->users()) {
     auto *USI = cast<StoreInst>(UI);
     IC.Builder.SetInsertPoint(USI);
     combineStoreToNewValue(IC, *USI, NewLI);
   }
-  IC.replaceInstUsesWith(*LI, UndefValue::get(LI->getType()));
+  // Use poison instead of undef because it can be aggressively folded.
+  IC.replaceInstUsesWith(*LI, PoisonValue::get(LI->getType()));
   IC.eraseInstFromFunction(*LI);
   return true;
 }
 
 Instruction *InstCombinerImpl::visitStoreInst(StoreInst &SI) {
   Value *Val = SI.getOperand(0);
   Value *Ptr = SI.getOperand(1);
 
for (unsigned ScanInsts = 6; BBI != SI.getParent()->begin() && ScanInsts;
     // Don't skip over loads, throws or things that can modify memory.
     if (BBI->mayWriteToMemory() || BBI->mayReadFromMemory() || BBI->mayThrow())
       break;
   }
 
   // store X, null    -> turns into 'unreachable' in SimplifyCFG
   // store X, GEP(null, Y) -> turns into 'unreachable' in SimplifyCFG
   if (canSimplifyNullStoreOrGEP(SI)) {
     if (!isa<UndefValue>(Val))
-      return replaceOperand(SI, 0, UndefValue::get(Val->getType()));
+      return replaceOperand(SI, 0, PoisonValue::get(Val->getType()));
     return nullptr;  // Do not modify these!
   }
 
   // store undef, Ptr -> noop
   if (isa<UndefValue>(Val))
     return eraseInstFromFunction(SI);
 
   return nullptr;

llvm/lib/Transforms/InstCombine/InstCombinePHI.cpp

for (User *U : PN->users()) {
 
       unsigned Shift = cast<ConstantInt>(UserI->getOperand(1))->getZExtValue();
       PHIUsers.push_back(PHIUsageRecord(PHIId, Shift, UserI->user_back()));
     }
   }
 
   // If we have no users, they must be all self uses, just nuke the PHI.
   if (PHIUsers.empty())
-    return replaceInstUsesWith(FirstPhi, UndefValue::get(FirstPhi.getType()));
+    // Use poison instead of undef because it can be aggressively folded.
+    return replaceInstUsesWith(FirstPhi, PoisonValue::get(FirstPhi.getType()));
 
   // If this phi node is transformable, create new PHIs for all the pieces
   // extracted out of it.  First, sort the users by their offset and size.
   array_pod_sort(PHIUsers.begin(), PHIUsers.end());
 
   LLVM_DEBUG(dbgs() << "SLICING UP PHI: " << FirstPhi << '\n';
              for (unsigned i = 1, e = PHIsToSlice.size(); i != e; ++i) dbgs()
              << "AND USER PHI #" << i << ": " << *PHIsToSlice[i] << '\n';);
if ((EltPHI = ExtractedVals[LoweredPHIRecord(PN, Offset, Ty)]) == nullptr) {
       ExtractedVals[LoweredPHIRecord(PN, Offset, Ty)] = EltPHI;
     }
 
     // Replace the use of this piece with the PHI node.
     replaceInstUsesWith(*PHIUsers[UserI].Inst, EltPHI);
   }
 
   // Replace all the remaining uses of the PHI nodes (self uses and the lshrs)
-  // with undefs.
-  Value *Undef = UndefValue::get(FirstPhi.getType());
+  // with posions.
+  // Use poison instead of undef because it can be aggressively folded.
+  Value *Poison = PoisonValue::get(FirstPhi.getType());
   for (unsigned i = 1, e = PHIsToSlice.size(); i != e; ++i)
-    replaceInstUsesWith(*PHIsToSlice[i], Undef);
-  return replaceInstUsesWith(FirstPhi, Undef);
+    replaceInstUsesWith(*PHIsToSlice[i], Poison);
+  return replaceInstUsesWith(FirstPhi, Poison);
 }
 
 static Value *SimplifyUsingControlFlow(InstCombiner &Self, PHINode &PN,
                                        const DominatorTree &DT) {
   // Simplify the following patterns:
   //       if (cond)
   //       /       \
   //      ...      ...
if (PN.hasOneUse()) {
     if (Instruction *Result = foldIntegerTypedPHI(PN))
       return Result;
 
     Instruction *PHIUser = cast<Instruction>(PN.user_back());
     if (PHINode *PU = dyn_cast<PHINode>(PHIUser)) {
       SmallPtrSet<PHINode*, 16> PotentiallyDeadPHIs;
       PotentiallyDeadPHIs.insert(&PN);
       if (DeadPHICycle(PU, PotentiallyDeadPHIs))
-        return replaceInstUsesWith(PN, UndefValue::get(PN.getType()));
+        // Use poison instead of undef because it can be aggressively folded.
+        return replaceInstUsesWith(PN, PoisonValue::get(PN.getType()));
     }
 
     // If this phi has a single use, and if that use just computes a value for
     // the next iteration of a loop, delete the phi.  This occurs with unused
     // induction variables, e.g. "for (int j = 0; ; ++j);".  Detecting this
     // common case here is good because the only other things that catch this
     // are induction variable analysis (sometimes) and ADCE, which is only run
     // late.
     if (PHIUser->hasOneUse() &&
         (isa<BinaryOperator>(PHIUser) || isa<GetElementPtrInst>(PHIUser)) &&
         PHIUser->user_back() == &PN) {
-      return replaceInstUsesWith(PN, UndefValue::get(PN.getType()));
+      return replaceInstUsesWith(PN, PoisonValue::get(PN.getType()));
     }
     // When a PHI is used only to be compared with zero, it is safe to replace
     // an incoming value proved as known nonzero with any non-zero constant.
     // For example, in the code below, the incoming value %v can be replaced
     // with any non-zero constant based on the fact that the PHI is only used to
     // be compared with zero and %v is a known non-zero value:
     // %v = select %cond, 1, 2
     // %p = phi [%v, BB] ...

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

for (unsigned i = 0, e = Users.size(); i != e; ++i) {
                                              C->isFalseWhenEqual()));
       } else if (auto *SI = dyn_cast<StoreInst>(I)) {
         for (auto *DVI : DVIs)
           if (DVI->isAddressOfVariable())
             ConvertDebugDeclareToDebugValue(DVI, SI, *DIB);
       } else {
         // Casts, GEP, or anything else: we're about to delete this instruction,
         // so it can not have any valid uses.
-        replaceInstUsesWith(*I, UndefValue::get(I->getType()));
+        // Use poison value instead of undef because using poison allows more
+        // aggressive folding.
+        replaceInstUsesWith(*I, PoisonValue::get(I->getType()));
       }
       eraseInstFromFunction(*I);
     }
 
     if (InvokeInst *II = dyn_cast<InvokeInst>(&MI)) {
       // Replace invoke with a NOP intrinsic to maintain the original CFG
       Module *M = II->getModule();
       Function *F = Intrinsic::getDeclaration(M, Intrinsic::donothing);
if (Prev && !Prev->isEHPad() &&
     // pending a potential LangRef change permitting volatile stores to trap.
     // TODO: Either remove this code, or properly integrate the check into
     // isGuaranteedToTransferExecutionToSuccessor().
     if (auto *SI = dyn_cast<StoreInst>(Prev))
       if (SI->isVolatile())
         return nullptr;
 
     // A value may still have uses before we process it here (for example, in
-    // another unreachable block), so convert those to undef.
-    replaceInstUsesWith(*Prev, UndefValue::get(Prev->getType()));
+    // another unreachable block), so convert those to poison.
+    replaceInstUsesWith(*Prev, PoisonValue::get(Prev->getType()));
     eraseInstFromFunction(*Prev);
     return &I;
   }
   return nullptr;
 }
 
 Instruction *InstCombinerImpl::visitUnconditionalBranchInst(BranchInst &BI) {
   assert(BI.isUnconditional() && "Only for unconditional branches.");
if (WithOverflowInst *WO = dyn_cast<WithOverflowInst>(Agg)) {
     // which allows us to simplify multiple result intrinsics to simpler
     // things that just get one value.
     if (WO->hasOneUse()) {
       // Check if we're grabbing only the result of a 'with overflow' intrinsic
       // and replace it with a traditional binary instruction.
       if (*EV.idx_begin() == 0) {
         Instruction::BinaryOps BinOp = WO->getBinaryOp();
         Value *LHS = WO->getLHS(), *RHS = WO->getRHS();
-        replaceInstUsesWith(*WO, UndefValue::get(WO->getType()));
+        // Replace the old instruction's uses with poison.
+        // Use poison instead of undef because it can be aggressively folded.
+        replaceInstUsesWith(*WO, PoisonValue::get(WO->getType()));
         eraseInstFromFunction(*WO);
         return BinaryOperator::Create(BinOp, LHS, RHS);
       }
 
       // If the normal result of the add is dead, and the RHS is a constant,
       // we can transform this into a range comparison.
       // overflow = uadd a, -4  -->  overflow = icmp ugt a, 3
       if (WO->getIntrinsicID() == Intrinsic::uadd_with_overflow)

llvm/test/Transforms/GVN/PRE/2017-06-28-pre-load-dbgloc.ll

 
 define i32 @test(%struct.desc* readonly %desc) local_unnamed_addr #0 !dbg !4 {
 entry:
   %tobool = icmp eq %struct.desc* %desc, null
   br i1 %tobool, label %cond.end, label %cond.false, !dbg !9
 ; ALL: br i1 %tobool, label %entry.cond.end_crit_edge, label %cond.false, !dbg [[LOC_15_6:![0-9]+]]
 ; ALL: entry.cond.end_crit_edge:
 ; GVN: %.pre = load %struct.node*, %struct.node** null, align 8, !dbg [[LOC_16_13:![0-9]+]]
-; INSTCOMBINE:store %struct.node* undef, %struct.node** null, align 536870912, !dbg [[LOC_16_13:![0-9]+]]
+; INSTCOMBINE:store %struct.node* poison, %struct.node** null, align 536870912, !dbg [[LOC_16_13:![0-9]+]]
 
 cond.false:
   %0 = bitcast %struct.desc* %desc to i8***, !dbg !11
   %1 = load i8**, i8*** %0, align 8, !dbg !11
   %2 = load i8*, i8** %1, align 8
   br label %cond.end, !dbg !9
 
 cond.end:

llvm/test/Transforms/InstCombine/atomic.ll

;
   %z = add i32 %x, %y
   ret i32 %z
 }
 
 ; An unordered access to null is still unreachable.  There's no
 ; ordering imposed.
 define i32 @test9() {
 ; CHECK-LABEL: @test9(
-; CHECK-NEXT:    store i32 undef, i32* null, align 536870912
-; CHECK-NEXT:    ret i32 undef
+; CHECK-NEXT:    store i32 poison, i32* null, align 536870912
+; CHECK-NEXT:    ret i32 poison
 ;
   %x = load atomic i32, i32* null unordered, align 4
   ret i32 %x
 }
 
 define i32 @test9_no_null_opt() #0 {
 ; CHECK-LABEL: @test9_no_null_opt(
 ; CHECK-NEXT:    [[X:%.*]] = load atomic i32, i32* null unordered, align 536870912
;
   %x = load atomic i32, i32* null seq_cst, align 4
   ret i32 %x
 }
 
 ; An unordered access to null is still unreachable.  There's no
 ; ordering imposed.
 define i32 @test12() {
 ; CHECK-LABEL: @test12(
-; CHECK-NEXT:    store atomic i32 undef, i32* null unordered, align 536870912
+; CHECK-NEXT:    store atomic i32 poison, i32* null unordered, align 536870912
 ; CHECK-NEXT:    ret i32 0
 ;
   store atomic i32 0, i32* null unordered, align 4
   ret i32 0
 }
 
 define i32 @test12_no_null_opt() #0 {
 ; CHECK-LABEL: @test12_no_null_opt(

llvm/test/Transforms/InstCombine/builtin-object-size-ptr.ll

;
   %t1 = call {}* @llvm.invariant.start.p0i8(i64 10, i8* align 16 %t0)
   call void @llvm.invariant.end.p0i8({}* %t1, i64 10, i8* align 16 %t0)
   store {}* %t1, {}** %p
   ret void
 }
 
 define {}* @minimal_invariant_start_use(i8 %x) {
 ; CHECK-LABEL: @minimal_invariant_start_use(
-; CHECK-NEXT:    ret {}* undef
+; CHECK-NEXT:    ret {}* poison
 ;
   %a = alloca i8
   %i = call {}* @llvm.invariant.start.p0i8(i64 1, i8* %a)
   ret {}* %i
 }
 
 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
 declare i64 @llvm.objectsize.i64.p0i8(i8*, i1) #2
 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1
 declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1 immarg) #0
 declare {}* @llvm.invariant.start.p0i8(i64 immarg, i8* nocapture) #0
 declare void @llvm.invariant.end.p0i8({}*, i64 immarg, i8* nocapture) #0

llvm/test/Transforms/InstCombine/getelementptr.ll

;
   %A = getelementptr %X, %X* null, i64 0, i32 0, i64 0                ; <i32*> [#uses=1]
   %B = icmp ne i32* %A, null              ; <i1> [#uses=1]
   ret i1 %B
 }
 
 define void @test25() {
 ; CHECK-LABEL: @test25(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    store i64 undef, i64* null, align 536870912
+; CHECK-NEXT:    store i64 poison, i64* null, align 536870912
 ; CHECK-NEXT:    tail call void @foo25(i32 0, i64 0)
 ; CHECK-NEXT:    unreachable
 ;
 entry:
   %tmp = getelementptr { i64, i64, i64, i64 }, { i64, i64, i64, i64 }* null, i32 0, i32 3         ; <i64*> [#uses=1]
   %tmp.upgrd.1 = load i64, i64* %tmp           ; <i64> [#uses=1]
   %tmp8.ui = load i64, i64* null               ; <i64> [#uses=1]
   %tmp8 = bitcast i64 %tmp8.ui to i64             ; <i64> [#uses=1]

 
 
 
 ; rdar://6762290
   %T = type <{ i64, i64, i64 }>
 define i32 @test29(i8* %start, i32 %X) nounwind {
 ; CHECK-LABEL: @test29(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    store i64 undef, i64* null, align 536870912
-; CHECK-NEXT:    [[ADD_PTR:%.*]] = getelementptr i8, i8* [[START:%.*]], i64 undef
-; CHECK-NEXT:    [[TMP0:%.*]] = sext i32 [[X:%.*]] to i64
-; CHECK-NEXT:    [[ADD_PTR212:%.*]] = getelementptr i8, i8* [[START]], i64 [[TMP0]]
-; CHECK-NEXT:    [[CMP214:%.*]] = icmp ugt i8* [[ADD_PTR212]], [[ADD_PTR]]
-; CHECK-NEXT:    br i1 [[CMP214]], label [[IF_THEN216:%.*]], label [[IF_END363:%.*]]
+; CHECK-NEXT:    store i64 poison, i64* null, align 536870912
+; CHECK-NEXT:    br i1 false, label [[IF_THEN216:%.*]], label [[IF_END363:%.*]]
 ; CHECK:       if.then216:
 ; CHECK-NEXT:    ret i32 1
 ; CHECK:       if.end363:
 ; CHECK-NEXT:    ret i32 0
 ;
 entry:
   %tmp3 = load i64, i64* null
   %add.ptr = getelementptr i8, i8* %start, i64 %tmp3

 
 %struct.f = type { i32 }
 
 @g0 = internal unnamed_addr constant %struct.f zeroinitializer, align 4
 @g1 = internal unnamed_addr constant %struct.f { i32 -1 }, align 4
 
 define i32* @PR45084(i1 %cond) {
 ; CHECK-LABEL: @PR45084(
-; CHECK-NEXT:    [[GEP:%.*]] = select i1 [[COND:%.*]], i32* getelementptr inbounds ([[STRUCT_F:%.*]], %struct.f* @g0, i64 0, i32 0), i32* getelementptr inbounds ([[STRUCT_F]], %struct.f* @g1, i64 0, i32 0), !prof !0
+; CHECK-NEXT:    [[GEP:%.*]] = select i1 [[COND:%.*]], i32* getelementptr inbounds ([[STRUCT_F:%.*]], %struct.f* @g0, i64 0, i32 0), i32* getelementptr inbounds ([[STRUCT_F]], %struct.f* @g1, i64 0, i32 0), !prof [[PROF0:![0-9]+]]
 ; CHECK-NEXT:    ret i32* [[GEP]]
 ;
   %sel = select i1 %cond, %struct.f* @g0, %struct.f* @g1, !prof !0
   %gep = getelementptr inbounds %struct.f, %struct.f* %sel, i64 0, i32 0
   ret i32* %gep
 }
 
 define i32* @PR45084_extra_use(i1 %cond, %struct.f** %p) {

llvm/test/Transforms/InstCombine/load.ll

 ;
   %Y = select i1 %C, i32* @X, i32* @X2    ; <i32*> [#uses=1]
   %Z = load i32, i32* %Y    ; <i32> [#uses=1]
   ret i32 %Z
 }
 
 define i32 @load_gep_null_inbounds(i64 %X) {
 ; CHECK-LABEL: @load_gep_null_inbounds(
-; CHECK-NEXT:    store i32 undef, i32* null, align 536870912
-; CHECK-NEXT:    ret i32 undef
+; CHECK-NEXT:    store i32 poison, i32* null, align 536870912
+; CHECK-NEXT:    ret i32 poison
 ;
   %V = getelementptr inbounds i32, i32* null, i64 %X
   %R = load i32, i32* %V
   ret i32 %R
 }
 
 define i32 @load_gep_null_not_inbounds(i64 %X) {
 ; CHECK-LABEL: @load_gep_null_not_inbounds(
-; CHECK-NEXT:    store i32 undef, i32* null, align 536870912
-; CHECK-NEXT:    ret i32 undef
+; CHECK-NEXT:    store i32 poison, i32* null, align 536870912
+; CHECK-NEXT:    ret i32 poison
 ;
   %V = getelementptr i32, i32* null, i64 %X
   %R = load i32, i32* %V
   ret i32 %R
 }
 
 define i32 @test7_no_null_opt(i32 %X) #0 {
 ; CHECK-LABEL: @test7_no_null_opt(

llvm/test/Transforms/InstCombine/pr44245.ll

 ; CHECK-NEXT:    br label [[WHILE_COND:%.*]]
 ; CHECK:       while.cond:
 ; CHECK-NEXT:    br label [[FOR_COND:%.*]]
 ; CHECK:       for.cond:
 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[COND_TRUE133:%.*]], label [[COND_FALSE138:%.*]]
 ; CHECK:       cond.true133:
 ; CHECK-NEXT:    br label [[COND_END144:%.*]]
 ; CHECK:       cond.false138:
-; CHECK-NEXT:    store %type_2* undef, %type_2** null, align 536870912
+; CHECK-NEXT:    store %type_2* poison, %type_2** null, align 536870912
 ; CHECK-NEXT:    br label [[COND_END144]]
 ; CHECK:       cond.end144:
 ; CHECK-NEXT:    br label [[WHILE_COND]]
 ;
 entry:
   br label %while.cond
 
 while.cond:                                       ; preds = %cond.end144, %entry

llvm/test/Transforms/InstCombine/store.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instcombine -S | FileCheck %s
 
 define void @test1(i32* %P) {
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:    store i32 123, i32* undef, align 4
-; CHECK-NEXT:    store i32 undef, i32* null, align 536870912
+; CHECK-NEXT:    store i32 poison, i32* null, align 536870912
 ; CHECK-NEXT:    ret void
 ;
   store i32 undef, i32* %P
   store i32 123, i32* undef
   store i32 124, i32* null
   ret void
 }
 
 define void @test2(i32* %P) {
 ; CHECK-LABEL: @test2(
 ; CHECK-NEXT:    ret void
 ;
   %X = load i32, i32* %P
   %Y = add i32 %X, 0
   store i32 %Y, i32* %P
   ret void
 }
 
 define void @store_at_gep_off_null_inbounds(i64 %offset) {
 ; CHECK-LABEL: @store_at_gep_off_null_inbounds(
 ; CHECK-NEXT:    [[PTR:%.*]] = getelementptr inbounds i32, i32* null, i64 [[OFFSET:%.*]]
-; CHECK-NEXT:    store i32 undef, i32* [[PTR]], align 4
+; CHECK-NEXT:    store i32 poison, i32* [[PTR]], align 4
 ; CHECK-NEXT:    ret void
 ;
   %ptr = getelementptr inbounds i32, i32 *null, i64 %offset
   store i32 24, i32* %ptr
   ret void
 }
 
 define void @store_at_gep_off_null_not_inbounds(i64 %offset) {
 ; CHECK-LABEL: @store_at_gep_off_null_not_inbounds(
 ; CHECK-NEXT:    [[PTR:%.*]] = getelementptr i32, i32* null, i64 [[OFFSET:%.*]]
-; CHECK-NEXT:    store i32 undef, i32* [[PTR]], align 4
+; CHECK-NEXT:    store i32 poison, i32* [[PTR]], align 4
 ; CHECK-NEXT:    ret void
 ;
   %ptr = getelementptr i32, i32 *null, i64 %offset
   store i32 24, i32* %ptr
   ret void
 }
 
 define void @store_at_gep_off_no_null_opt(i64 %offset) #0 {

 
 ; PR14753 - merging two stores should preserve the TBAA tag.
 define void @test6(i32 %n, float* %a, i32* %gi) nounwind uwtable ssp {
 ; CHECK-LABEL: @test6(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br label [[FOR_COND:%.*]]
 ; CHECK:       for.cond:
 ; CHECK-NEXT:    [[STOREMERGE:%.*]] = phi i32 [ 42, [[ENTRY:%.*]] ], [ [[INC:%.*]], [[FOR_BODY:%.*]] ]
-; CHECK-NEXT:    store i32 [[STOREMERGE]], i32* [[GI:%.*]], align 4, [[TBAA0:!tbaa !.*]]
+; CHECK-NEXT:    store i32 [[STOREMERGE]], i32* [[GI:%.*]], align 4, !tbaa [[TBAA0:![0-9]+]]
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[STOREMERGE]], [[N:%.*]]
 ; CHECK-NEXT:    br i1 [[CMP]], label [[FOR_BODY]], label [[FOR_END:%.*]]
 ; CHECK:       for.body:
 ; CHECK-NEXT:    [[IDXPROM:%.*]] = sext i32 [[STOREMERGE]] to i64
 ; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds float, float* [[A:%.*]], i64 [[IDXPROM]]
-; CHECK-NEXT:    store float 0.000000e+00, float* [[ARRAYIDX]], align 4, [[TBAA4:!tbaa !.*]]
-; CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* [[GI]], align 4, [[TBAA0]]
+; CHECK-NEXT:    store float 0.000000e+00, float* [[ARRAYIDX]], align 4, !tbaa [[TBAA4:![0-9]+]]
+; CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* [[GI]], align 4, !tbaa [[TBAA0]]
 ; CHECK-NEXT:    [[INC]] = add nsw i32 [[TMP0]], 1
 ; CHECK-NEXT:    br label [[FOR_COND]]
 ; CHECK:       for.end:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   store i32 42, i32* %gi, align 4, !tbaa !0
   br label %for.cond