[ValueTracking] Safe assumption context for args

[gilr]

Summary

Add to safeCxtI() a default context for function arguments which accepts assumptions defined in the entry block that are valid anywhere in the function.

[nikic]

Am I understanding correctly that this tries to use the last instruction in the entry block rather than the first one to avoid triggering the ephemeral value check, in case the first instruction is part of an assumption?

In any case, I don't think it's appropriate to perform a full block scan to determine the context instruction. safeCxtI() should be cheap (as in O(1)).

[gilr]

Sorry for the delay @nikic.

In D93974#2476165, @nikic wrote:

Am I understanding correctly that this tries to use the last instruction in the entry block rather than the first one to avoid triggering the ephemeral value check, in case the first instruction is part of an assumption?

Yes, the first instruction is fine except for an assume which appears (along with its ephemeral values) as the first thing in the function, which in case of an argument seems quite likely.

In any case, I don't think it's appropriate to perform a full block scan to determine the context instruction. safeCxtI() should be cheap (as in O(1)).

An unbounded scan of the entry block might indeed be too much even if applied only to arguments. The scan can perhaps be limited to some small number of instructions (5 seems like the minimum to cover most patterns in computeKnownBits()) which gets reset if an assume is encountered.

[nikic]

In D93974#2479403, @gilr wrote:

Sorry for the delay @nikic.

In D93974#2476165, @nikic wrote:

Am I understanding correctly that this tries to use the last instruction in the entry block rather than the first one to avoid triggering the ephemeral value check, in case the first instruction is part of an assumption?

Yes, the first instruction is fine except for an assume which appears (along with its ephemeral values) as the first thing in the function, which in case of an argument seems quite likely.

In any case, I don't think it's appropriate to perform a full block scan to determine the context instruction. safeCxtI() should be cheap (as in O(1)).

An unbounded scan of the entry block might indeed be too much even if applied only to arguments. The scan can perhaps be limited to some small number of instructions (5 seems like the minimum to cover most patterns in computeKnownBits()) which gets reset if an assume is encountered.

Another possibility would be to leave the context instruction at nullptr, and instead adjust isValidAssumeForContext to accept a nullptr CxtI in which case only instructions that are must-exec from the function entry are considered. Advantage is that it only incurs a cost if there is a potentially relevant assume.

[gilr]

In D93974#2480270, @nikic wrote:

In D93974#2479403, @gilr wrote:

Sorry for the delay @nikic.

In D93974#2476165, @nikic wrote:

Am I understanding correctly that this tries to use the last instruction in the entry block rather than the first one to avoid triggering the ephemeral value check, in case the first instruction is part of an assumption?

Yes, the first instruction is fine except for an assume which appears (along with its ephemeral values) as the first thing in the function, which in case of an argument seems quite likely.

In any case, I don't think it's appropriate to perform a full block scan to determine the context instruction. safeCxtI() should be cheap (as in O(1)).

An unbounded scan of the entry block might indeed be too much even if applied only to arguments. The scan can perhaps be limited to some small number of instructions (5 seems like the minimum to cover most patterns in computeKnownBits()) which gets reset if an assume is encountered.

Another possibility would be to leave the context instruction at nullptr, and instead adjust isValidAssumeForContext to accept a nullptr CxtI in which case only instructions that are must-exec from the function entry are considered. Advantage is that it only incurs a cost if there is a potentially relevant assume.

Right. Setting a safe context seemed less intrusive than letting isValidAssumeForContext take a nullptr CxtI, which requires changes in some of the callers. But on a closer look it seems it's only simplifyICmpWithDominatingAssume(), computeKnownBitsFromAssume() and computeConstantRange() that might get a nullptr context, and the modifications there seem relatively minor. Another option might be to find a safe context in those callers for the first assume, caching and updating it for the other assumptions as needed. Will give it a try.

[jdoerfert]

FWIW, I agree with @nikic, we should not put this logic here. There are two problems:

1. We compute something we might not need.
2. We do it only in value tracking.

I'd prefer the following, though the nullptr proposal seems fine too:
a) For arguments use the first instruction in the entry as context, this is trivial and correct.
b) When the context is used, e.g., to look for assumption, allow to some exploration of surrounding instructions.

[gilr]

In D93974#2489195, @jdoerfert wrote:

FWIW, I agree with @nikic, we should not put this logic here. There are two problems:

1. We compute something we might not need.
2. We do it only in value tracking.

