InstSimplify: Require instruction be parented

[arsenm]

Summary

Unlike every other analysis and transform, simplifyInstruction
permitted operating on instructions which are not inserted
into a function. This created an edge case no other code needs
to really worry about, and limited transforms in cases that
can make use of the context function. Only the inliner and a handful
of other utilities were making use of this, so just fix up these
edge cases. Results in some IR ordering differences since
cloned blocks are inserted eagerly now. Plus some additional
simplifications trigger (e.g. some add 0s now folded out that
previously didn't).

[nikic]

I'm okay with making this change. People regularly rediscover it :)

You'll want to adjust the comment at https://github.com/llvm/llvm-project/blob/7f033d0f756e72359c525ed3ab371e064cf55cff/llvm/include/llvm/Analysis/InstructionSimplify.h#L22-L27.

I assume you plan to followup with a change that removes no longer needed checks from InstSimplify?

llvm/test/Transforms/Inline/call-intrinsic-is-constant.ll

2

Precommit regenerated checks.

llvm/test/Transforms/Inline/noalias-calls2.ll

18

You'll have to manually undo these for now, to preserve integrity of the checks. (Once D148216 lands, we can just use --check-globals instead.)

[arsenm]

Documentation updates

[arsenm]

In D151254#4365962, @nikic wrote:

I assume you plan to followup with a change that removes no longer needed checks from InstSimplify?

Yes

[nikic]

llvm/docs/ReleaseNotes.rst

74

too much indent

llvm/include/llvm/Analysis/InstructionSimplify.h

22

drop the "do", doesn't really make sense anymore.

llvm/lib/Transforms/Utils/CloneFunction.cpp

689

Can we do something like NewBB->moveBefore(NewFunc->end()) here?

The nice thing about the current implementation is that it will use the same block order as in the original function, which seems like a nice property to preserve.

I also expect that changing the order will result in massive codegen diffs, for a patch that should otherwise be close to NFC.

[arsenm]

Try to preserve order

[nikic]

llvm/unittests/Transforms/Utils/LocalTest.cpp

606 ↗

(On Diff #527397)

Per this comment, you should just delete the test.

[arsenm]

Delete test

[nikic]

LGTM

[arsenm]

1536e299e63d7788f38117b0212ca50eb76d7a3b

[ayzhao]

Copy/pasting my comment from https://reviews.llvm.org/rG1536e299e63d7788f38117b0212ca50eb76d7a3b#1217141 (I didn't see this code review because this commit didn't have the "Differential Revision" line)

Chrome is seeing a regression where the build size increased for Android and Fuchsia (https://crbug.com/1454531) - see the attached files.

Repro steps:

$ opt -passes=inline before-inline.S

The diff before and after this patch contains the following extra instructions:

while.cond.i.i.preheader.i.i:                     ; preds = %_ZNSt4__Cr6vectorIPN4base5ValueENS_9allocatorIS3_EEE4backEv.exit254.i, %_ZNSt4__Cr6vectorIPN4base5ValueENS_9allocatorIS3_EEE4backEv.exit242.i, %_ZNSt4__Cr6vectorIPN4base5ValueENS_9allocatorIS3_EEE4backEv.exit.i
  %cmp.not.i.i.i.i.i.i.i = icmp eq ptr %add.ptr.i.i, null
  br i1 %cmp.not.i.i.i.i.i.i.i, label %cond.false.i.i.i.i.i.i.i, label %_ZNSt4__Cr6vectorIPN4base5ValueENS_9allocatorIS3_EEE8pop_backEv.exit.i, !prof !4, !llvm.loop !5

cond.false.i.i.i.i.i.i.i:                         ; preds = %while.cond.i.i.preheader.i.i
  call void (ptr, ...) @_ZNSt4__Cr22__libcpp_verbose_abortEPKcz(ptr noundef nonnull @.str.10, ptr noundef nonnull @.str.11, i32 noundef 65, ptr noundef nonnull @.str.17, ptr noundef nonnull @.str.18) #29
  unreachable

before-inline.S411 KBDownload

after-inline-old.S405 KBDownload

after-inline-new.S406 KBDownload

[aeubanks]

this was reverted due to causing size regressions, then relanded due to objections in https://reviews.llvm.org/rG464dcab8a6c823c9cb462bf4107797b8173de088 and the chain of reverts being longer than I expected. IIUC this was part of a forward fix for https://github.com/llvm/llvm-project/issues/63316, it would have been nice to get ToT back to a green state (but perhaps I'm missing some context on why reverting was hard, because more dependent commits?) to prevent this sort of revert of a forward fix reintroducing a regression.

also linking the phab review from the landed commit is helpful for provenance tracking

I'm looking into the inliner size regression caused by this now to fix forward

[aeubanks]

from what I can tell, the binary size increase seems to be due to instsimplify in the inliner respecting null_pointer_is_valid more, which is actually a bug fix

[arsenm]

In D151254#4436054, @aeubanks wrote:

from what I can tell, the binary size increase seems to be due to instsimplify in the inliner respecting null_pointer_is_valid more, which is actually a bug fix

Another example of how null_pointer_is_valid is a kind of broken design. Can you add a test for this?

llvm/docs/ReleaseNotes.rst

 ------------------------------
 
 * The legacy optimization pipeline has been removed.
 
 * Alloca merging in the inliner has been removed, since it only worked with the
   legacy inliner pass. Backend stack coloring should handle cases alloca
   merging initially set out to handle.
 
+* InstructionSimplify APIs now require instructions be inserted into a
+   parent function.
+
 Changes to building LLVM
 ------------------------
 
 Changes to TableGen
 -------------------
 
 Changes to Interprocedural Optimizations
 ----------------------------------------

llvm/include/llvm/Analysis/InstructionSimplify.h

 // then it dominates the original instruction.
 //
 // These routines implicitly resolve undef uses. The easiest way to be safe when
 // using these routines to obtain simplified values for existing instructions is
 // to always replace all uses of the instructions with the resulting simplified
 // values. This will prevent other code from seeing the same undef uses and
 // resolving them to different values.
 //
-// These routines are designed to tolerate moderately incomplete IR, such as
-// instructions that are not connected to basic blocks yet. However, they do
-// require that all the IR that they encounter be valid. In particular, they
-// require that all non-constant values be defined in the same function, and the
-// same call context of that function (and not split between caller and callee
-// contexts of a directly recursive call, for example).
+// They do require that all the IR that they encounter be valid and inserted
+// into a parent function.
 //
 // Additionally, these routines can't simplify to the instructions that are not
 // def-reachable, meaning we can't just scan the basic block for instructions
 // to simplify to.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ANALYSIS_INSTRUCTIONSIMPLIFY_H

llvm/lib/Analysis/InstructionSimplify.cpp

 
 /// See if we can compute a simplified version of this instruction.
 /// If not, this returns null.
 
 static Value *simplifyInstructionWithOperands(Instruction *I,
                                               ArrayRef<Value *> NewOps,
                                               const SimplifyQuery &SQ,
                                               unsigned MaxRecurse) {
+  assert(I->getFunction() && "instruction should be inserted in a function");
   const SimplifyQuery Q = SQ.CxtI ? SQ : SQ.getWithInstruction(I);
 
   switch (I->getOpcode()) {
   default:
     if (llvm::all_of(NewOps, [](Value *V) { return isa<Constant>(V); })) {
       SmallVector<Constant *, 8> NewConstOps(NewOps.size());
       transform(NewOps, NewConstOps.begin(),
                 [](Value *V) { return cast<Constant>(V); });

llvm/lib/Transforms/Scalar/JumpThreading.cpp

bool JumpThreadingPass::duplicateCondBranchOnPHIIntoPred(
 
   BasicBlock::iterator BI = BB->begin();
   for (; PHINode *PN = dyn_cast<PHINode>(BI); ++BI)
     ValueMapping[PN] = PN->getIncomingValueForBlock(PredBB);
   // Clone the non-phi instructions of BB into PredBB, keeping track of the
   // mapping and using it to remap operands in the cloned instructions.
   for (; BI != BB->end(); ++BI) {
     Instruction *New = BI->clone();
+    New->insertInto(PredBB, OldPredBranch->getIterator());
 
     // Remap operands to patch up intra-block references.
     for (unsigned i = 0, e = New->getNumOperands(); i != e; ++i)
       if (Instruction *Inst = dyn_cast<Instruction>(New->getOperand(i))) {
         DenseMap<Instruction*, Value*>::iterator I = ValueMapping.find(Inst);
         if (I != ValueMapping.end())
           New->setOperand(i, I->second);
       }
 
     // If this instruction can be simplified after the operands are updated,
     // just use the simplified value instead.  This frequently happens due to
     // phi translation.
     if (Value *IV = simplifyInstruction(
             New,
             {BB->getModule()->getDataLayout(), TLI, nullptr, nullptr, New})) {
       ValueMapping[&*BI] = IV;
       if (!New->mayHaveSideEffects()) {
-        New->deleteValue();
+        New->eraseFromParent();
         New = nullptr;
       }
     } else {
       ValueMapping[&*BI] = New;
     }
     if (New) {
       // Otherwise, insert the new instruction into the block.
       New->setName(BI->getName());
-      New->insertInto(PredBB, OldPredBranch->getIterator());
       // Update Dominance from simplified New instruction operands.
       for (unsigned i = 0, e = New->getNumOperands(); i != e; ++i)
         if (BasicBlock *SuccBB = dyn_cast<BasicBlock>(New->getOperand(i)))
           Updates.push_back({DominatorTree::Insert, PredBB, SuccBB});
     }
   }
 
   // Check to see if the targets of the branch had PHI nodes. If so, we need to

llvm/lib/Transforms/Utils/CloneFunction.cpp

void PruningFunctionCloner::CloneBlock(
   WeakTrackingVH &BBEntry = VMap[BB];
 
   // Have we already cloned this block?
   if (BBEntry)
     return;
 
   // Nope, clone it now.
   BasicBlock *NewBB;
-  BBEntry = NewBB = BasicBlock::Create(BB->getContext());
-  if (BB->hasName())
-    NewBB->setName(BB->getName() + NameSuffix);
+  Twine NewName(BB->hasName() ? Twine(BB->getName()) + NameSuffix : "");
+  BBEntry = NewBB = BasicBlock::Create(BB->getContext(), NewName, NewFunc);
 
   // It is only legal to clone a function if a block address within that
   // function is never referenced outside of the function.  Given that, we
   // want to map block addresses from the old function to block addresses in
   // the clone. (This is different from the generic ValueMapper
   // implementation, which generates an invalid blockaddress when
   // cloning a function.)
   //
void PruningFunctionCloner::CloneBlock(
   bool hasMemProfMetadata = false;
 
   // Loop over all instructions, and copy them over, DCE'ing as we go.  This
   // loop doesn't include the terminator.
   for (BasicBlock::const_iterator II = StartingInst, IE = --BB->end(); II != IE;
        ++II) {
 
     Instruction *NewInst = cloneInstruction(II);
+    NewInst->insertInto(NewBB, NewBB->end());
 
     if (HostFuncIsStrictFP) {
       // All function calls in the inlined function must get 'strictfp'
       // attribute to prevent undesirable optimizations.
       if (auto *Call = dyn_cast<CallInst>(NewInst))
         Call->addFnAttr(Attribute::StrictFP);
     }
 
     // Eagerly remap operands to the newly cloned instruction, except for PHI
     // nodes for which we defer processing until we update the CFG. Also defer
     // debug intrinsic processing because they may contain use-before-defs.
     if (!isa<PHINode>(NewInst) && !isa<DbgVariableIntrinsic>(NewInst)) {
       RemapInstruction(NewInst, VMap,
                        ModuleLevelChanges ? RF_None : RF_NoModuleLevelChanges);
 
       // If we can simplify this instruction to some other value, simply add
       // a mapping to that value rather than inserting a new instruction into
       // the basic block.
-      //
-      // FIXME: simplifyInstruction should know the context of the new function.
       if (Value *V =
               simplifyInstruction(NewInst, BB->getModule()->getDataLayout())) {
         // On the off-chance that this simplifies to an instruction in the old
         // function, map it back into the new function.
         if (NewFunc != OldFunc)
           if (Value *MappedV = VMap.lookup(V))
             V = MappedV;
 
         if (!NewInst->mayHaveSideEffects()) {
           VMap[&*II] = V;
-          NewInst->deleteValue();
+          NewInst->eraseFromParent();
           continue;
         }
       }
     }
 
     if (II->hasName())
       NewInst->setName(II->getName() + NameSuffix);
     VMap[&*II] = NewInst; // Add instruction map to value.
-    NewInst->insertInto(NewBB, NewBB->end());
     if (isa<CallInst>(II) && !II->isDebugOrPseudoInst()) {
       hasCalls = true;
       hasMemProfMetadata |= II->hasMetadata(LLVMContext::MD_memprof);
     }
 
     if (CodeInfo) {
       CodeInfo->OrigVMap[&*II] = NewInst;
       if (auto *CB = dyn_cast<CallBase>(&*II))
#endif
   // Defer PHI resolution until rest of function is resolved.
   SmallVector<const PHINode *, 16> PHIToResolve;
   for (const BasicBlock &BI : *OldFunc) {
     Value *V = VMap.lookup(&BI);
     BasicBlock *NewBB = cast_or_null<BasicBlock>(V);
     if (!NewBB)
       continue; // Dead block.
 
-    // Add the new block to the new function.
-    NewFunc->insert(NewFunc->end(), NewBB);
-
     // Handle PHI nodes specially, as we have to remove references to dead
     // blocks.
     for (const PHINode &PN : BI.phis()) {
       // PHI nodes may have been remapped to non-PHI nodes by the caller or
       // during the cloning process.
       if (isa<PHINode>(VMap[&PN]))
         PHIToResolve.push_back(&PN);
       else

llvm/lib/Transforms/Utils/LoopRotationUtils.cpp

while (I != E) {
           !isa<DbgInfoIntrinsic>(Inst) && !isa<AllocaInst>(Inst)) {
         Inst->moveBefore(LoopEntryBranch);
         ++NumInstrsHoisted;
         continue;
       }
 
       // Otherwise, create a duplicate of the instruction.
       Instruction *C = Inst->clone();
+      C->insertBefore(LoopEntryBranch);
+
       ++NumInstrsDuplicated;
 
       // Eagerly remap the operands of the instruction.
       RemapInstruction(C, ValueMap,
                        RF_NoModuleLevelChanges | RF_IgnoreMissingLocals);
 
       // Avoid inserting the same intrinsic twice.
       if (auto *DII = dyn_cast<DbgVariableIntrinsic>(C))
         if (DbgIntrinsics.count(makeHash(DII))) {
-          C->deleteValue();
+          C->eraseFromParent();
           continue;
         }
 
       // With the operands remapped, see if the instruction constant folds or is
       // otherwise simplifyable.  This commonly occurs because the entry from PHI
       // nodes allows icmps and other instructions to fold.
       Value *V = simplifyInstruction(C, SQ);
       if (V && LI->replacementPreservesLCSSAForm(C, V)) {
         // If so, then delete the temporary instruction and stick the folded value
         // in the map.
         InsertNewValueIntoMap(ValueMap, Inst, V);
         if (!C->mayHaveSideEffects()) {
-          C->deleteValue();
+          C->eraseFromParent();
           C = nullptr;
         }
       } else {
         InsertNewValueIntoMap(ValueMap, Inst, C);
       }
       if (C) {
         // Otherwise, stick the new instruction into the new block!
         C->setName(Inst->getName());
-        C->insertBefore(LoopEntryBranch);
 
         if (auto *II = dyn_cast<AssumeInst>(C))
           AC->registerAssumption(II);
         // MemorySSA cares whether the cloned instruction was inserted or not, and
         // not whether it can be remapped to a simplified value.
         if (MSSAU)
           InsertNewValueIntoMap(ValueMapMSSA, Inst, C);
       }

llvm/lib/Transforms/Utils/SimplifyCFG.cpp

for (const auto &Pair : KnownValues) {
     TranslateMap[Cond] = CB;
     for (BasicBlock::iterator BBI = BB->begin(); &*BBI != BI; ++BBI) {
       if (PHINode *PN = dyn_cast<PHINode>(BBI)) {
         TranslateMap[PN] = PN->getIncomingValueForBlock(EdgeBB);
         continue;
       }
       // Clone the instruction.
       Instruction *N = BBI->clone();
+      // Insert the new instruction into its new home.
+      N->insertInto(EdgeBB, InsertPt);
+
       if (BBI->hasName())
         N->setName(BBI->getName() + ".c");
 
       // Update operands due to translation.
       for (Use &Op : N->operands()) {
         DenseMap<Value *, Value *>::iterator PI = TranslateMap.find(Op);
         if (PI != TranslateMap.end())
           Op = PI->second;
       }
 
       // Check for trivial simplification.
       if (Value *V = simplifyInstruction(N, {DL, nullptr, nullptr, AC})) {
         if (!BBI->use_empty())
           TranslateMap[&*BBI] = V;
         if (!N->mayHaveSideEffects()) {
-          N->deleteValue(); // Instruction folded away, don't need actual inst
+          N->eraseFromParent(); // Instruction folded away, don't need actual
+                                // inst
           N = nullptr;
         }
       } else {
         if (!BBI->use_empty())
           TranslateMap[&*BBI] = N;
       }
       if (N) {
-        // Insert the new instruction into its new home.
-        N->insertInto(EdgeBB, InsertPt);
-
         // Register the new instruction with the assumption cache if necessary.
         if (auto *Assume = dyn_cast<AssumeInst>(N))
           if (AC)
             AC->registerAssumption(Assume);
       }
     }
 
     BB->removePredecessor(EdgeBB);

llvm/test/Transforms/CodeExtractor/PartialInlineAndOr.ll

 declare void @foo(...) local_unnamed_addr #1
 
 ; Function Attrs: nounwind uwtable
 define i32 @dummy_caller(i32 %arg) local_unnamed_addr #0 {
 bb:
 ; CHECK-LABEL: @dummy_caller
 ; CHECK: br i1
 ; CHECK: br i1
-; CHECK: br i1
 ; CHECK: call void @bar.1.
+; CHECK: br i1
 ; LIMIT-LABEL: @dummy_caller
 ; LIMIT-NOT: br i1
 ; LIMIT: call i32 @bar
   %tmp = tail call i32 @bar(i32 %arg)
   ret i32 %tmp
 }
 
 attributes #0 = { nounwind }
 attributes #1 = { nounwind }
 attributes #2 = { nounwind }
 

llvm/test/Transforms/CodeExtractor/PartialInlinePGOMultiRegion.ll

 l_yes:
   %20 = load i32, ptr %sum, align 4
   ret i32 %20
 }
 
 define signext i32 @foo(i32 signext %value, i32 signext %ub) #0 !prof !30 {
 ; CHECK-LABEL: @foo
 ; CHECK-NOT: call signext i32 @bar
-; CHECK: codeRepl1.i:
-; CHECK: call void @bar.1.if.then
 ; CHECK: codeRepl.i:
 ; CHECK: call void @bar.1.if.then2
+; CHECK: codeRepl1.i:
+; CHECK: call void @bar.1.if.then
 entry:
   %value.addr = alloca i32, align 4
   %ub.addr = alloca i32, align 4
   store i32 %value, ptr %value.addr, align 4
   store i32 %ub, ptr %ub.addr, align 4
   %0 = load i32, ptr %value.addr, align 4
   %1 = load i32, ptr %ub.addr, align 4
   %call = call signext i32 @bar(i32 signext %0, i32 signext %1)

llvm/test/Transforms/Inline/call-intrinsic-is-constant.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
 ; RUN: opt %s -passes=inline -inline-threshold=20 -S | FileCheck %s
 
 declare i1 @llvm.is.constant.i64(i64)
 declare void @foo()
 
 define void @callee(i64 %val) {
 ; CHECK-LABEL: define void @callee
 ; CHECK-SAME: (i64 [[VAL:%.*]]) {
 ; CHECK-NEXT:    [[COND:%.*]] = call i1 @llvm.is.constant.i64(i64 [[VAL]])
cond.false:
   ret void
 }
 
 define void @caller(i64 %val) {
 ; CHECK-LABEL: define void @caller
 ; CHECK-SAME: (i64 [[VAL:%.*]]) {
 ; CHECK-NEXT:    [[COND_I:%.*]] = call i1 @llvm.is.constant.i64(i64 [[VAL]])
 ; CHECK-NEXT:    br i1 [[COND_I]], label [[COND_TRUE_I:%.*]], label [[COND_FALSE_I:%.*]]
+; CHECK:       cond.false.i:
+; CHECK-NEXT:    br label [[CALLEE_EXIT:%.*]]
 ; CHECK:       cond.true.i:
 ; CHECK-NEXT:    call void @foo()
 ; CHECK-NEXT:    call void @foo()
-; CHECK-NEXT:    br label [[CALLEE_EXIT:%.*]]
-; CHECK:       cond.false.i:
 ; CHECK-NEXT:    br label [[CALLEE_EXIT]]
 ; CHECK:       callee.exit:
 ; CHECK-NEXT:    ret void
 ;
   call void @callee(i64 %val)
   ret void
 }

llvm/test/Transforms/Inline/callbr.ll

 ; CHECK-NEXT:    [[I:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    store i32 0, ptr [[I]], align 4
 ; CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr [[I_I]])
 ; CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr [[I1_I]])
 ; CHECK-NEXT:    store i32 0, ptr [[I1_I]], align 4
 ; CHECK-NEXT:    [[I2_I:%.*]] = load i32, ptr [[I1_I]], align 4
 ; CHECK-NEXT:    callbr void asm sideeffect "", "r,!i,!i,~{dirflag},~{fpsr},~{flags}"(i32 [[I2_I]])
 ; CHECK-NEXT:    to label [[BB3_I:%.*]] [label [[BB5_I:%.*]], label %bb4.i]
-; CHECK:       bb3.i:
-; CHECK-NEXT:    store i32 0, ptr [[I_I]], align 4
-; CHECK-NEXT:    br label [[T32_EXIT:%.*]]
 ; CHECK:       bb4.i:
 ; CHECK-NEXT:    store i32 1, ptr [[I_I]], align 4
-; CHECK-NEXT:    br label [[T32_EXIT]]
+; CHECK-NEXT:    br label [[T32_EXIT:%.*]]
 ; CHECK:       bb5.i:
 ; CHECK-NEXT:    store i32 2, ptr [[I_I]], align 4
 ; CHECK-NEXT:    br label [[T32_EXIT]]
+; CHECK:       bb3.i:
+; CHECK-NEXT:    store i32 0, ptr [[I_I]], align 4
+; CHECK-NEXT:    br label [[T32_EXIT]]
 ; CHECK:       t32.exit:
 ; CHECK-NEXT:    [[I7_I:%.*]] = load i32, ptr [[I_I]], align 4
 ; CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr [[I_I]])
 ; CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr [[I1_I]])
 ; CHECK-NEXT:    ret i32 [[I7_I]]
 ;
 bb:
   %i = alloca i32, align 4

llvm/test/Transforms/Inline/deoptimize-intrinsic.ll

 
 define void @caller_0(ptr %c, ptr %ptr) {
 ; CHECK-LABEL: @caller_0(
 entry:
   %v = call i8 @callee(ptr %c)  [ "deopt"(i32 2) ]
   store i8 %v, ptr %ptr
   ret void
 
-; CHECK: lleft.i:
-; CHECK-NEXT:  call void (...) @llvm.experimental.deoptimize.isVoid(i32 1) [ "deopt"(i32 2, i32 1) ]
+; CHECK: rright.i:
+; CHECK-NEXT:  call void (...) @llvm.experimental.deoptimize.isVoid() [ "deopt"(i32 2, i32 1) ]
 ; CHECK-NEXT:  ret void
 
 ; CHECK: rleft.i:
 ; CHECK-NEXT:  call void (...) @llvm.experimental.deoptimize.isVoid(i32 1, i32 300, float 5.000000e+02, <2 x ptr> undef) [ "deopt"(i32 2, i32 1) ]
 ; CHECK-NEXT:  ret void
 
-; CHECK: rright.i:
-; CHECK-NEXT:  call void (...) @llvm.experimental.deoptimize.isVoid() [ "deopt"(i32 2, i32 1) ]
+; CHECK: lleft.i:
+; CHECK-NEXT:  call void (...) @llvm.experimental.deoptimize.isVoid(i32 1) [ "deopt"(i32 2, i32 1) ]
 ; CHECK-NEXT:  ret void
 
 ; CHECK: callee.exit:
 ; CHECK-NEXT:  store i8 10, ptr %ptr
 ; CHECK-NEXT:  ret void
 
 }
 
 define i32 @caller_1(ptr %c, ptr %ptr) personality i8 3 {
 ; CHECK-LABEL: @caller_1(
 entry:
   %v = invoke i8 @callee(ptr %c)  [ "deopt"(i32 3) ] to label %normal
        unwind label %unwind
 
-; CHECK: lleft.i:
-; CHECK-NEXT:  %0 = call i32 (...) @llvm.experimental.deoptimize.i32(i32 1) [ "deopt"(i32 3, i32 1) ]
+; CHECK: rright.i:
+; CHECK-NEXT:  %0 = call i32 (...) @llvm.experimental.deoptimize.i32() [ "deopt"(i32 3, i32 1) ]
 ; CHECK-NEXT:  ret i32 %0
 
 ; CHECK: rleft.i:
 ; CHECK-NEXT:  %1 = call i32 (...) @llvm.experimental.deoptimize.i32(i32 1, i32 300, float 5.000000e+02, <2 x ptr> undef) [ "deopt"(i32 3, i32 1) ]
 ; CHECK-NEXT:  ret i32 %1
 
-; CHECK: rright.i:
-; CHECK-NEXT:  %2 = call i32 (...) @llvm.experimental.deoptimize.i32() [ "deopt"(i32 3, i32 1) ]
+; CHECK: lleft.i:
+; CHECK-NEXT:  %2 = call i32 (...) @llvm.experimental.deoptimize.i32(i32 1) [ "deopt"(i32 3, i32 1) ]
 ; CHECK-NEXT:  ret i32 %2
 
 ; CHECK: callee.exit:
 ; CHECK-NEXT:  br label %normal
 
 ; CHECK: normal:
 ; CHECK-NEXT:  store i8 10, ptr %ptr
 ; CHECK-NEXT:  ret i32 42

llvm/test/Transforms/Inline/dynamic-alloca-simplified-large.ll

 
 define ptr @test_stack_allocate_always(i32 %size) {
 ; CHECK-LABEL: @test_stack_allocate_always(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[SAVEDSTACK:%.*]] = call ptr @llvm.stacksave()
 ; CHECK-NEXT:    [[CMP_I:%.*]] = icmp ult i32 [[SIZE:%.*]], 100
 ; CHECK-NEXT:    [[CONV_I:%.*]] = zext i32 [[SIZE]] to i64
 ; CHECK-NEXT:    br i1 [[CMP_I]], label [[IF_THEN_I:%.*]], label [[IF_END_I:%.*]]
-; CHECK:       if.then.i:
-; CHECK-NEXT:    [[TMP0:%.*]] = alloca i8, i64 [[CONV_I]], align 8
-; CHECK-NEXT:    br label [[STACK_ALLOCATE_EXIT:%.*]]
 ; CHECK:       if.end.i:
 ; CHECK-NEXT:    [[CALL_I:%.*]] = tail call ptr @malloc(i64 [[CONV_I]]) #3
+; CHECK-NEXT:    br label [[STACK_ALLOCATE_EXIT:%.*]]
+; CHECK:       if.then.i:
+; CHECK-NEXT:    [[TMP0:%.*]] = alloca i8, i64 [[CONV_I]], align 8
 ; CHECK-NEXT:    br label [[STACK_ALLOCATE_EXIT]]
 ; CHECK:       stack_allocate.exit:
 ; CHECK-NEXT:    [[RETVAL_0_I:%.*]] = phi ptr [ [[TMP0]], [[IF_THEN_I]] ], [ [[CALL_I]], [[IF_END_I]] ]
 ; CHECK-NEXT:    call void @llvm.stackrestore(ptr [[SAVEDSTACK]])
 ; CHECK-NEXT:    ret ptr [[RETVAL_0_I]]
 ;
 entry:
   %call = tail call ptr @stack_allocate(i32 %size)

llvm/test/Transforms/Inline/inline-funclets.ll

 
 left.right:
   %lr.pad = cleanuppad within %left.cp []
   unreachable
 ; CHECK: [[left_right]]:
 ; CHECK-NEXT: %[[lr_pad:.+]] = cleanuppad within %[[left_cp]] []
 ; CHECK-NEXT: unreachable
 
+; CHECK: [[unreach]]:
+; CHECK-NEXT: unreachable
+
 root.cont:
   call void @g() [ "funclet"(token %root.pad) ]
   invoke void @g() [ "funclet"(token %root.pad) ]
     to label %unreach unwind label %right
 ; CHECK: [[root_cont]]:
 ; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[root_pad]]) ]
 ; CHECK-NEXT:   to label %[[root_cont_cont:.+]] unwind label %cleanup
 ; CHECK: [[root_cont_cont]]:
fr.catch:
   %fr.cp = catchpad within %fr.cs []
   unreachable
 ; CHECK: [[fr_catch]]:
 ; CHECK-NEXT: %[[fr_cp:.+]] = catchpad within %[[fr_cs]] []
 ; CHECK-NEXT: unreachable
 
 unreach:
   unreachable
-; CHECK: [[unreach]]:
-; CHECK-NEXT: unreachable
-
 exit:
   ret void
 }
 
 
 ;;; Test with a no-info funclet (right) which has a cousin (left.left) that
 ;;; unwinds to another cousin (left.right); make sure we don't trip over this
 ;;; when propagating unwind destination info to "right".
invoke void @g() [ "funclet"(token %root.cp) ]
     to label %root.cont unwind label %child
 ; CHECK: [[root]]:
 ; CHECK-NEXT: %[[root_cp:.+]] = cleanuppad within none []
 ; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[root_cp]]) ]
 ; CHECK-NEXT:   to label %[[root_cont:.+]] unwind label %[[child:.+]]
 
 root.cont:
   cleanupret from %root.cp unwind to caller
-; CHECK: [[root_cont]]:
-; CHECK-NEXT: cleanupret from %[[root_cp]] unwind label %cleanup
 
 child:
   %child.cp = cleanuppad within %root.cp []
   invoke void @g() [ "funclet"(token %child.cp) ]
     to label %child.cont unwind label %left
 ; CHECK: [[child]]:
 ; CHECK-NEXT: %[[child_cp:.+]] = cleanuppad within %[[root_cp]] []
 ; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[child_cp]]) ]

 
 left.left:
   %ll.cp = cleanuppad within %left.cp []
   cleanupret from %ll.cp unwind label %left.right
 ; CHECK: [[left_left]]:
 ; CHECK-NEXT: %[[ll_cp:.+]] = cleanuppad within %[[left_cp]] []
 ; CHECK-NEXT: cleanupret from %[[ll_cp]] unwind label %[[left_right:.+]]
 
+
+; CHECK: [[left_right]]:
+; CHECK-NEXT: %[[lr_cp:.+]] = cleanuppad within %[[left_cp]] []
+; CHECK-NEXT: unreachable
+
 left.cont:
   invoke void @g() [ "funclet"(token %left.cp) ]
     to label %unreach unwind label %left.right
 ; CHECK: [[left_cont]]:
 ; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[left_cp]]) ]
 ; CHECK-NEXT:   to label %[[unreach:.+]] unwind label %[[left_right]]
 
 left.right:
   %lr.cp = cleanuppad within %left.cp []
   unreachable
-; CHECK: [[left_right]]:
-; CHECK-NEXT: %[[lr_cp:.+]] = cleanuppad within %[[left_cp]] []
+; CHECK: [[unreach]]:
 ; CHECK-NEXT: unreachable
 
 child.cont:
   invoke void @g() [ "funclet"(token %child.cp) ]
     to label %unreach unwind label %right
 ; CHECK: [[child_cont]]:
 ; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[child_cp]]) ]
 ; CHECK-NEXT:   to label %[[unreach]] unwind label %[[right:.+]]
 
 right:
   %right.cp = cleanuppad within %child.cp []
   call void @g() [ "funclet"(token %right.cp) ]
   unreachable
 ; CHECK: [[right]]:
 ; CHECK-NEXT: %[[right_cp:.+]] = cleanuppad within %[[child_cp]]
 ; CHECK-NEXT: invoke void @g() [ "funclet"(token %[[right_cp]]) ]
 ; CHECK-NEXT:   to label %[[right_cont:.+]] unwind label %cleanup
 ; CHECK: [[right_cont]]:
 ; CHECK-NEXT: unreachable
 
