Hoist llvm.assume into single predecessor if block otherwise empty

[markus]

Summary

Here is a first go at what was discussed in the thread of https://lists.llvm.org/pipermail/llvm-dev/2021-May/150739.html

Hoist llvm.assume instrinsics (and rewrite condition) from blocks where they would inhibit transformation by SimplifyCFGOpt::simplifyUncondBranch.

[nikic]

This kind of transformation should probably eventually reside in lib/Transforms/Utils/SimplifyCFG.cpp but for now it seemed easier and a smaller change to just leave it in CodeGenPrepare.

I don't think this transform makes a lot of sense in CGP, I'd prefer it to go directly to SimplifyCFG (after which we can drop the CGP code).

However, I'm not sure the whole concept of "hoisting assumes" even makes sense. I'm not sure if we have any passes that can reason about assume(c1 || c2) conditions. We have a lot that can reason about assume(c1 && c2) once it has been canonicalized to assume(c1) assume(c2), but probably nothing that handles ||. The only case in which it could end up being useful is if at a later point, we can show that c1 is actually false, which means we can fold it to just assume(c2), at which point it becomes usable.

Another thing to consider is that assumes with operand bundles would require a more complex transform, to convert the operand bundle form back into a condition form.

I think we would be better off to just drop these assumes. The framing I'm thinking of here is that SimplifyCFG should generally be ignoring ephemeral values in transforms. So if normally SimplifyCFG would drop a block that contains no instructions, then it should also drop a block that only contains ephemeral values.

[jdoerfert]

In D103316#2786946, @nikic wrote:

This kind of transformation should probably eventually reside in lib/Transforms/Utils/SimplifyCFG.cpp but for now it seemed easier and a smaller change to just leave it in CodeGenPrepare.

I don't think this transform makes a lot of sense in CGP, I'd prefer it to go directly to SimplifyCFG (after which we can drop the CGP code).

I agree.

I think we would be better off to just drop these assumes. The framing I'm thinking of here is that SimplifyCFG should generally be ignoring ephemeral values in transforms. So if normally SimplifyCFG would drop a block that contains no instructions, then it should also drop a block that only contains ephemeral values.

I disagree.

if (x)
  assume(y)

is a natural way to spell something for the user.
We should not just drop it without having a good reason.
While we might not use assume(x && y) directly, we will use it if we specialize x to true in some places.

[markus]

Since there seem to be agreement on the placement in SimplifyCFG the code has been moved there.

Wrt assume operand bundles I am thinking that those can always simply be dropped.

Old CodeGenPrepare tests have been temporarily disabled but will be revamped in the SimplifyCFG setting once it is decided if this transformation should hoist or drop assumes (from or in otherwise empty blocks).

[reames]

In D103316#2787008, @jdoerfert wrote:

In D103316#2786946, @nikic wrote:

This kind of transformation should probably eventually reside in lib/Transforms/Utils/SimplifyCFG.cpp but for now it seemed easier and a smaller change to just leave it in CodeGenPrepare.

I don't think this transform makes a lot of sense in CGP, I'd prefer it to go directly to SimplifyCFG (after which we can drop the CGP code).

I agree.

I think we would be better off to just drop these assumes. The framing I'm thinking of here is that SimplifyCFG should generally be ignoring ephemeral values in transforms. So if normally SimplifyCFG would drop a block that contains no instructions, then it should also drop a block that only contains ephemeral values.

I disagree.

if (x)
  assume(y)

is a natural way to spell something for the user.
We should not just drop it without having a good reason.
While we might not use assume(x && y) directly, we will use it if we specialize x to true in some places.

Er, I think you misread the comment you were replying to. The comment was discussing assume(A || B), your response is discussing assume(A && B). Given the context of the discussion, that difference seems important.

My own opinion is closer to that of @nikic. I think we should not be letting assumes block transforms. We should attempt to salvage assume information where we can, but only on a best effort basis. I do think we should generate the assume(A || B) form if that's the logical salvage even if nothing currently can infer from that.