Thanks for taking a look, Johannes!

I'd prefer the following, though the nullptr proposal seems fine too:
a) For arguments use the first instruction in the entry as context, this is trivial and correct.

Agreed. Will limit this patch for this low-hanging fruit. Handling null contexts in isValidAssumptionForContext() is indeed more general, but also seems to have greater potential for causing trivial simplification of ephemeral values. If it works out it would replace the safe context for arguments.

b) When the context is used, e.g., to look for assumption, allow to some exploration of surrounding instructions.

Not sure I see how (beyond the existing extension to reachable instructions). Since isValidAssumeForContext() can't tell why its context was chosen it must assume the context might be protecting an ephemeral from simplification, right?

[jdoerfert]

In D93974#2492566, @gilr wrote:

In D93974#2489195, @jdoerfert wrote:

FWIW, I agree with @nikic, we should not put this logic here. There are two problems:

1. We compute something we might not need.
2. We do it only in value tracking.

Thanks for taking a look, Johannes!

I'd prefer the following, though the nullptr proposal seems fine too:
a) For arguments use the first instruction in the entry as context, this is trivial and correct.

Agreed. Will limit this patch for this low-hanging fruit. Handling null contexts in isValidAssumptionForContext() is indeed more general, but also seems to have greater potential for causing trivial simplification of ephemeral values. If it works out it would replace the safe context for arguments.

b) When the context is used, e.g., to look for assumption, allow to some exploration of surrounding instructions.

Not sure I see how (beyond the existing extension to reachable instructions). Since isValidAssumeForContext() can't tell why its context was chosen it must assume the context might be protecting an ephemeral from simplification, right?

The idea is that you can always do what you do here in isValidAssumeForContext (and friends). I just checked and we seem to do so already. Could you explain to me why we need to go for the Last instruction in this patch at all? What would happen if you simply pick the first in the entry block, which is trivially correct. (Note: You can skip llvm.assume to make some weird problems go away).

[gilr]

In D93974#2492979, @jdoerfert wrote:

The idea is that you can always do what you do here in isValidAssumeForContext (and friends). I just checked and we seem to do so already. Could you explain to me why we need to go for the Last instruction in this patch at all? What would happen if you simply pick the first in the entry block, which is trivially correct. (Note: You can skip llvm.assume to make some weird problems go away).

The patch indeed defaults to the first instruction in the entry. Scanning to the end at safeCxtI() was an optimization for cases where the first instruction is an ephemeral value of an assume (which seems quite likely for assumes about arguments) that would get the assume discarded by the isEphemeralValueOf(Inv, CxtI) check. At isValidAssumeForContext() we can't distinguish between a context given only as a control-flow marker and a context that also guards against simplifying an ephemeral so we can't try to improve it there, but since any context safeCxtI() provides for a null CxtI is just a control-flow marker anyway we might as well choose one that's not an ephemeral of any assume in the entry block. Does that make sense?

[jdoerfert]

In D93974#2493287, @gilr wrote:

In D93974#2492979, @jdoerfert wrote:

The idea is that you can always do what you do here in isValidAssumeForContext (and friends). I just checked and we seem to do so already. Could you explain to me why we need to go for the Last instruction in this patch at all? What would happen if you simply pick the first in the entry block, which is trivially correct. (Note: You can skip llvm.assume to make some weird problems go away).

The patch indeed defaults to the first instruction in the entry. Scanning to the end at safeCxtI() was an optimization for cases where the first instruction is an ephemeral value of an assume (which seems quite likely for assumes about arguments) that would get the assume discarded by the isEphemeralValueOf(Inv, CxtI) check. At isValidAssumeForContext() we can't distinguish between a context given only as a control-flow marker and a context that also guards against simplifying an ephemeral so we can't try to improve it there, but since any context safeCxtI() provides for a null CxtI is just a control-flow marker anyway we might as well choose one that's not an ephemeral of any assume in the entry block. Does that make sense?

Yes. But your code does "more" than that. All you want is this pseudo-code, right?

auto &It = EntryBlock.begin();
while (isaAssumeIntrinsic(*It)) ++It;
return *It;

[gilr]

In D93974#2493403, @jdoerfert wrote:

In D93974#2493287, @gilr wrote:

In D93974#2492979, @jdoerfert wrote:

The idea is that you can always do what you do here in isValidAssumeForContext (and friends). I just checked and we seem to do so already. Could you explain to me why we need to go for the Last instruction in this patch at all? What would happen if you simply pick the first in the entry block, which is trivially correct. (Note: You can skip llvm.assume to make some weird problems go away).

The patch indeed defaults to the first instruction in the entry. Scanning to the end at safeCxtI() was an optimization for cases where the first instruction is an ephemeral value of an assume (which seems quite likely for assumes about arguments) that would get the assume discarded by the isEphemeralValueOf(Inv, CxtI) check. At isValidAssumeForContext() we can't distinguish between a context given only as a control-flow marker and a context that also guards against simplifying an ephemeral so we can't try to improve it there, but since any context safeCxtI() provides for a null CxtI is just a control-flow marker anyway we might as well choose one that's not an ephemeral of any assume in the entry block. Does that make sense?

Yes. But your code does "more" than that. All you want is this pseudo-code, right?

auto &It = EntryBlock.begin();
while (isaAssumeIntrinsic(*It)) ++It;
return *It;

Yes, if isaAssumeIntrinsic stands for "is an assume or an ephemeral of an assume". I suggested something like that in a previous comment:

An unbounded scan of the entry block might indeed be too much even if applied only to arguments. The scan can perhaps be limited to some small number of instructions (5 seems like the minimum to cover most patterns in computeKnownBits()) which gets reset if an assume is encountered.

(which could still of course skip over perfectly good instructions and choose an ephemeral as context if the assumes were not written right at function entry)

[jdoerfert]

In D93974#2493646, @gilr wrote:

Yes, if isaAssumeIntrinsic stands for "is an assume or an ephemeral of an assume".

Why is anything but an llvm.assume a problem? (Sorry I have so many questions)

[gilr]

In D93974#2493723, @jdoerfert wrote:

In D93974#2493646, @gilr wrote:

Yes, if isaAssumeIntrinsic stands for "is an assume or an ephemeral of an assume".

Why is anything but an llvm.assume a problem? (Sorry I have so many questions)

No problem, a chance to verify my understanding:
So a function such as

int f(int num) {
    __builtin_assume((num & 3) == 0);
    return num +1;
}

ompiles under -O3 -g0 -S -emit-llvm into:

define dso_local i32 @_Z1fi(i32 %0) local_unnamed_addr #0 {
  %2 = and i32 %0, 3
  %3 = icmp eq i32 %2, 0
  tail call void @llvm.assume(i1 %3)
  %4 = or i32 %0, 1
  ret i32 %4
}

Computing the known bits of %0 with %2 as the context would have isValidAssumeForContext() return false on the assume since %2 is one of its ephemeral values. Otherwise, simplifying %2 by computing %0's known bits would be logical bootstrapping - %0's assumed zero bits would be used to simplify %2 to zero, then %3 to true and the assume would be lost.

[jdoerfert]

In D93974#2494250, @gilr wrote:

define dso_local i32 @_Z1fi(i32 %0) local_unnamed_addr #0 {
  %2 = and i32 %0, 3
  %3 = icmp eq i32 %2, 0
  tail call void @llvm.assume(i1 %3)
  %4 = or i32 %0, 1
  ret i32 %4
}

Computing the known bits of %0 with %2 as the context would have isValidAssumeForContext() return false on the assume since %2 is one of its ephemeral values. Otherwise, simplifying %2 by computing %0's known bits would be logical bootstrapping - %0's assumed zero bits would be used to simplify %2 to zero, then %3 to true and the assume would be lost.