+; CHECK: [[root_cont]]:
+; CHECK-NEXT: cleanupret from %[[root_cp]] unwind label %cleanup
 unreach:
   unreachable
-; CHECK: [[unreach]]:
-; CHECK-NEXT: unreachable
 
 exit:
   ret void
 }
 
 declare void @ProcessCLRException()
 
 ; Make sure the logic doesn't get tripped up when the inlined invoke is

llvm/test/Transforms/Inline/inline-tail.ll

 }
 define void @test_dynalloca_a(i32* byval(i32) %p, i32 %n) {
   musttail call void @test_dynalloca_b(i32* byval(i32) %p, i32 %n)
   ret void
 }
 
 ; We can't merge the returns.
 ; CHECK: define void @test_multiret_a(
-; CHECK: musttail call void @test_multiret_c(
-; CHECK-NEXT: ret void
 ; CHECK: musttail call void @test_multiret_d(
 ; CHECK-NEXT: ret void
+; CHECK: musttail call void @test_multiret_c(
+; CHECK-NEXT: ret void
 
 declare void @test_multiret_c(i1 zeroext %b)
 declare void @test_multiret_d(i1 zeroext %b)
 define internal void @test_multiret_b(i1 zeroext %b) {
   br i1 %b, label %c, label %d
 c:
   musttail call void @test_multiret_c(i1 zeroext %b)
   ret void

 define i32* @test_retptr_a() {
   %rv = musttail call i16* @test_retptr_b()
   %v = bitcast i16* %rv to i32*
   ret i32* %v
 }
 
 ; Combine the last two cases: multiple returns with pointer bitcasts.
 ; CHECK: define i32* @test_multiptrret_a(
-; CHECK: musttail call i8* @test_multiptrret_c(
+; CHECK: musttail call i8* @test_multiptrret_d(
 ; CHECK-NEXT: bitcast i8* {{.*}} to i32*
 ; CHECK-NEXT: ret i32*
-; CHECK: musttail call i8* @test_multiptrret_d(
+; CHECK: musttail call i8* @test_multiptrret_c(
 ; CHECK-NEXT: bitcast i8* {{.*}} to i32*
 ; CHECK-NEXT: ret i32*
 
 declare i8* @test_multiptrret_c(i1 zeroext %b)
 declare i8* @test_multiptrret_d(i1 zeroext %b)
 define internal i16* @test_multiptrret_b(i1 zeroext %b) {
   br i1 %b, label %c, label %d
 c:

llvm/test/Transforms/Inline/inline_inv_group.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
 ; RUN: opt < %s -passes=inline -S | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define ptr @callee() alwaysinline {
 ; CHECK-LABEL: define ptr @callee
 ; CHECK-SAME: () #[[ATTR0:[0-9]+]] {
 ; CHECK-NEXT:    [[TMP1:%.*]] = call ptr @llvm.strip.invariant.group.p0(ptr null)
 ; CHECK-NEXT:    ret ptr [[TMP1]]
 ;
   %1 = call ptr @llvm.strip.invariant.group.p0(ptr null)
   ret ptr %1
 }
 
-define ptr @caller() {
-; CHECK-LABEL: define ptr @caller() {
+define ptr @caller() null_pointer_is_valid {
+; CHECK-LABEL: define ptr @caller
+; CHECK-SAME: () #[[ATTR1:[0-9]+]] {
 ; CHECK-NEXT:    [[TMP1:%.*]] = call ptr @llvm.strip.invariant.group.p0(ptr null)
 ; CHECK-NEXT:    ret ptr [[TMP1]]
 ;
   %1 = call ptr @callee()
   ret ptr %1
 }
 
 declare ptr @llvm.strip.invariant.group.p0(ptr)

llvm/test/Transforms/Inline/inline_invoke.ll

eh.resume:
   resume { ptr, i32 } %exn
 }
 
 ; CHECK:    define void @test0_out()
 ; CHECK:      [[A:%.*]] = alloca %struct.A,
 ; CHECK:      [[B:%.*]] = alloca %struct.A,
 ; CHECK:      invoke void @_ZN1AC1Ev(ptr [[A]])
 ; CHECK:      invoke void @_ZN1AC1Ev(ptr [[B]])
-; CHECK:      invoke void @_ZN1AD1Ev(ptr [[B]])
-; CHECK:      invoke void @_ZN1AD1Ev(ptr [[A]])
 ; CHECK:      landingpad { ptr, i32 }
 ; CHECK-NEXT:    cleanup
 ; CHECK-NEXT:    catch ptr @_ZTIi
 ; CHECK-NEXT: invoke void @_ZN1AD1Ev(ptr [[A]])
 ; CHECK-NEXT:   to label %[[LBL:[^\s]+]] unwind
 ; CHECK: [[LBL]]:
 ; CHECK-NEXT: br label %[[LPAD:[^\s]+]]
+; CHECK:      invoke void @_ZN1AD1Ev(ptr [[B]])
+; CHECK:      invoke void @_ZN1AD1Ev(ptr [[A]])
 ; CHECK:      ret void
 ; CHECK:      landingpad { ptr, i32 }
 ; CHECK-NEXT:    catch ptr @_ZTIi
 ; CHECK-NEXT: br label %[[LPAD]]
 ; CHECK: [[LPAD]]:
 ; CHECK-NEXT: phi { ptr, i32 } [
 ; CHECK-NEXT: extractvalue { ptr, i32 }
 ; CHECK-NEXT: extractvalue { ptr, i32 }

 ; CHECK:      [[A2:%.*]] = alloca %struct.A,
 ; CHECK:      [[B2:%.*]] = alloca %struct.A,
 ; CHECK:      [[A1:%.*]] = alloca %struct.A,
 ; CHECK:      [[B1:%.*]] = alloca %struct.A,
 ; CHECK:      invoke void @_ZN1AC1Ev(ptr [[A1]])
 ; CHECK-NEXT:   unwind label %[[LPAD:[^\s]+]]
 ; CHECK:      invoke void @_ZN1AC1Ev(ptr [[B1]])
 ; CHECK-NEXT:   unwind label %[[LPAD1:[^\s]+]]
-; CHECK:      invoke void @_ZN1AD1Ev(ptr [[B1]])
-; CHECK-NEXT:   unwind label %[[LPAD1]]
-; CHECK:      invoke void @_ZN1AD1Ev(ptr [[A1]])
-; CHECK-NEXT:   unwind label %[[LPAD]]
 
 ; Inner landing pad from first inlining.
 ; CHECK:    [[LPAD1]]:
 ; CHECK-NEXT: [[LPADVAL1:%.*]] = landingpad { ptr, i32 }
 ; CHECK-NEXT:    cleanup
 ; CHECK-NEXT:    catch ptr @_ZTIi
 ; CHECK-NEXT: invoke void @_ZN1AD1Ev(ptr [[A1]])
 ; CHECK-NEXT:   to label %[[RESUME1:[^\s]+]] unwind
+
 ; CHECK: [[RESUME1]]:
 ; CHECK-NEXT: br label %[[LPAD_JOIN1:[^\s]+]]
 
+; CHECK:      invoke void @_ZN1AD1Ev(ptr [[B1]])
+; CHECK-NEXT:   unwind label %[[LPAD1]]
+; CHECK:      invoke void @_ZN1AD1Ev(ptr [[A1]])
+; CHECK-NEXT:   unwind label %[[LPAD]]
+
+
+
 ; CHECK:      invoke void @_ZN1AC1Ev(ptr [[A2]])
 ; CHECK-NEXT:   unwind label %[[LPAD]]
 ; CHECK:      invoke void @_ZN1AC1Ev(ptr [[B2]])
 ; CHECK-NEXT:   unwind label %[[LPAD2:[^\s]+]]
-; CHECK:      invoke void @_ZN1AD1Ev(ptr [[B2]])
-; CHECK-NEXT:   unwind label %[[LPAD2]]
-; CHECK:      invoke void @_ZN1AD1Ev(ptr [[A2]])
-; CHECK-NEXT:   unwind label %[[LPAD]]
 
 ; Inner landing pad from second inlining.
 ; CHECK:    [[LPAD2]]:
 ; CHECK-NEXT: [[LPADVAL2:%.*]] = landingpad { ptr, i32 }
 ; CHECK-NEXT:   cleanup
 ; CHECK-NEXT:   catch ptr @_ZTIi
 ; CHECK-NEXT: invoke void @_ZN1AD1Ev(ptr [[A2]])
 ; CHECK-NEXT:   to label %[[RESUME2:[^\s]+]] unwind
 ; CHECK: [[RESUME2]]:
 ; CHECK-NEXT: br label %[[LPAD_JOIN2:[^\s]+]]
 
+; CHECK:      invoke void @_ZN1AD1Ev(ptr [[B2]])
+; CHECK-NEXT:   unwind label %[[LPAD2]]
+; CHECK:      invoke void @_ZN1AD1Ev(ptr [[A2]])
+; CHECK-NEXT:   unwind label %[[LPAD]]
+
 ; CHECK:      ret void
 
 ; CHECK:    [[LPAD]]:
 ; CHECK-NEXT: [[X:%.*]] = phi i32 [ 0, %entry ], [ 0, {{%.*}} ], [ 1, %cont ], [ 1, {{%.*}} ]
 ; CHECK-NEXT: [[Y:%.*]] = phi i32 [ 1, %entry ], [ 1, {{%.*}} ], [ 4, %cont ], [ 4, {{%.*}} ]
 ; CHECK-NEXT: [[LPADVAL:%.*]] = landingpad { ptr, i32 }
 ; CHECK-NEXT:   catch ptr @_ZTIi
 ; CHECK-NEXT: br label %[[LPAD_JOIN2]]

llvm/test/Transforms/Inline/inlined-mustprogress-loop-metadata.ll

for.end:
   br label %while.body
 while.body:
   br label %while.body
 }
 
 define void @caller(i32 %a, i32 %b) #1 {
 ; CHECK: Function Attrs: noinline
 ; CHECK-LABEL: define {{[^@]+}}@caller
-; CHECK-SAME: (i32 [[A:%.*]], i32 [[B:%.*]]) [[ATTR1:#.*]] {
+; CHECK-SAME: (i32 [[A:%.*]], i32 [[B:%.*]]) [[ATTR1:#[0-9]+]] {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br label [[FOR_COND:%.*]]
 ; CHECK:       for.cond:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[A]], [[B]]
 ; CHECK-NEXT:    br i1 [[CMP]], label [[FOR_BODY:%.*]], label [[FOR_END:%.*]]
 ; CHECK:       for.body:
 ; CHECK-NEXT:    br label [[FOR_COND]]
 ; CHECK:       for.end:
 ; CHECK-NEXT:    br label [[FOR_COND_I:%.*]]
 ; CHECK:       for.cond.i:
-  ; CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP0:![0-9]+]]
 ; CHECK:       callee.exit:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   br label %for.cond
 for.cond:
   %cmp = icmp slt i32 %a, %b
   br i1 %cmp, label %for.body, label %for.end

 ; CHECK:       for.end4:
 ; CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr [[A_ADDR_I]])
 ; CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr [[B_ADDR_I]])
 ; CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr [[I_I]])
 ; CHECK-NEXT:    store i32 0, ptr [[A_ADDR_I]], align 4
 ; CHECK-NEXT:    store i32 5, ptr [[B_ADDR_I]], align 4
 ; CHECK-NEXT:    br label [[FOR_COND_I:%.*]]
 ; CHECK:       for.cond.i:
-; CHECK-NEXT:    [[TMP7:%.*]] = load i32, ptr [[A_ADDR_I]], align 4
-; CHECK-NEXT:    [[TMP8:%.*]] = load i32, ptr [[B_ADDR_I]], align 4
-; CHECK-NEXT:    [[CMP_I:%.*]] = icmp slt i32 [[TMP7]], [[TMP8]]
+; CHECK-NEXT:    [[TMP4:%.*]] = load i32, ptr [[A_ADDR_I]], align 4
+; CHECK-NEXT:    [[TMP5:%.*]] = load i32, ptr [[B_ADDR_I]], align 4
+; CHECK-NEXT:    [[CMP_I:%.*]] = icmp slt i32 [[TMP4]], [[TMP5]]
 ; CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I:%.*]], label [[FOR_END_I:%.*]]
-; CHECK:       for.body.i:
-  ; CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP2:![0-9]+]]
 ; CHECK:       for.end.i:
 ; CHECK-NEXT:    store i32 0, ptr [[I_I]], align 4
 ; CHECK-NEXT:    br label [[FOR_COND1_I:%.*]]
 ; CHECK:       for.cond1.i:
-; CHECK-NEXT:    [[TMP9:%.*]] = load i32, ptr [[I_I]], align 4
-; CHECK-NEXT:    [[CMP2_I:%.*]] = icmp slt i32 [[TMP9]], 10
+; CHECK-NEXT:    [[TMP6:%.*]] = load i32, ptr [[I_I]], align 4
+; CHECK-NEXT:    [[CMP2_I:%.*]] = icmp slt i32 [[TMP6]], 10
 ; CHECK-NEXT:    br i1 [[CMP2_I]], label [[FOR_BODY3_I:%.*]], label [[FOR_END4_I:%.*]]
-; CHECK:       for.body3.i:
-; CHECK-NEXT:    [[TMP10:%.*]] = load i32, ptr [[I_I]], align 4
-; CHECK-NEXT:    [[INC_I:%.*]] = add nsw i32 [[TMP10]], 1
-; CHECK-NEXT:    store i32 [[INC_I]], ptr [[I_I]], align 4
-; CHECK-NEXT:    br label [[FOR_COND1_I]], !llvm.loop [[LOOP3:![0-9]+]]
 ; CHECK:       for.end4.i:
 ; CHECK-NEXT:    br label [[WHILE_BODY_I:%.*]]
 ; CHECK:       while.body.i:
 ; CHECK-NEXT:    br label [[WHILE_BODY_I]]
+; CHECK:       for.body3.i:
+; CHECK-NEXT:    [[TMP7:%.*]] = load i32, ptr [[I_I]], align 4
+; CHECK-NEXT:    [[INC_I:%.*]] = add nsw i32 [[TMP7]], 1
+; CHECK-NEXT:    store i32 [[INC_I]], ptr [[I_I]], align 4
+; CHECK-NEXT:    br label [[FOR_COND1_I]], !llvm.loop [[LOOP3:![0-9]+]]
+; CHECK:       for.body.i:
+; CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP2:![0-9]+]]
 ; CHECK:       callee_multiple.exit:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %a.addr = alloca i32, align 4
   %b.addr = alloca i32, align 4
   %i = alloca i32, align 4
   store i32 %a, ptr %a.addr, align 4

 ; CHECK:       for.end15:
 ; CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr [[A_ADDR_I]])
 ; CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr [[B_ADDR_I]])
 ; CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr [[I_I]])
 ; CHECK-NEXT:    store i32 0, ptr [[A_ADDR_I]], align 4
 ; CHECK-NEXT:    store i32 5, ptr [[B_ADDR_I]], align 4
 ; CHECK-NEXT:    br label [[FOR_COND_I:%.*]]
 ; CHECK:       for.cond.i:
-; CHECK-NEXT:    [[TMP11:%.*]] = load i32, ptr [[A_ADDR_I]], align 4
-; CHECK-NEXT:    [[TMP12:%.*]] = load i32, ptr [[B_ADDR_I]], align 4
-; CHECK-NEXT:    [[CMP_I:%.*]] = icmp slt i32 [[TMP11]], [[TMP12]]
+; CHECK-NEXT:    [[TMP8:%.*]] = load i32, ptr [[A_ADDR_I]], align 4
+; CHECK-NEXT:    [[TMP9:%.*]] = load i32, ptr [[B_ADDR_I]], align 4
+; CHECK-NEXT:    [[CMP_I:%.*]] = icmp slt i32 [[TMP8]], [[TMP9]]
 ; CHECK-NEXT:    br i1 [[CMP_I]], label [[FOR_BODY_I:%.*]], label [[FOR_END_I:%.*]]
-; CHECK:       for.body.i:
-; CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP0]]
 ; CHECK:       for.end.i:
 ; CHECK-NEXT:    store i32 0, ptr [[I_I]], align 4
 ; CHECK-NEXT:    br label [[FOR_COND1_I:%.*]]
 ; CHECK:       for.cond1.i:
-; CHECK-NEXT:    [[TMP13:%.*]] = load i32, ptr [[I_I]], align 4
-; CHECK-NEXT:    [[CMP2_I:%.*]] = icmp slt i32 [[TMP13]], 10
+; CHECK-NEXT:    [[TMP10:%.*]] = load i32, ptr [[I_I]], align 4
+; CHECK-NEXT:    [[CMP2_I:%.*]] = icmp slt i32 [[TMP10]], 10
 ; CHECK-NEXT:    br i1 [[CMP2_I]], label [[FOR_BODY3_I:%.*]], label [[FOR_END8_I:%.*]]
+; CHECK:       for.end8.i:
+; CHECK-NEXT:    br label [[WHILE_BODY_I:%.*]]
+; CHECK:       while.body.i:
+; CHECK-NEXT:    br label [[WHILE_BODY_I]]
 ; CHECK:       for.body3.i:
 ; CHECK-NEXT:    br label [[FOR_COND4_I:%.*]]
 ; CHECK:       for.cond4.i:
-; CHECK-NEXT:    [[TMP14:%.*]] = load i32, ptr [[B_ADDR_I]], align 4
-; CHECK-NEXT:    [[TMP15:%.*]] = load i32, ptr [[A_ADDR_I]], align 4
-; CHECK-NEXT:    [[CMP5_I:%.*]] = icmp slt i32 [[TMP14]], [[TMP15]]
+; CHECK-NEXT:    [[TMP11:%.*]] = load i32, ptr [[B_ADDR_I]], align 4
+; CHECK-NEXT:    [[TMP12:%.*]] = load i32, ptr [[A_ADDR_I]], align 4
+; CHECK-NEXT:    [[CMP5_I:%.*]] = icmp slt i32 [[TMP11]], [[TMP12]]
 ; CHECK-NEXT:    br i1 [[CMP5_I]], label [[FOR_BODY6_I:%.*]], label [[FOR_END7_I:%.*]]