[reames]

In D103316#2789027, @markus wrote:

Wrt assume operand bundles I am thinking that those can always simply be dropped.

I think you can simply ignore operand bundle forms. This is not on by default, and the implementation isn't yet mature. The folks working on that can pay the cost of figuring out what to do for them. As long as your code doesn't crash on operand bundle assumes, I don't really care what it does with them.

[reames]

llvm/lib/CodeGen/CodeGenPrepare.cpp

380

Please split the new transform in SimplifyCFG and the deletion of the old CGP code into two patches. The former should be independently worthwhile if structured properly.

llvm/lib/Transforms/Utils/SimplifyCFG.cpp

6817

I don't think this is the right framing. We don't want to unconditionally hoist assumes, we only want to hoist them if they'd otherwise inhibit a transformation. (e.g. If the successor block was otherwise empty, we hoist as part of threading the edge to the successors successor.)

llvm/test/Transforms/InstCombine/assume-align.ll

16

If we don't predicate the store, the shown transform here does not appear profitable.

[jdoerfert]

[EDIT respond to the assume bundle comment]

In D103316#2800110, @reames wrote:

In D103316#2787008, @jdoerfert wrote:

In D103316#2786946, @nikic wrote:

This kind of transformation should probably eventually reside in lib/Transforms/Utils/SimplifyCFG.cpp but for now it seemed easier and a smaller change to just leave it in CodeGenPrepare.

I don't think this transform makes a lot of sense in CGP, I'd prefer it to go directly to SimplifyCFG (after which we can drop the CGP code).

I agree.

I think we would be better off to just drop these assumes. The framing I'm thinking of here is that SimplifyCFG should generally be ignoring ephemeral values in transforms. So if normally SimplifyCFG would drop a block that contains no instructions, then it should also drop a block that only contains ephemeral values.

I disagree.

if (x)
  assume(y)

is a natural way to spell something for the user.
We should not just drop it without having a good reason.
While we might not use assume(x && y) directly, we will use it if we specialize x to true in some places.

Er, I think you misread the comment you were replying to. The comment was discussing assume(A || B), your response is discussing assume(A && B). Given the context of the discussion, that difference seems important.

My own opinion is closer to that of @nikic. I think we should not be letting assumes block transforms. We should attempt to salvage assume information where we can, but only on a best effort basis. I do think we should generate the assume(A || B) form if that's the logical salvage even if nothing currently can infer from that.

Unsure if I got it right or wrong before but what you said last is what I like too. Salvage assumes in blocks we want to remove if possible. At the same time, "ignore" assumes when the decision for transformations are made.

In D103316#2800112, @reames wrote:

In D103316#2789027, @markus wrote:

Wrt assume operand bundles I am thinking that those can always simply be dropped.

I think you can simply ignore operand bundle forms. This is not on by default, and the implementation isn't yet mature. The folks working on that can pay the cost of figuring out what to do for them. As long as your code doesn't crash on operand bundle assumes, I don't really care what it does with them.

Given that operand bundles for align are the default, people might care: https://clang.godbolt.org/z/Kq8c81T15
That said, I think dropping them is the only reasonable choice we have right now. We don't have a concept of a "pre-condition" that needs to hold in order for the rest to be usable.

[markus]

In D103316#2800153, @jdoerfert wrote:

In D103316#2800110, @reames wrote:

My own opinion is closer to that of @nikic. I think we should not be letting assumes block transforms. We should attempt to salvage assume information where we can, but only on a best effort basis. I do think we should generate the assume(A || B) form if that's the logical salvage even if nothing currently can infer from that.

Unsure if I got it right or wrong before but what you said last is what I like too. Salvage assumes in blocks we want to remove if possible. At the same time, "ignore" assumes when the decision for transformations are made.