Oh.. this is bad. That happens if you mix two logically differnet things into a single instruction pointer. I put it on the list of things that need to fixed wrt. assumes ... :(

Thanks for the patience. I'm fine with the nullptr solution for now. I need to think more about this "workaround" before I'd suggest an alternative.

[gilr]

In D93974#2494331, @jdoerfert wrote:

Oh.. this is bad. That happens if you mix two logically differnet things into a single instruction pointer.
I put it on the list of things that need to fixed wrt. assumes ... :(

Excellent. Is the list published anywhere?

Thanks for the patience. I'm fine with the nullptr solution for now. I need to think more about this "workaround" before I'd suggest an alternative.

Sure, thanks for taking the time!

[jdoerfert]

In D93974#2496824, @gilr wrote:

In D93974#2494331, @jdoerfert wrote:

Oh.. this is bad. That happens if you mix two logically differnet things into a single instruction pointer.
I put it on the list of things that need to fixed wrt. assumes ... :(

Excellent. Is the list published anywhere?

No, but maybe I should do that. Here is what I remember right now:

• Distinguish between the context location for which an assumption is queried and the instructions for which it is queried. Basically what is going "wrong" here. I assume tracking what assumptions have been used is the most efficient and if some were used and their operands include the instruction to be optimized, don't. Alternatively, pass the instruction and avoid dependent assumes. Other options are sensible as well.
• We did 1) from https://lists.llvm.org/pipermail/llvm-dev/2019-December/137632.html but not 2) and 3) yet. 2) is needed to lower assert in release mode and arbitrary assumes to IR. 3) is needed, among other things, for pragma omp assumes and pragma omp assume, see https://clang.llvm.org/docs/AttributeReference.html#assume and https://www.openmp.org/spec-html/5.1/openmpsu37.html#x56-560002.5.2
• This was just a WIP, needs verification and test changes: https://reviews.llvm.org/D89054 . This will most likely flush out a few bugs in our non-speculatable call handling.
• Rewriting more "boolean" assumption to high-level assume bundles. We could for example do pointer comparisons with "eq/neq"(%ptr1, %ptr2) and then teach the capture checker that those uses do not capture.
• Continue to preserve knowledge whenever we modify the IR. There were some large regressions before, I hope D89054 will take care of some of that.

If you are interested in any of this, or something related, please let me know.

llvm/lib/Analysis/ValueTracking.cpp

static const Instruction *safeCxtI(const Value *V, const Instruction *CxtI) {
   if (CxtI && CxtI->getParent())
     return CxtI;
 
   // If the value is really an already-inserted instruction, then use that.
   CxtI = dyn_cast<Instruction>(V);
   if (CxtI && CxtI->getParent())
     return CxtI;
 
+  // If the value is a function argument, accept assumptions defined in the
+  // entry block if entering the function guarantees reaching them.
+  if (const Argument *Arg = dyn_cast<Argument>(V)) {
+    const Function *F = Arg->getParent();
+    if (!F || F->empty())
+      return nullptr;
+    const BasicBlock &Entry = F->getEntryBlock();
+    if (Entry.size() < 2) {
+      // Even if the only instruction is an assumption, it cannot be used as its
+      // own context.
+      return nullptr;
+    }
+
+    // First, to avoid potentially ephemeral values, try using the last
+    // instruction of the entry block as context.
+    const Instruction &Last = Entry.back();
+    bool MustReachLast = true;
+    for (auto I = Entry.begin(), E = Last.getIterator(); I != E; ++I) {
+      if (!isGuaranteedToTransferExecutionToSuccessor(&*I)) {
+        MustReachLast = false;
+        break;
+      }
+    }
+    if (MustReachLast)
+      return &Last;
+
+    // Use the first instruction in the entry block as the context. Making sure
+    // that control flow reaches assumptions in the entry block will be done by
+    // isValidAssumeForContext().
+    return &Entry.front();
+  }
+
   return nullptr;
 }
 
 static bool getShuffleDemandedElts(const ShuffleVectorInst *Shuf,
                                    const APInt &DemandedElts,
                                    APInt &DemandedLHS, APInt &DemandedRHS) {
   // The length of scalable vectors is unknown at compile time, thus we
   // cannot check their values

llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info.ll

 
 ; Test case for PR47247. Both the guard condition and the assume limit the
 ; max backedge-taken count.
 
 define void @test_guard_and_assume(i32* nocapture readonly %data, i64 %count) {
 ; CHECK-LABEL: 'test_guard_and_assume'
 ; CHECK-NEXT:  Classifying expressions for: @test_guard_and_assume
 ; CHECK-NEXT:    %iv = phi i64 [ %iv.next, %loop ], [ 0, %entry ]
-; CHECK-NEXT:    --> {0,+,1}<nuw><%loop> U: [0,4) S: [0,4) Exits: (-1 + %count) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {0,+,1}<nuw><%loop> U: [0,4) S: [0,4) Exits: (-1 + %count)<nsw> LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %idx = getelementptr inbounds i32, i32* %data, i64 %iv
-; CHECK-NEXT:    --> {%data,+,4}<nuw><%loop> U: full-set S: full-set Exits: (-4 + (4 * %count) + %data) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT:    --> {%data,+,4}<nuw><%loop> U: full-set S: full-set Exits: (-4 + (4 * %count)<nuw><nsw> + %data) LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:    %iv.next = add nuw i64 %iv, 1
 ; CHECK-NEXT:    --> {1,+,1}<nuw><%loop> U: [1,5) S: [1,5) Exits: %count LoopDispositions: { %loop: Computable }
 ; CHECK-NEXT:  Determining loop execution counts for: @test_guard_and_assume
 ; CHECK-NEXT:  Loop %loop: backedge-taken count is (-1 + %count)
 ; CHECK-NEXT:  Loop %loop: max backedge-taken count is 3
 ; CHECK-NEXT:  Loop %loop: Predicated backedge-taken count is (-1 + %count)
 ; CHECK-NEXT:   Predicates:
 ; CHECK:       Loop %loop: Trip multiple is 1

llvm/test/Transforms/LoopUnroll/runtime-unroll-assume-no-remainder.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt < %s -S -loop-unroll -unroll-runtime=true -unroll-runtime-epilog=true | FileCheck %s
+
+; Make sure the loop is unrolled without a remainder loop based on an assumption
+; that the lower bits are known to be zero.
+
+define dso_local void @assumeDivisibleTC(i8* noalias nocapture %a, i8* noalias nocapture readonly %b, i32 %n) local_unnamed_addr {
+; CHECK-LABEL: @assumeDivisibleTC(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[AND:%.*]] = and i32 [[N:%.*]], 3
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[AND]], 0
+; CHECK-NEXT:    tail call void @llvm.assume(i1 [[CMP]])
+; CHECK-NEXT:    [[CMP110:%.*]] = icmp sgt i32 [[N]], 0
+; CHECK-NEXT:    br i1 [[CMP110]], label [[FOR_BODY_PREHEADER:%.*]], label [[FOR_COND_CLEANUP:%.*]]
+; CHECK:       for.body.preheader:
+; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
+; CHECK:       for.cond.cleanup.loopexit:
+; CHECK-NEXT:    br label [[FOR_COND_CLEANUP]]
+; CHECK:       for.cond.cleanup:
+; CHECK-NEXT:    ret void
+; CHECK:       for.body:
+; CHECK-NEXT:    [[I_011:%.*]] = phi i32 [ 0, [[FOR_BODY_PREHEADER]] ], [ [[INC_3:%.*]], [[FOR_BODY]] ]
+; CHECK-NEXT:    [[IDXPROM:%.*]] = zext i32 [[I_011]] to i64
+; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds i8, i8* [[B:%.*]], i64 [[IDXPROM]]
+; CHECK-NEXT:    [[TMP0:%.*]] = load i8, i8* [[ARRAYIDX]], align 1
+; CHECK-NEXT:    [[ADD:%.*]] = add i8 [[TMP0]], 3
+; CHECK-NEXT:    [[ARRAYIDX4:%.*]] = getelementptr inbounds i8, i8* [[A:%.*]], i64 [[IDXPROM]]
+; CHECK-NEXT:    store i8 [[ADD]], i8* [[ARRAYIDX4]], align 1
+; CHECK-NEXT:    [[INC:%.*]] = add nuw nsw i32 [[I_011]], 1
+; CHECK-NEXT:    [[IDXPROM_1:%.*]] = zext i32 [[INC]] to i64
+; CHECK-NEXT:    [[ARRAYIDX_1:%.*]] = getelementptr inbounds i8, i8* [[B]], i64 [[IDXPROM_1]]
+; CHECK-NEXT:    [[TMP1:%.*]] = load i8, i8* [[ARRAYIDX_1]], align 1
+; CHECK-NEXT:    [[ADD_1:%.*]] = add i8 [[TMP1]], 3
+; CHECK-NEXT:    [[ARRAYIDX4_1:%.*]] = getelementptr inbounds i8, i8* [[A]], i64 [[IDXPROM_1]]
+; CHECK-NEXT:    store i8 [[ADD_1]], i8* [[ARRAYIDX4_1]], align 1
+; CHECK-NEXT:    [[INC_1:%.*]] = add nuw nsw i32 [[INC]], 1
+; CHECK-NEXT:    [[IDXPROM_2:%.*]] = zext i32 [[INC_1]] to i64
+; CHECK-NEXT:    [[ARRAYIDX_2:%.*]] = getelementptr inbounds i8, i8* [[B]], i64 [[IDXPROM_2]]
+; CHECK-NEXT:    [[TMP2:%.*]] = load i8, i8* [[ARRAYIDX_2]], align 1
+; CHECK-NEXT:    [[ADD_2:%.*]] = add i8 [[TMP2]], 3
+; CHECK-NEXT:    [[ARRAYIDX4_2:%.*]] = getelementptr inbounds i8, i8* [[A]], i64 [[IDXPROM_2]]
+; CHECK-NEXT:    store i8 [[ADD_2]], i8* [[ARRAYIDX4_2]], align 1
+; CHECK-NEXT:    [[INC_2:%.*]] = add nuw nsw i32 [[INC_1]], 1
+; CHECK-NEXT:    [[IDXPROM_3:%.*]] = zext i32 [[INC_2]] to i64
+; CHECK-NEXT:    [[ARRAYIDX_3:%.*]] = getelementptr inbounds i8, i8* [[B]], i64 [[IDXPROM_3]]
+; CHECK-NEXT:    [[TMP3:%.*]] = load i8, i8* [[ARRAYIDX_3]], align 1
+; CHECK-NEXT:    [[ADD_3:%.*]] = add i8 [[TMP3]], 3
+; CHECK-NEXT:    [[ARRAYIDX4_3:%.*]] = getelementptr inbounds i8, i8* [[A]], i64 [[IDXPROM_3]]
+; CHECK-NEXT:    store i8 [[ADD_3]], i8* [[ARRAYIDX4_3]], align 1
+; CHECK-NEXT:    [[INC_3]] = add nuw nsw i32 [[INC_2]], 1
+; CHECK-NEXT:    [[CMP1_3:%.*]] = icmp slt i32 [[INC_3]], [[N]]
+; CHECK-NEXT:    br i1 [[CMP1_3]], label [[FOR_BODY]], label [[FOR_COND_CLEANUP_LOOPEXIT:%.*]], [[LOOP0:!llvm.loop !.*]]
+;
+entry:
+  %and = and i32 %n, 3
+  %cmp = icmp eq i32 %and, 0
+  tail call void @llvm.assume(i1 %cmp)
+  %cmp110 = icmp sgt i32 %n, 0
+  br i1 %cmp110, label %for.body.preheader, label %for.cond.cleanup
+
+for.body.preheader:                               ; preds = %entry
+  br label %for.body
+
+for.cond.cleanup.loopexit:                        ; preds = %for.body
+  br label %for.cond.cleanup
+
+for.cond.cleanup:                                 ; preds = %for.cond.cleanup.loopexit, %entry
+  ret void
+
+for.body:                                         ; preds = %for.body.preheader, %for.body
+  %i.011 = phi i32 [ %inc, %for.body ], [ 0, %for.body.preheader ]
+  %idxprom = zext i32 %i.011 to i64
+  %arrayidx = getelementptr inbounds i8, i8* %b, i64 %idxprom
+  %0 = load i8, i8* %arrayidx, align 1
+  %add = add i8 %0, 3
+  %arrayidx4 = getelementptr inbounds i8, i8* %a, i64 %idxprom
+  store i8 %add, i8* %arrayidx4, align 1
+  %inc = add nuw nsw i32 %i.011, 1
+  %cmp1 = icmp slt i32 %inc, %n
+  br i1 %cmp1, label %for.body, label %for.cond.cleanup.loopexit, !llvm.loop !0
+}
+
+declare void @llvm.assume(i1 noundef) nofree nosync nounwind willreturn
+!0 = distinct !{!0, !1, !2}
+!1 = !{!"llvm.loop.mustprogress"}
+!2 = !{!"llvm.loop.unroll.count", i32 4}

llvm/test/Transforms/SimplifyCFG/pr46638.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -simplifycfg -simplifycfg-require-and-preserve-domtree=1 < %s | FileCheck %s
 
 define void @pr46638(i1 %c, i32 %x) {
 ; CHECK-LABEL: @pr46638(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i32 [[X:%.*]], 0
+; CHECK:         [[CMP1:%.*]] = icmp slt i32 [[X:%.*]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP1]])
 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[TRUE2_CRITEDGE:%.*]], label [[FALSE1:%.*]]
 ; CHECK:       false1:
 ; 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:    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 2)
 ; CHECK-NEXT:    ret void
 ;
+entry:
+  %cmp0 = icmp sgt i32 %x, -333
+  br i1 %cmp0, label %start, label %skip
+
+skip:
+  call void @dummy(i32 999)
+  ret void
+
+start:
   %cmp1 = icmp slt i32 %x, 0
   call void @llvm.assume(i1 %cmp1)
   br i1 %c, label %true1, label %false1
 
 true1:
   %cmp2 = icmp sgt i32 %x, 0
   %ext = zext i1 %cmp2 to i32
   call void @dummy(i32 %ext)

llvm/unittests/Analysis/ValueTrackingTest.cpp

TEST_F(ComputeKnownBitsTest, ComputeKnownBitsGEPWithRangeNoOverlap) {
   EXPECT_EQ(Known.Zero.getZExtValue(), ~512llu & ~(64llu - 1));
   EXPECT_EQ(Known.One.getZExtValue(), 512u | 32u);
   // The known range is not precise given computeKnownBits works
   // with the masks of zeros and ones, not the ranges.
   EXPECT_EQ(Known.getMinValue(), 544);
   EXPECT_EQ(Known.getMaxValue(), 575);
 }
 
+TEST_F(ValueTrackingTest, ComputeKnownBitsArgNoCxtI) {
+  // Take advantage of assumptions on arguments w/o a context.
+  parseAssembly(
+      "define void @test(i32 %x) {\n"
+      "  %A = and i32 %x, 31\n"
+      "  %c = icmp eq i32 %A, 0\n"
+      "  call void @llvm.assume(i1 %c)\n"
+      "  ret void\n"
+      "}\n"
+      "declare void @llvm.assume(i1)\n");
+  AssumptionCache AC(*F);
+  KnownBits Known = computeKnownBits(
+      F->getArg(0), M->getDataLayout(), /* Depth */ 0, &AC, nullptr);
+  EXPECT_EQ(Known.Zero.getZExtValue(), 31u);
+  EXPECT_EQ(Known.One.getZExtValue(), 0u);
+}
+
+TEST_F(ValueTrackingTest, ComputeKnownBitsArgNoCxtIFront) {
+  // Take advantage of assumptions on arguments w/o a context.
+  parseAssembly(
+      "define void @test(i32 %x) {\n"
+      "  %e = mul i32 %x, 7"
+      "  %A = and i32 %x, 31\n"
+      "  %c = icmp eq i32 %A, 0\n"
+      "  call void @llvm.assume(i1 %c)\n"
+      "  call void @may.not.transfer.execution.to.successor()\n"
+      "  ret void\n"
+      "}\n"
+      "declare void @llvm.assume(i1)\n"
+      "declare void @may.not.transfer.execution.to.successor()\n");
+  AssumptionCache AC(*F);
+  KnownBits Known = computeKnownBits(
+      F->getArg(0), M->getDataLayout(), /* Depth */ 0, &AC, nullptr);
+  EXPECT_EQ(Known.Zero.getZExtValue(), 31u);
+  EXPECT_EQ(Known.One.getZExtValue(), 0u);
+}
+
+TEST_F(ValueTrackingTest, ComputeKnownBitsArgNoCxtIInvalid) {
+  // Do not take advantage of assumptions on arguments w/o a context if control
+  // is not guaranteed to reach them.
+  parseAssembly(
+      "define void @test(i32 %x) {\n"
+      "  %e = mul i32 %x, 7"
+      "  %A = and i32 %x, 31\n"
+      "  %c = icmp eq i32 %A, 0\n"
+      "  call void @may.not.transfer.execution.to.successor()\n"
+      "  call void @llvm.assume(i1 %c)\n"
+      "  call void @may.not.transfer.execution.to.successor()\n"
+      "  ret void\n"
+      "}\n"
+      "declare void @llvm.assume(i1)\n"
+      "declare void @may.not.transfer.execution.to.successor()\n");
+  AssumptionCache AC(*F);
+  KnownBits Known = computeKnownBits(
+      F->getArg(0), M->getDataLayout(), /* Depth */ 0, &AC, nullptr);
+  EXPECT_EQ(Known.Zero.getZExtValue(), 0u);
+  EXPECT_EQ(Known.One.getZExtValue(), 0u);
+}
+
 class IsBytewiseValueTest : public ValueTrackingTest,
                             public ::testing::WithParamInterface<
                                 std::pair<const char *, const char *>> {
 protected:
 };
 
 const std::pair<const char *, const char *> IsBytewiseValueTests[] = {
     {