-; CHECK:       for.body6.i:
-  ; CHECK-NEXT:    br label [[FOR_COND4_I]], !llvm.loop [[LOOP2:![0-9]+]]
 ; CHECK:       for.end7.i:
-; CHECK-NEXT:    [[TMP16:%.*]] = load i32, ptr [[I_I]], align 4
-; CHECK-NEXT:    [[INC_I:%.*]] = add nsw i32 [[TMP16]], 1
+; CHECK-NEXT:    [[TMP13:%.*]] = load i32, ptr [[I_I]], align 4
+; CHECK-NEXT:    [[INC_I:%.*]] = add nsw i32 [[TMP13]], 1
 ; CHECK-NEXT:    store i32 [[INC_I]], ptr [[I_I]], align 4
 ; CHECK-NEXT:    br label [[FOR_COND1_I]], !llvm.loop [[LOOP4:![0-9]+]]
-; CHECK:       for.end8.i:
-; CHECK-NEXT:    br label [[WHILE_BODY_I:%.*]]
-; CHECK:       while.body.i:
-; CHECK-NEXT:    br label [[WHILE_BODY_I]]
+; CHECK:       for.body6.i:
+; CHECK-NEXT:    br label [[FOR_COND4_I]], !llvm.loop [[LOOP2]]
+; CHECK:       for.body.i:
+; CHECK-NEXT:    br label [[FOR_COND_I]], !llvm.loop [[LOOP0]]
 ; CHECK:       callee_nested.exit:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %a.addr = alloca i32, align 4
   %b.addr = alloca i32, align 4
   %i = alloca i32, align 4
   %i9 = alloca i32, align 4