So what does this mean in practice?
I interpret it as follows:
We provide a function say bool isBlockEmptyExceptAssumes(BasicBlock *BB) and we update the decision making of all the existing CFG transformations to use that. We provide another function say void hoistAssumesFromBlockKnownToBeOtherwiseEmpty(BasicBlock *BB) that all those CFG transformations need to call during their transformation if they used that fact that any of the blocks checked out as true with the former function.

Now maybe there aren't that many CFG transformations where this is relevant and maybe it integrates easily, I don't know, but it does seem like a somewhat larger change.

llvm/lib/CodeGen/CodeGenPrepare.cpp

380

That makes sense. Will do.

llvm/lib/Transforms/Utils/SimplifyCFG.cpp

6817

I don't fully understand this comment. The current patch does not unconditionally hoist assumes. It hoists assumes if the block in question is otherwise empty. Thus preventing those assumes from inhibiting other transformations later on. Of course it will require another iteration of CFG considerations but isn't that the way these CFG optimizations are generally structured (one transform enables another transform)?

I guess one way I could interpret this comment is that we should provide a utility function say isBlockEmptyExceptAssumes() that can then be queried in the decision making of all the other CFG transformations. So if a block only contains assumes then treat it as if it was empty when performing those optimizations. Maybe that is doable but it does not seem obvious that it would integrate easily with the existing transformations.

llvm/test/Transforms/InstCombine/assume-align.ll

16

I didn't even know that we had predicated scalar stores on IR. Either way is it a generic comment that it would be good if the stores was eventually predicated (in the final emission) or does it imply that predication should happen as part of simplify-cfg now with the added transformation?

[jdoerfert]

In D103316#2802200, @markus wrote:

We provide a function say bool isBlockEmptyExceptAssumes(BasicBlock *BB) and we update the decision making of all the existing CFG transformations to use that. We provide another function say void hoistAssumesFromBlockKnownToBeOtherwiseEmpty(BasicBlock *BB) that all those CFG transformations need to call during their transformation if they used that fact that any of the blocks checked out as true with the former function.

Now maybe there aren't that many CFG transformations where this is relevant and maybe it integrates easily, I don't know, but it does seem like a somewhat larger change.

The above sounds sensible. To keep it small you can use it only in the transformation relevant to you right now. We can update others as we go.

[markus]

Is this the way we want to integrate into SimplifyCFG? Currently only tested with the supplied lit-test.

[bjope]

Not sure I've actually captured all the logic in how we ended up here, considering the original problem was that CodeGenPrepare is too pessimistic when it removes all llvm.assume intrinsics when doing CFG transformations.

The first patch from @markus aimed at improving CodeGenPrepare by making it a bit less aggressive and keeping some llvm.assumes. And then there was an idea to make it even less aggressive by also salvaging some llvm.assume intrinsics.

Now, we have ended up with a patch modifying SimplifyCFG instead. Which obviously doesn't solve the problems we have in CodeGenPrepare. So what is the ultimate goal with this approach? Is the idea that we should remove the CFG transformations in CodeGenPrepare (at least eliminateMostlyEmptyBlocks?) in a follow up patch? Or is the idea to reuse these Utils helpers in CodeGenPrepare when doing such CFG transforms?

I mean, currently the CFG tranformations in CodeGenPrepare might depend on the existence of llvm.assume in the code. That problem still exist unless we also do something in CodeGenPrepare as well, given that the ultimate goal still is that we want to keep/salvage as many llvm.assume intrinsics as possible until ISel.
According to code comments in CodeGenPrepare those transforms are done (at least partially) as a cleanup after early IR passes in codegen such as LSR. And not all targets are running SimplifyCFG between LSR and CodeGenPrepare. Maybe the idea is to also add SimplifyCFG to the codegen pipeline just before CodeGenPrepare as a preparation to remove CodeGenPrepare::eliminateMostlyEmptyBlocks?

[jdoerfert]

I thought the problem was that a block with an assume caused us to miss out on some backed optimization.
The proposed solution was to eliminate blocks that only contain an assume as side effect early as middle-end
optimizations would also benefit from a simplified CFG.

