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

1 ↗

(On Diff #524867)

Precommit regenerated checks.

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

17 ↗

(On Diff #524867)

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

79

too much indent

llvm/include/llvm/Analysis/InstructionSimplify.h

22–23

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

590–591

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 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/include/llvm/IR/BasicBlock.h

public:
 
   /// Unlink 'this' from the containing function and delete it.
   ///
   // \returns an iterator pointing to the element after the erased one.
   SymbolTableList<BasicBlock>::iterator eraseFromParent();
 
   /// Unlink this basic block from its current function and insert it into
   /// the function that \p MovePos lives in, right before \p MovePos.
-  void moveBefore(BasicBlock *MovePos);
+  inline void moveBefore(BasicBlock *MovePos) {
+    moveBefore(MovePos->getIterator());
+  }
+  void moveBefore(SymbolTableList<BasicBlock>::iterator MovePos);
 
   /// Unlink this basic block from its current function and insert it
   /// right after \p MovePos in the function \p MovePos lives in.
   void moveAfter(BasicBlock *MovePos);
 
   /// Insert unlinked basic block into a function.
   ///
   /// Inserts an unlinked basic block into \c Parent.  If \c InsertBefore is

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/IR/BasicBlock.cpp

 void BasicBlock::removeFromParent() {
   getParent()->getBasicBlockList().remove(getIterator());
 }
 
 iplist<BasicBlock>::iterator BasicBlock::eraseFromParent() {
   return getParent()->getBasicBlockList().erase(getIterator());
 }
 
-void BasicBlock::moveBefore(BasicBlock *MovePos) {
-  MovePos->getParent()->splice(MovePos->getIterator(), getParent(),
-                               getIterator());
+void BasicBlock::moveBefore(SymbolTableList<BasicBlock>::iterator MovePos) {
+  getParent()->splice(MovePos, getParent(), getIterator());
 }
 
 void BasicBlock::moveAfter(BasicBlock *MovePos) {
   MovePos->getParent()->splice(++MovePos->getIterator(), getParent(),
                                getIterator());
 }
 
 const Module *BasicBlock::getModule() const {

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);
+    // Move the new block to preserve the order in the original function.
+    NewBB->moveBefore(NewFunc->end());
 
     // 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);

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/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/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/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:   %call.i2 = tail call i32 @_Z3fibi
 ; INLINE-ALL-NEXT: Getting callee context for instr:   %call5.i = 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

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:

llvm/unittests/Transforms/Utils/LocalTest.cpp

 
 TEST_F(SalvageDebugInfoTest, RecursiveBlockSimplification) {
   BasicBlock *BB = &F->front();
   ASSERT_TRUE(BB);
   bool Deleted = SimplifyInstructionsInBlock(BB);
   ASSERT_TRUE(Deleted);
   verifyDebugValuesAreSalvaged();
 }
 
-TEST(Local, SimplifyVScaleWithRange) {
-  LLVMContext C;
-  Module M("Module", C);
-
-  IntegerType *Ty = Type::getInt32Ty(C);
-  Function *VScale = Intrinsic::getDeclaration(&M, Intrinsic::vscale, {Ty});
-  auto *CI = CallInst::Create(VScale, {}, "vscale");
-
-  // Test that simplifyCall won't try to query it's parent function for
-  // vscale_range attributes in order to simplify llvm.vscale -> constant.
-  EXPECT_EQ(simplifyCall(CI, VScale, {}, SimplifyQuery(M.getDataLayout())),
-            nullptr);
-  delete CI;
-}
-
 TEST(Local, wouldInstructionBeTriviallyDead) {
   LLVMContext Ctx;
   std::unique_ptr<Module> M = parseIR(Ctx,
                                       R"(
     define dso_local void @fun() local_unnamed_addr #0 !dbg !9 {
     entry:
       call void @llvm.dbg.declare(metadata !{}, metadata !13, metadata !DIExpression()), !dbg !16
       ret void, !dbg !16
     }