llvm/test/Transforms/Inline/noalias-calls2.ll

 define void @caller_equals_callee(ptr noalias %p0, ptr noalias %p1, i32 %cnt) {
 ; CHECK-LABEL: define {{[^@]+}}@caller_equals_callee
 ; CHECK-SAME: (ptr noalias [[P0:%.*]], ptr noalias [[P1:%.*]], i32 [[CNT:%.*]]) {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[ADD_PTR:%.*]] = getelementptr inbounds i32, ptr [[P0]], i64 2
 ; CHECK-NEXT:    [[ADD_PTR1:%.*]] = getelementptr inbounds i32, ptr [[P1]], i64 2
 ; CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata !0)
 ; CHECK-NEXT:    tail call void @llvm.experimental.noalias.scope.decl(metadata !3)
 ; CHECK-NEXT:    store i32 10, ptr [[ADD_PTR]], align 4, !alias.scope !0, !noalias !3
 ; CHECK-NEXT:    store i32 20, ptr [[ADD_PTR1]], align 4, !alias.scope !3, !noalias !0
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[CNT]], 0
 ; CHECK-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
 ; CHECK:       if.then:
 ; CHECK-NEXT:    store i32 11, ptr [[P0]], align 4
 ; CHECK-NEXT:    br label [[IF_END:%.*]]
 ; CHECK:       if.else:
 ; CHECK-NEXT:    [[ADD_PTR2:%.*]] = getelementptr inbounds i32, ptr [[P1]], i64 1

 ; CHECK-NEXT:    [[ADD_PTR_I:%.*]] = getelementptr inbounds i32, ptr [[ADD_PTR]], i64 2
 ; CHECK-NEXT:    [[ADD_PTR1_I:%.*]] = getelementptr inbounds i32, ptr [[ADD_PTR1]], i64 2
 ; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata !22)
 ; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata !25)
 ; CHECK-NEXT:    store i32 10, ptr [[ADD_PTR_I]], align 4, !alias.scope !27, !noalias !28
 ; CHECK-NEXT:    store i32 20, ptr [[ADD_PTR1_I]], align 4, !alias.scope !28, !noalias !27
 ; CHECK-NEXT:    [[CMP_I:%.*]] = icmp eq i32 [[CNT]], 0
 ; CHECK-NEXT:    br i1 [[CMP_I]], label [[IF_THEN_I:%.*]], label [[IF_ELSE_I:%.*]]