[bjope]

In D103316#2817597, @jdoerfert wrote:

I thought the problem was that a block with an assume caused us to miss out on some backed optimization.
The proposed solution was to eliminate blocks that only contain an assume as side effect early as middle-end
optimizations would also benefit from a simplified CFG.

The problem @markus is working on is that the assumes are removed already in CodeGenPrepare. So there is no assumes left in the IR after CodeGenPrepare, and any AliasAnalysis queries after CodeGenPrepare won't benefit from the assumes.
Thus, any guidance here that isn't moving towards the goal of handling assumes better in CodeGenPrepare (preferrably keeping/salvaging as many assumes as possible) is a bit confusing.

[nikic]

@bjope This SimplifyCFG patch allows us to remove the assume dropping code in CGP subsequently.

llvm/lib/Transforms/Utils/Local.cpp

1112 ↗

(On Diff #350601)

This needs to be CreateLogicalOr.

llvm/lib/Transforms/Utils/SimplifyCFG.cpp

307

You need isSafeToSpeculativelyExecute() here, not just !mayHaveSideEffects().

[markus]

Thanks @bjope for the input. I do share your concern. While I think we all agree that SimplifyCFG is the right place for this kind of transformation the steps that would follow acceptance and landing of the current patch do not seem to directly lead to being able to remove the unconditional assume elimination from CodeGenPrepare. At least not without possibly introducing other degradation as there may be other transformation that have run in between and now put assumes in inconvenient places. As pointed out by @bjope.

[markus]

Updated to address (some) review comments, clang-tidy warnings and taking the Succ->getSinglePredecessor() condition into account to avoid duplication of instructions.

llvm/lib/CodeGen/CodeGenPrepare.cpp

private:
 
     // Get the DominatorTree, building if necessary.
     DominatorTree &getDT(Function &F) {
       if (!DT)
         DT = std::make_unique<DominatorTree>(F);
       return *DT;
     }
 
     void removeAllAssertingVHReferences(Value *V);
-    bool eliminateAssumptions(Function &F);
     bool eliminateFallThrough(Function &F);
     bool eliminateMostlyEmptyBlocks(Function &F);
     BasicBlock *findDestBlockOfMergeableEmptyBlock(BasicBlock *BB);
     bool canMergeBlocks(const BasicBlock *BB, const BasicBlock *DestBB) const;
     void eliminateMostlyEmptyBlock(BasicBlock *BB);
     bool isMergingEmptyBlockProfitable(BasicBlock *BB, BasicBlock *DestBB,
                                        bool isPreheader);
     bool makeBitReverse(Instruction &I);
while (BB != nullptr) {
       BasicBlock* Next = BB->getNextNode();
       // F.hasOptSize is already checked in the outer if statement.
       if (!llvm::shouldOptimizeForSize(BB, PSI, BFI.get()))
         EverMadeChange |= bypassSlowDivision(BB, BypassWidths);
       BB = Next;
     }
   }
 
-  // Get rid of @llvm.assume builtins before attempting to eliminate empty
-  // blocks, since there might be blocks that only contain @llvm.assume calls
-  // (plus arguments that we can get rid of).
-  EverMadeChange |= eliminateAssumptions(F);
-
   // Eliminate blocks that contain only PHI nodes and an
   // unconditional branch.
   EverMadeChange |= eliminateMostlyEmptyBlocks(F);
 
   bool ModifiedDT = false;
   if (!DisableBranchOpts)
     EverMadeChange |= splitBranchCondition(F, ModifiedDT);
 

 #ifndef NDEBUG
   if (VerifyBFIUpdates)
     verifyBFIUpdates(F);
 #endif
 
   return EverMadeChange;
 }
 
-bool CodeGenPrepare::eliminateAssumptions(Function &F) {
-  bool MadeChange = false;
-  for (BasicBlock &BB : F) {
-    CurInstIterator = BB.begin();
-    while (CurInstIterator != BB.end()) {
-      Instruction *I = &*(CurInstIterator++);
-      if (auto *Assume = dyn_cast<AssumeInst>(I)) {
-        MadeChange = true;
-        Value *Operand = Assume->getOperand(0);
-        Assume->eraseFromParent();
-
-        resetIteratorIfInvalidatedWhileCalling(&BB, [&]() {
-          RecursivelyDeleteTriviallyDeadInstructions(Operand, TLInfo, nullptr);
-        });
-      }
-    }
-  }
-  return MadeChange;
-}
-
 /// An instruction is about to be deleted, so remove all references to it in our
 /// GEP-tracking data strcutures.
 void CodeGenPrepare::removeAllAssertingVHReferences(Value *V) {
   LargeOffsetGEPMap.erase(V);
   NewGEPBases.erase(V);
 
   auto GEP = dyn_cast<GetElementPtrInst>(V);
   if (!GEP)
for (auto &Arg : CI->arg_operands()) {
       unsigned AS = Arg->getType()->getPointerAddressSpace();
       return optimizeMemoryInst(CI, Arg, Arg->getType(), AS);
     }
 
   IntrinsicInst *II = dyn_cast<IntrinsicInst>(CI);
   if (II) {
     switch (II->getIntrinsicID()) {
     default: break;
-    case Intrinsic::assume:
-      llvm_unreachable("llvm.assume should have been removed already");
     case Intrinsic::experimental_widenable_condition: {
       // Give up on future widening oppurtunties so that we can fold away dead
       // paths and merge blocks before going into block-local instruction
       // selection.
       if (II->use_empty()) {
         II->eraseFromParent();
         return true;
       }

llvm/lib/Transforms/Utils/SimplifyCFG.cpp

if (SI1 == SI2)
     return false; // Can't merge with self!
 
   // It is not safe to merge these two switch instructions if they have a common
   // successor, and if that successor has a PHI node, and if *that* PHI node has
   // conflicting incoming values from the two switch blocks.
   BasicBlock *SI1BB = SI1->getParent();
   BasicBlock *SI2BB = SI2->getParent();
 
   SmallPtrSet<BasicBlock *, 16> SI1Succs(succ_begin(SI1BB), succ_end(SI1BB));
   bool Fail = false;
   for (BasicBlock *Succ : successors(SI2BB))
     if (SI1Succs.count(Succ))
       for (BasicBlock::iterator BBI = Succ->begin(); isa<PHINode>(BBI); ++BBI) {
         PHINode *PN = cast<PHINode>(BBI);
         if (PN->getIncomingValueForBlock(SI1BB) !=
             PN->getIncomingValueForBlock(SI2BB)) {
           if (FailBlocks)
for (unsigned i = 0, e = PHI.getNumIncomingValues(); i != e; ++i)
           return true;
         }
         // TODO: SwitchInst.
       }
 
   return false;
 }
 
+/// Hoist @llvm.assume and inputs of BB into the single predecessor Pred if they
+/// are the only non-terminator instructions in BB. When hoisted the original
+/// assumption %X needs to be weakened to include the possibility that the
+/// branch was not taken. That is with branch condition %Y in  Pred the new
+/// assumption becomes (!%Y | %X) if BB is the true-target of Pred and (%Y | %X)
+/// if BB is the false-target of Pred. Since 'Assume Operand Bundles' are not
+/// easily transformed in this way they are simply dropped.
+static bool hoistAssumptions(BasicBlock *BB) {
+  auto *Pred = BB->getSinglePredecessor();
+  if (!Pred)
+    return false;
+
+  SetVector<Instruction *> Candidates;
+
+  for (auto It = BB->rbegin(), E = BB->rend(); It != E; ++It) {
+    auto I = &(*It);
+    // Skip the terminator.
+    if (I->isTerminator())
+      continue;
+
+    // Bail if side-effects.
+    if (I->mayHaveSideEffects() && !isa<AssumeInst>(I))
+      return false;
+
+    // Insert into Candidates either if instruction is a @llvm.assume or if all
+    // uses of the instruction are covered by the Candidates set. Otherwise
+    // bail.
+    if (isa<AssumeInst>(I))
+      Candidates.insert(I);
+    else if (!empty(I->users()) && all_of(I->users(), [&](User *U) {
+               return isa<Instruction>(U)
+                          ? Candidates.count(cast<Instruction>(U))
+                          : false;
+             }))
+      Candidates.insert(I);
+    else
+      return false;
+  }
+
+  if (!Candidates.size())
+    return false;
+
+  // If we reach this point BB contains only @llvm.assume instructions and
+  // their input. Hoist into Pred.
+
+  auto *PredBranch = dyn_cast<BranchInst>(Pred->getTerminator());
+  if (!PredBranch || PredBranch->isUnconditional())
+    return false;
+
+  // Now move Candidates into Pred. When we get to a @llvm.assume update the
+  // assume condition to depend on PredBranch->getCondition().
+  Module *M = BB->getParent()->getParent();
+  IRBuilder<> IRB(M->getContext());
+  IRB.SetInsertPoint(PredBranch);
+
+  Value *Cond = PredBranch->getCondition();
+  auto *PredTrueSucc = PredBranch->getSuccessor(0);
+  if (BB == PredTrueSucc)
+    Cond = IRB.CreateNot(Cond);
+
+  for (auto It = Candidates.rbegin(), E = Candidates.rend(); It != E; ++It) {
+    if (auto *Assume = dyn_cast<AssumeInst>(*It)) {
+      auto *OrCond = IRB.CreateOr(Cond, Assume->getOperand(0));
+      // Note that any Operand Bundle is dropped at this point.
+      IRB.CreateAssumption(OrCond);
+      Assume->eraseFromParent();
+    } else {
+      auto *I = *It;
+      I->moveBefore(PredBranch);
+    }
+  }
+
+  return true;
+}
+
 bool SimplifyCFGOpt::simplifyOnceImpl(BasicBlock *BB) {
   bool Changed = false;
 
   assert(BB && BB->getParent() && "Block not embedded in function!");
   assert(BB->getTerminator() && "Degenerate basic block encountered!");
 
   // Remove basic blocks that have no predecessors (except the entry block)...
   // or that just have themself as a predecessor.  These are unreachable.
bool SimplifyCFGOpt::simplifyOnceImpl(BasicBlock *BB) {
   Changed |= removeUndefIntroducingPredecessor(BB, DTU);
 
   // Merge basic blocks into their predecessor if there is only one distinct
   // pred, and if there is only one distinct successor of the predecessor, and
   // if there are no PHI nodes.
   if (MergeBlockIntoPredecessor(BB, DTU))
     return true;
 
+  // Hoist @llvm.assumes if they (and their inputs) are the only contents of
+  // the block.
+  Changed |= hoistAssumptions(BB);
+
   if (SinkCommon && Options.SinkCommonInsts)
     Changed |= SinkCommonCodeFromPredecessors(BB, DTU);
 
   IRBuilder<> Builder(BB);
 
   if (Options.FoldTwoEntryPHINode) {
     // If there is a trivial two-entry PHI node in this basic block, and we can
     // eliminate it, do so now.

llvm/test/Transforms/CodeGenPrepare/X86/delete-assume-dead-code.ll

-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -codegenprepare -S -mtriple=x86_64-linux < %s | FileCheck %s
-
-define i32 @test1(i8* %d) nounwind {
-; CHECK-LABEL: @test1(
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[L:%.*]] = load i8, i8* [[D:%.*]], align 1
-; CHECK-NEXT:    [[TMP0:%.*]] = icmp eq i8 [[L]], 0
-; CHECK-NEXT:    [[CONV:%.*]] = zext i1 [[TMP0]] to i32
-; CHECK-NEXT:    ret i32 [[CONV]]
-;
-entry:
-  %l = load i8, i8* %d
-  %cmp = icmp eq i8 %l, 0
-  br i1 %cmp, label %exit, label %if.end
-
-if.end:
-  %gep = getelementptr i8, i8* %d, i32 42
-  %call = call i64 @foo(i8* %gep) nounwind readonly willreturn
-  %cmp2 = icmp ne i64 %call, 0
-  call void @llvm.assume(i1 %cmp2)
-  br label %exit
-
-exit:
-  %conv = zext i1 %cmp to i32
-  ret i32 %conv
-}
-
-declare i64 @foo(i8*) nounwind readonly willreturn
-declare void @llvm.assume(i1 noundef) nounwind willreturn

llvm/test/Transforms/CodeGenPrepare/X86/recursively-delete-dead-instructions.ll

-; RUN: opt -codegenprepare -S -mtriple=x86_64-linux < %s | FileCheck %s
-
-declare void @llvm.assume(i1 noundef) nounwind willreturn
-
-; Recursively deleting dead operands of assume() may result in its next
-; instruction deleted and the iterator pointing to the next instruction
-; invalidated. This prevents the following simple loop in
-; CodeGenPrepare::optimizeBlock() unless CurInstIterator is fixed:
-;
-;   CurInstIterator = BB.begin();
-;   while (CurInstIterator != BB.end())
-;     optimizeInst(&*CurInstIterator++, ModifiedDT);
-;
-define i32 @test_assume_in_loop(i1 %cond1, i1 %cond2) {
-; CHECK-LABEL: @test_assume_in_loop(
-; CHECK-NEXT:  entry:
-entry:
-  br label %loop
-
-; CHECK: loop:
-; CHECK-NEXT:  br label %loop
-loop:
-  %cond3 = phi i1 [%cond1, %entry], [%cond4, %loop]
-  call void @llvm.assume(i1 %cond3)
-  %cond4 = icmp ult i1 %cond1, %cond2
-  br label %loop
-}

llvm/test/Transforms/CodeGenPrepare/X86/remove-assume-block.ll

-; RUN: opt -S -codegenprepare -mtriple=x86_64-linux < %s | FileCheck %s
-;
-; Ensure that blocks that only contain @llvm.assume are removed completely
-; during CodeGenPrepare.
-
-; CHECK-LABEL: @simple(
-; CHECK-NEXT: end:
-; CHECK-NEXT: ret void
-define void @simple(i64 %addr, i1 %assumption) {
-  %cmp1 = icmp eq i64 %addr, 0
-  br i1 %cmp1, label %do_assume, label %end
-
-do_assume:
-  tail call void @llvm.assume(i1 %assumption)
-  br label %end
-
-end:
-  ret void
-}
-
-; CHECK-LABEL: @complex_assume(
-; CHECK-NEXT: end:
-; CHECK-NEXT: ret void
-define void @complex_assume(i64 %addr, i1 %assumption_a, i1 %assumption_b,
-                          i64 %val_a, i64 %val_b) {
-  %cmp1 = icmp eq i64 %addr, 0
-  br i1 %cmp1, label %do_assume, label %end
-
-do_assume:
-  call void @llvm.assume(i1 %assumption_a)
-  call void @llvm.assume(i1 %assumption_b)
-  %val_xor = xor i64 %val_a, %val_b
-  %val_shifted = lshr i64 %val_xor, 7
-  %assumption_c = trunc i64 %val_shifted to i1
-  call void @llvm.assume(i1 %assumption_c)
-  %assumption_d = call i1 @readonly_func(i64 %val_b)
-  call void @llvm.assume(i1 %assumption_d)
-  br label %end
-
-end:
-  ret void
-}
-
-declare void @llvm.assume(i1 noundef)
-declare i1 @readonly_func(i64) nounwind readonly willreturn;
-

llvm/test/Transforms/CodeGenPrepare/X86/tailcall-assume-xbb.ll

-; RUN: opt -codegenprepare -S -mtriple=x86_64-linux < %s | FileCheck %s
-
-; The ret instruction can be duplicated into BB case2 even though there is an
-; intermediate BB exit1 and call to llvm.assume.
-
-@ptr = external global i8*, align 8
-
-; CHECK:       %ret1 = tail call i8* @qux()
-; CHECK-NEXT:  ret i8* %ret1
-
-; CHECK:       %ret2 = tail call i8* @bar()
-; CHECK-NEXT:  ret i8* %ret2
-
-define i8* @foo(i64 %size, i64 %v1, i64 %v2) {
-entry:
-  %a = alloca i8
-  call void @llvm.lifetime.start.p0i8(i64 -1, i8* %a) nounwind
-  %cmp1 = icmp ult i64 %size, 1025
-  br i1 %cmp1, label %if.end, label %case1
-
-case1:
-  %ret1 = tail call i8* @qux()
-  br label %exit2
-
-if.end:
-  %cmp2 = icmp ult i64 %v1, %v2
-  br i1 %cmp2, label %case3, label %case2
-
-case2:
-  %ret2 = tail call i8* @bar()
-  br label %exit1
-
-case3:
-  %ret3 = load i8*, i8** @ptr, align 8
-  br label %exit1
-
-exit1:
-  %retval1 = phi i8* [ %ret2, %case2 ], [ %ret3, %case3 ]
-  %cmp3 = icmp ne i8* %retval1, null
-  tail call void @llvm.assume(i1 %cmp3)
-  br label %exit2
-
-exit2:
-  %retval2 = phi i8* [ %ret1, %case1 ], [ %retval1, %exit1 ]
-  call void @llvm.lifetime.end.p0i8(i64 -1, i8* %a) nounwind
-  ret i8* %retval2
-}
-
-declare void @llvm.assume(i1)
-declare i8* @qux()
-declare i8* @bar()
-declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) nounwind
-declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) nounwind

llvm/test/Transforms/InstCombine/assume-align.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -passes=instcombine,simplify-cfg < %s 2>&1 | FileCheck %s
 
 declare void @llvm.assume(i1 noundef)
 
 define void @f1(i8* %a) {
 ; CHECK-LABEL: @f1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[PTR:%.*]] = getelementptr inbounds i8, i8* [[A:%.*]], i64 4
 ; CHECK-NEXT:    [[TMP0:%.*]] = ptrtoint i8* [[PTR]] to i64
 ; CHECK-NEXT:    [[TMP1:%.*]] = and i64 [[TMP0]], 3
 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i64 [[TMP1]], 0
-; CHECK-NEXT:    br i1 [[TMP2]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
-; CHECK:       if.then:
-; CHECK-NEXT:    call void @llvm.assume(i1 true) [ "align"(i8* [[PTR]], i64 4) ]
-; CHECK-NEXT:    [[TMP3:%.*]] = bitcast i8* [[PTR]] to i32*
-; CHECK-NEXT:    store i32 4, i32* [[TMP3]], align 4
+; CHECK-NEXT:    [[TMP3:%.*]] = xor i1 [[TMP2]], true
+; CHECK-NEXT:    [[TMP4:%.*]] = or i1 [[TMP3]], true
+; CHECK-NEXT:    call void @llvm.assume(i1 [[TMP4]])
+; CHECK-NEXT:    br i1 [[TMP2]], label [[IF_THEN1:%.*]], label [[IF_END:%.*]]
+; CHECK:       if.then1:
+; CHECK-NEXT:    [[TMP5:%.*]] = bitcast i8* [[PTR]] to i32*
+; CHECK-NEXT:    store i32 4, i32* [[TMP5]], align 4
 ; CHECK-NEXT:    br label [[IF_END]]
 ; CHECK:       if.end:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %ptr = getelementptr inbounds i8, i8* %a, i64 4
   %0 = ptrtoint i8* %ptr to i64
   %1 = and i64 %0, 3