-; CHECK:       if.then.i:
-; CHECK-NEXT:    store i32 11, ptr [[ADD_PTR]], align 4, !alias.scope !17, !noalias !20
-; CHECK-NEXT:    br label [[CALLER_EQUALS_CALLEE_EXIT:%.*]]
 ; CHECK:       if.else.i:
 ; CHECK-NEXT:    [[ADD_PTR2_I:%.*]] = getelementptr inbounds i32, ptr [[ADD_PTR1]], i64 1
 ; CHECK-NEXT:    [[ADD_PTR3_I:%.*]] = getelementptr inbounds i32, ptr [[ADD_PTR]], i64 1
 ; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata !29)
 ; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata !32)
 ; CHECK-NEXT:    [[ADD_PTR_I_I:%.*]] = getelementptr inbounds i32, ptr [[ADD_PTR2_I]], i64 2
 ; CHECK-NEXT:    [[ADD_PTR1_I_I:%.*]] = getelementptr inbounds i32, ptr [[ADD_PTR3_I]], i64 2
 ; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata !34)
 ; CHECK-NEXT:    call void @llvm.experimental.noalias.scope.decl(metadata !37)
 ; CHECK-NEXT:    store i32 10, ptr [[ADD_PTR_I_I]], align 4, !alias.scope !39, !noalias !40
 ; CHECK-NEXT:    store i32 20, ptr [[ADD_PTR1_I_I]], align 4, !alias.scope !40, !noalias !39
 ; CHECK-NEXT:    store i32 11, ptr [[ADD_PTR2_I]], align 4, !alias.scope !41, !noalias !42
 ; CHECK-NEXT:    store i32 12, ptr [[ADD_PTR1]], align 4, !alias.scope !20, !noalias !17
+; CHECK-NEXT:    br label [[CALLER_EQUALS_CALLEE_EXIT:%.*]]
+; CHECK:       if.then.i:
+; CHECK-NEXT:    store i32 11, ptr [[ADD_PTR]], align 4, !alias.scope !17, !noalias !20
 ; CHECK-NEXT:    br label [[CALLER_EQUALS_CALLEE_EXIT]]
 ; CHECK:       caller_equals_callee.exit:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   store i32 13, ptr %p0, align 4
   %add.ptr = getelementptr inbounds i32, ptr %p0, i64 1
   %add.ptr1 = getelementptr inbounds i32, ptr %p1, i64 1

llvm/test/Transforms/Inline/nonnull.ll

;
   ret void
 }
 
 define void @caller3(ptr %arg) {
 ; CHECK-LABEL: define void @caller3
 ; CHECK-SAME: (ptr [[ARG:%.*]]) {
 ; CHECK-NEXT:    [[CMP_I:%.*]] = icmp eq ptr [[ARG]], null
 ; CHECK-NEXT:    br i1 [[CMP_I]], label [[EXPENSIVE_I:%.*]], label [[DONE_I:%.*]]
+; CHECK:       done.i:
+; CHECK-NEXT:    call void @bar()
+; CHECK-NEXT:    br label [[CALLEE_EXIT:%.*]]
 ; CHECK:       expensive.i:
 ; CHECK-NEXT:    call void @foo()
 ; CHECK-NEXT:    call void @foo()
 ; CHECK-NEXT:    call void @foo()
 ; CHECK-NEXT:    call void @foo()
 ; CHECK-NEXT:    call void @foo()
 ; CHECK-NEXT:    call void @foo()
 ; CHECK-NEXT:    call void @foo()
 ; CHECK-NEXT:    call void @foo()
 ; CHECK-NEXT:    call void @foo()
 ; CHECK-NEXT:    call void @foo()
-; CHECK-NEXT:    br label [[CALLEE_EXIT:%.*]]
-; CHECK:       done.i:
-; CHECK-NEXT:    call void @bar()
 ; CHECK-NEXT:    br label [[CALLEE_EXIT]]
 ; CHECK:       callee.exit:
 ; CHECK-NEXT:    ret void
 ;
   call void @callee(ptr nonnull %arg)
   ret void
 }
 

llvm/test/Transforms/Inline/ret_attr_update.ll

 ; CHECK-LABEL: @caller2(
 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds i8, ptr [[PTR:%.*]], i64 [[X:%.*]]
 ; CHECK-NEXT:    [[R_I:%.*]] = call ptr @foo(ptr [[GEP]])
 ; CHECK-NEXT:    [[COND_I:%.*]] = icmp ne ptr [[R_I]], null
 ; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[COND_I]]) [ "deopt"() ]
 ; CHECK-NEXT:    [[R_I1:%.*]] = call ptr @bar(ptr [[GEP]])
 ; CHECK-NEXT:    [[COND_I2:%.*]] = icmp ne ptr [[R_I1]], null
 ; CHECK-NEXT:    br i1 [[COND_I2]], label [[RET_I:%.*]], label [[ORIG_I:%.*]]
-; CHECK:       ret.i:
-; CHECK-NEXT:    br label [[CALLEE_WITH_EXPLICIT_CONTROL_FLOW_EXIT:%.*]]
 ; CHECK:       orig.i:
+; CHECK-NEXT:    br label [[CALLEE_WITH_EXPLICIT_CONTROL_FLOW_EXIT:%.*]]
+; CHECK:       ret.i:
 ; CHECK-NEXT:    br label [[CALLEE_WITH_EXPLICIT_CONTROL_FLOW_EXIT]]
 ; CHECK:       callee_with_explicit_control_flow.exit:
-; CHECK-NEXT:    [[Q3:%.*]] = phi ptr [ [[R_I1]], [[RET_I]] ], [ [[GEP]], [[ORIG_I]] ]
+; CHECK-NEXT:    [[Q3:%.*]] = phi ptr [ [[GEP]], [[ORIG_I]] ], [ [[R_I1]], [[RET_I]] ]
 ; CHECK-NEXT:    br i1 [[COND:%.*]], label [[PRET:%.*]], label [[QRET:%.*]]
 ; CHECK:       pret:
 ; CHECK-NEXT:    ret ptr [[R_I]]
 ; CHECK:       qret:
 ; CHECK-NEXT:    ret ptr [[Q3]]
 ;
   %gep = getelementptr inbounds i8, ptr %ptr, i64 %x
   %p = call nonnull ptr @callee_with_throwable(ptr %gep)
fail:
   %s = call ptr @baz(ptr %ptr)
   ret ptr %s
 }
 
 define void @test7(ptr %ptr, i64 %x, i1 %cond) {
 ; CHECK-LABEL: @test7(
 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds i8, ptr [[PTR:%.*]], i64 [[X:%.*]]
 ; CHECK-NEXT:    br i1 [[COND:%.*]], label [[PASS_I:%.*]], label [[FAIL_I:%.*]]
-; CHECK:       pass.i:
-; CHECK-NEXT:    [[R_I:%.*]] = call nonnull ptr @foo(ptr noalias [[GEP]])
-; CHECK-NEXT:    br label [[CALLEE7_EXIT:%.*]]
 ; CHECK:       fail.i:
 ; CHECK-NEXT:    [[S_I:%.*]] = call nonnull ptr @baz(ptr [[GEP]])
+; CHECK-NEXT:    br label [[CALLEE7_EXIT:%.*]]
+; CHECK:       pass.i:
+; CHECK-NEXT:    [[R_I:%.*]] = call nonnull ptr @foo(ptr noalias [[GEP]])
 ; CHECK-NEXT:    br label [[CALLEE7_EXIT]]
 ; CHECK:       callee7.exit:
-; CHECK-NEXT:    [[T1:%.*]] = phi ptr [ [[R_I]], [[PASS_I]] ], [ [[S_I]], [[FAIL_I]] ]
+; CHECK-NEXT:    [[T1:%.*]] = phi ptr [ [[S_I]], [[FAIL_I]] ], [ [[R_I]], [[PASS_I]] ]
 ; CHECK-NEXT:    call void @snort(ptr [[T1]])
 ; CHECK-NEXT:    ret void
 ;
 
   %gep = getelementptr inbounds i8, ptr %ptr, i64 %x
   %t = call nonnull ptr @callee7(ptr %gep, i1 %cond)
   call void @snort(ptr %t)
   ret void

llvm/test/Transforms/Inline/simplify-instruction-computeKnownFPClass-context.ll

define internal i1 @simplify_fcmp_ord_fsub_callee(double %a, double %b) {
   %cmp = fcmp ord double %sub.double.sub, 0.0
   ret i1 %cmp
 }
 
 define i1 @simplify_fcmp_ord_fdiv_caller(double nofpclass(zero nan inf) %i0, double nofpclass(zero nan inf) %i1) {
 ; CHECK-LABEL: define i1 @simplify_fcmp_ord_fdiv_caller
 ; CHECK-SAME: (double nofpclass(nan inf zero) [[I0:%.*]], double nofpclass(nan inf zero) [[I1:%.*]]) {
 ; CHECK-NEXT:    [[SUB_DOUBLE_SUB_I:%.*]] = fdiv double [[I0]], [[I1]]
-; CHECK-NEXT:    [[CMP_I:%.*]] = fcmp ord double [[SUB_DOUBLE_SUB_I]], 0.000000e+00
-; CHECK-NEXT:    ret i1 [[CMP_I]]
+; CHECK-NEXT:    ret i1 true
 ;
   %call = call i1 @simplify_fcmp_ord_fdiv_callee(double %i0, double %i1)
   ret i1 %call
 }
 
 ; Make sure we hit the denormal query in isKnownNeverLogicalZero
 define internal i1 @simplify_fcmp_ord_fdiv_callee(double %a, double %b) {
   %sub.double.sub = fdiv double %a, %b
   %cmp = fcmp ord double %sub.double.sub, 0.0
   ret i1 %cmp
 }
 
 define i1 @simplify_fcmp_ord_frem_caller(double nofpclass(zero nan inf) %i0, double nofpclass(zero nan inf) %i1) {
 ; CHECK-LABEL: define i1 @simplify_fcmp_ord_frem_caller
 ; CHECK-SAME: (double nofpclass(nan inf zero) [[I0:%.*]], double nofpclass(nan inf zero) [[I1:%.*]]) {
 ; CHECK-NEXT:    [[SUB_DOUBLE_SUB_I:%.*]] = frem double [[I0]], [[I1]]
-; CHECK-NEXT:    [[CMP_I:%.*]] = fcmp ord double [[SUB_DOUBLE_SUB_I]], 0.000000e+00
-; CHECK-NEXT:    ret i1 [[CMP_I]]
+; CHECK-NEXT:    ret i1 true
 ;
   %call = call i1 @simplify_fcmp_ord_frem_callee(double %i0, double %i1)
   ret i1 %call
 }
 
 ; Make sure we hit the denormal query in isKnownNeverLogicalZero
 define internal i1 @simplify_fcmp_ord_frem_callee(double %a, double %b) {
   %sub.double.sub = frem double %a, %b
   %cmp = fcmp ord double %sub.double.sub, 0.0
   ret i1 %cmp
 }
 
 define i1 @simplify_fcmp_ord_fmul_caller(double nofpclass(zero nan) %i0, double nofpclass(zero nan) %i1) {
 ; CHECK-LABEL: define i1 @simplify_fcmp_ord_fmul_caller
 ; CHECK-SAME: (double nofpclass(nan zero) [[I0:%.*]], double nofpclass(nan zero) [[I1:%.*]]) {
 ; CHECK-NEXT:    [[SUB_DOUBLE_SUB_I:%.*]] = fmul double [[I0]], [[I1]]
-; CHECK-NEXT:    [[CMP_I:%.*]] = fcmp ord double [[SUB_DOUBLE_SUB_I]], 0.000000e+00
-; CHECK-NEXT:    ret i1 [[CMP_I]]
+; CHECK-NEXT:    ret i1 true
 ;
   %call = call i1 @simplify_fcmp_ord_fmul_callee(double %i0, double %i1)
   ret i1 %call
 }
 
 ; Make sure we hit the denormal query in isKnownNeverLogicalZero
 define internal i1 @simplify_fcmp_ord_fmul_callee(double %a, double %b) {
   %sub.double.sub = fmul double %a, %b

llvm/test/Transforms/LoopRotate/pr56260.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes='loop(loop-rotate,loop-deletion)' -S | FileCheck %s
 
 target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 
 define void @main() {
 ; CHECK-LABEL: @main(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br label [[L0_PREHEADER:%.*]]
 ; CHECK:       L0.L0.preheader.loopexit_crit_edge:
 ; CHECK-NEXT:    br label [[L0_PREHEADER_LOOPEXIT:%.*]]
 ; CHECK:       L0.preheader.loopexit:
 ; CHECK-NEXT:    br label [[L0_PREHEADER]]
 ; CHECK:       L0.preheader:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 0, 0
 ; CHECK-NEXT:    [[INC:%.*]] = zext i1 [[CMP]] to i32
-; CHECK-NEXT:    [[SPEC_SELECT1:%.*]] = add nsw i32 0, [[INC]]
-; CHECK-NEXT:    [[TOBOOL3_NOT2:%.*]] = icmp eq i32 [[SPEC_SELECT1]], 0
-; CHECK-NEXT:    br i1 [[TOBOOL3_NOT2]], label [[L0_PREHEADER_LOOPEXIT]], label [[L1_PREHEADER_LR_PH:%.*]]
+; CHECK-NEXT:    [[TOBOOL3_NOT1:%.*]] = icmp eq i32 [[INC]], 0
+; CHECK-NEXT:    br i1 [[TOBOOL3_NOT1]], label [[L0_PREHEADER_LOOPEXIT]], label [[L1_PREHEADER_LR_PH:%.*]]
 ; CHECK:       L1.preheader.lr.ph:
 ; CHECK-NEXT:    br label [[L1_PREHEADER:%.*]]
 ; CHECK:       L1.preheader:
-; CHECK-NEXT:    [[SPEC_SELECT4:%.*]] = phi i32 [ [[SPEC_SELECT1]], [[L1_PREHEADER_LR_PH]] ], [ [[SPEC_SELECT:%.*]], [[L0_LATCH:%.*]] ]
-; CHECK-NEXT:    [[K_03:%.*]] = phi i32 [ 0, [[L1_PREHEADER_LR_PH]] ], [ [[SPEC_SELECT4]], [[L0_LATCH]] ]
-; CHECK-NEXT:    [[TOBOOL8_NOT:%.*]] = icmp eq i32 [[K_03]], 0
+; CHECK-NEXT:    [[SPEC_SELECT3:%.*]] = phi i32 [ [[INC]], [[L1_PREHEADER_LR_PH]] ], [ [[SPEC_SELECT:%.*]], [[L0_LATCH:%.*]] ]
+; CHECK-NEXT:    [[K_02:%.*]] = phi i32 [ 0, [[L1_PREHEADER_LR_PH]] ], [ [[SPEC_SELECT3]], [[L0_LATCH]] ]
+; CHECK-NEXT:    [[TOBOOL8_NOT:%.*]] = icmp eq i32 [[K_02]], 0
 ; CHECK-NEXT:    br label [[L0_LATCH]]
 ; CHECK:       L0.latch:
-; CHECK-NEXT:    [[SPEC_SELECT]] = add nsw i32 [[SPEC_SELECT4]], [[INC]]
+; CHECK-NEXT:    [[SPEC_SELECT]] = add nsw i32 [[SPEC_SELECT3]], [[INC]]
 ; CHECK-NEXT:    [[TOBOOL3_NOT:%.*]] = icmp eq i32 [[SPEC_SELECT]], 0
 ; CHECK-NEXT:    br i1 [[TOBOOL3_NOT]], label [[L0_L0_PREHEADER_LOOPEXIT_CRIT_EDGE:%.*]], label [[L1_PREHEADER]]
 ;
 entry:
   br label %L0.preheader
 
 L0.preheader:
   br label %L0

llvm/test/Transforms/PartialInlining/switch_stmt.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes="partial-inliner" -skip-partial-inlining-cost-analysis -S < %s | FileCheck %s
 ; RUN: opt -passes=partial-inliner -skip-partial-inlining-cost-analysis -S < %s | FileCheck %s
 
 define dso_local signext i32 @callee(i32 signext %c1, i32 signext %c2) !prof !30 {
 ; CHECK-LABEL: @callee(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[RC:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    store i32 0, ptr [[RC]], align 4
 ; CHECK-NEXT:    switch i32 [[C1:%.*]], label [[SW_DEFAULT:%.*]] [
 ; CHECK-NEXT:    i32 0, label [[SW_BB:%.*]]
 ; CHECK-NEXT:    i32 1, label [[SW_BB1:%.*]]
 ; CHECK-NEXT:    i32 2, label [[SW_BB2:%.*]]
-; CHECK-NEXT:    ], !prof !31
+; CHECK-NEXT:    ], !prof [[PROF31:![0-9]+]]
 ; CHECK:       sw.bb:
 ; CHECK-NEXT:    store i32 1, ptr [[RC]], align 4
 ; CHECK-NEXT:    br label [[SW_EPILOG:%.*]]
 ; CHECK:       sw.bb1:
 ; CHECK-NEXT:    store i32 2, ptr [[RC]], align 4
 ; CHECK-NEXT:    br label [[SW_EPILOG]]
 ; CHECK:       sw.bb2:
 ; CHECK-NEXT:    store i32 4, ptr [[RC]], align 4

 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[RC_I:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr [[RC_I]])
 ; CHECK-NEXT:    store i32 0, ptr [[RC_I]], align 4
 ; CHECK-NEXT:    switch i32 [[C:%.*]], label [[SW_DEFAULT_I:%.*]] [
 ; CHECK-NEXT:    i32 0, label [[CODEREPL_I:%.*]]
 ; CHECK-NEXT:    i32 1, label [[SW_BB1_I:%.*]]
 ; CHECK-NEXT:    i32 2, label [[CODEREPL1_I:%.*]]
-; CHECK-NEXT:    ], !prof !31
-; CHECK:       codeRepl.i:
-; CHECK-NEXT:    call void @callee.1.sw.bb(ptr [[RC_I]])
+; CHECK-NEXT:    ], !prof [[PROF31]]
+; CHECK:       codeRepl1.i:
+; CHECK-NEXT:    call void @callee.1.sw.bb2(ptr [[RC_I]])
 ; CHECK-NEXT:    br label [[CALLEE_1_EXIT:%.*]]
 ; CHECK:       sw.bb1.i:
 ; CHECK-NEXT:    store i32 2, ptr [[RC_I]], align 4
 ; CHECK-NEXT:    br label [[CALLEE_1_EXIT]]
-; CHECK:       codeRepl1.i:
-; CHECK-NEXT:    call void @callee.1.sw.bb2(ptr [[RC_I]])
+; CHECK:       codeRepl.i:
+; CHECK-NEXT:    call void @callee.1.sw.bb(ptr [[RC_I]])
 ; CHECK-NEXT:    br label [[CALLEE_1_EXIT]]
 ; CHECK:       sw.default.i:
 ; CHECK-NEXT:    store i32 [[C]], ptr [[RC_I]], align 4
 ; CHECK-NEXT:    br label [[CALLEE_1_EXIT]]
 ; CHECK:       callee.1.exit:
-; CHECK-NEXT:    [[TMP1:%.*]] = load i32, ptr [[RC_I]], align 4
+; CHECK-NEXT:    [[TMP0:%.*]] = load i32, ptr [[RC_I]], align 4
 ; CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr [[RC_I]])
+; CHECK-NEXT:    ret i32 [[TMP0]]
 ;
 entry:
   %0 = call signext i32 @callee(i32 signext %c, i32 signext %c)
   ret i32 %0
 }
 
 !llvm.module.flags = !{!0, !1}
 

llvm/test/Transforms/SampleProfile/profile-context-tracker-debug.ll

 ; INLINE-ALL-NEXT: Getting callee context for instr:   %call = tail call i32 @_Z5funcBi
 ; INLINE-ALL-NEXT:   Callee context found: main:3.1 @ _Z5funcBi
 ; INLINE-ALL-NEXT: Getting callee context for instr:   %call1 = tail call i32 @_Z5funcAi
 ; INLINE-ALL-NEXT:   Callee context found: main:3 @ _Z5funcAi
 ; INLINE-ALL-NEXT: Marking context profile as inlined: main:3 @ _Z5funcAi
 ; INLINE-ALL-NEXT: Getting callee context for instr:   %call.i = tail call i32 @_Z8funcLeafi
 ; INLINE-ALL-NEXT:   Callee context found: main:3 @ _Z5funcAi:1 @ _Z8funcLeafi
 ; INLINE-ALL-NEXT: Marking context profile as inlined: main:3 @ _Z5funcAi:1 @ _Z8funcLeafi
-; INLINE-ALL-NEXT: Getting callee context for instr:   %call.i1 = tail call i32 @_Z3fibi
 ; INLINE-ALL-NEXT: Getting callee context for instr:   %call5.i = tail call i32 @_Z3fibi
+; INLINE-ALL-NEXT: Getting callee context for instr:   %call.i2 = tail call i32 @_Z3fibi
 ; INLINE-ALL-DAG:  Getting base profile for function: _Z5funcAi
 ; INLINE-ALL-DAG-NEXT:   Merging context profile into base profile: _Z5funcAi
 ; INLINE-ALL-DAG:  Getting base profile for function: _Z5funcBi
 ; INLINE-ALL-DAG-NEXT:   Merging context profile into base profile: _Z5funcBi
 ; INLINE-ALL-DAG-NEXT:   Found context tree root to promote: external:10 @ _Z5funcBi
 ; INLINE-ALL-DAG-NEXT:   Context promoted to: _Z5funcBi
 ; INLINE-ALL-DAG-NEXT:   Found context tree root to promote: externalA:17 @ _Z5funcBi
 ; INLINE-ALL-DAG-NEXT:   Context promoted and merged to: _Z5funcBi

llvm/test/Transforms/SampleProfile/pseudo-probe-inline.ll

 define dso_local i32 @foo(i32 %x) #0 !dbg !12 {
 entry:
 ; CHECK: call void @llvm.pseudoprobe(i64 [[#GUID1:]], i64 1, i32 0, i64 -1)
   %add = add nsw i32 %x, 100000, !dbg !19
 ;; Check zen is fully inlined so there's no call to zen anymore.
 ;; Check code from the inlining of zen is properly annotated here.
 ; CHECK: call void @llvm.pseudoprobe(i64 [[#GUID2:]], i64 1, i32 0, i64 -1)
 ; CHECK: br i1 %cmp.i, label %while.cond.i, label %while.cond2.i, !dbg ![[#]], !prof ![[PD1:[0-9]+]]
+; CHECK: call void @llvm.pseudoprobe(i64 [[#GUID2]], i64 4, i32 0, i64 -1)
+; CHECK: call void @llvm.pseudoprobe(i64 [[#GUID2]], i64 5, i32 0, i64 -1)
 ; CHECK: call void @llvm.pseudoprobe(i64 [[#GUID2]], i64 2, i32 0, i64 -1)
 ; CHECK: br i1 %cmp1.i, label %while.body.i, label %zen.exit, !dbg ![[#]], !prof ![[PD2:[0-9]+]]
 ; CHECK: call void @llvm.pseudoprobe(i64 [[#GUID2]], i64 3, i32 0, i64 -1)
-; CHECK: call void @llvm.pseudoprobe(i64 [[#GUID2]], i64 4, i32 0, i64 -1)
-; CHECK: call void @llvm.pseudoprobe(i64 [[#GUID2]], i64 5, i32 0, i64 -1)
 ; CHECK: call void @llvm.pseudoprobe(i64 [[#GUID2]], i64 6, i32 0, i64 -1)
 ; CHECK-NOT: call i32 @zen
   %call = call i32 @zen(i32 %add), !dbg !20
   ret i32 %call, !dbg !21
 }
 
 ; CHECK: define dso_local i32 @zen
 define dso_local i32 @zen(i32 %x) #0 !dbg !22 {

 ;YAML-NEXT:    - String:          ' samples from profile (ProbeId='
 ;YAML-NEXT:    - ProbeId:         '1'
 ;YAML-NEXT:    - String:          ', Factor='
 ;YAML-NEXT:    - Factor:          '1.000000e+00'
 ;YAML-NEXT:    - String:          ', OriginalSamples='
 ;YAML-NEXT:    - OriginalSamples: '23'
 ;YAML-NEXT:    - String:          ')'
 ;YAML-NEXT:  ...
+
+;YAML:  --- !Analysis
+;YAML:  --- !Analysis
+
 ;YAML:  --- !Analysis
 ;YAML-NEXT:  Pass:            sample-profile
 ;YAML-NEXT:  Name:            AppliedSamples
 ;YAML-NEXT:  DebugLoc:        { File: test.cpp, Line: 41, Column: 14 }
 ;YAML-NEXT:  Function:        foo
 ;YAML-NEXT:  Args:
 ;YAML-NEXT:    - String:          'Applied '
 ;YAML-NEXT:    - NumSamples:      '382920'

llvm/test/Transforms/SimplifyCFG/pr46638.ll

 ; CHECK-NEXT:    call void @dummy(i32 1)
 ; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i32 [[X]], 0
 ; CHECK-NEXT:    [[EXT:%.*]] = zext i1 [[CMP2]] to i32
 ; CHECK-NEXT:    call void @dummy(i32 [[EXT]])
 ; CHECK-NEXT:    br label [[COMMON_RET:%.*]]
 ; CHECK:       common.ret:
 ; CHECK-NEXT:    ret void
 ; CHECK:       true2.critedge:
-; CHECK-NEXT:    [[CMP2_C:%.*]] = icmp sgt i32 [[X]], 0
-; CHECK-NEXT:    [[EXT_C:%.*]] = zext i1 [[CMP2_C]] to i32
-; CHECK-NEXT:    call void @dummy(i32 [[EXT_C]])
+; CHECK-NEXT:    call void @dummy(i32 0)
 ; CHECK-NEXT:    call void @dummy(i32 2)
 ; CHECK-NEXT:    br label [[COMMON_RET]]
 ;
   %cmp1 = icmp slt i32 %x, 0
   call void @llvm.assume(i1 %cmp1)
   br i1 %c, label %true1, label %false1
 
 true1: