[ValueTracking] Handle assumes on arguments with context instruction

[nikic]

Summary

This is an alternative to D93974 and D97077. If CtxI is null, then we can still make use of any assumes that are guaranteed to be executed from the entry of the function. This allows us to handle assumes on arguments, for cases where no explicit context instruction is provided.

Relative to D93974 the advantage here is that we only need to do the "guaranteed to execute" check if there are potentially relevant assumes, rather than always doing it. Relative to D97077 the advantage is that this is not SCEV specific, and avoids issues with ephemeral values (i.e., we support assumes directly at the start of the function).

This change has no compile-time impact on CTMark, though that isn't exactly an assume heavy workload.

The unit tests are adopted from D93974.

[jdoerfert]

I like this idea. As I mentioned before, we should check the willreturn and nounwind function attribute to avoid scanning all together, but that is again only partially related.

LG from me, someone else might want to chime in as well.

[reames]

I posted another alternative (or maybe a stepping stone towards this one), over in D97099. It simply sets the context for arguments, and uses the existing mechanism. The key detail from this patch is that it doesn't attempt to side step the ephemeral value case.

For the ephemeral value case, I'd really like to have a solution which is not non-instruction specific. If we asking a query on some instruction I, the fact that I is directly used by the assume should not prevent us from inferring facts about that assume.

The test case I'm thinking of is something like the following:

declare void @llvm.assume(i1)

define i32 @test(i1* %p) {

%a = load i1, i1* %p
call void @llvm.assume(i1 %a)
%a.32 = sext i1 %a to i32
ret i32 %a.32

}

$ opt -enable-new-pm=0 -analyze -scalar-evolution ephemeral.ll
Printing analysis 'Scalar Evolution Analysis' for function 'test':
Classifying expressions for: @test

%a = load i1, i1* %p, align 1
-->  %a U: full-set S: full-set
%a.32 = sext i1 %a to i32
-->  (sext i1 %a to i32) U: [-1,1) S: [-1,1) <--- FOCUS HERE

Determining loop execution counts for: @test

From this, we appear to not be picking up the assume on %a - as I'd expect from the code structure.

Interestingly, instcombine does constant fold this. This is because instcombine queries the sext directly with the context set to the sext and that gets preserved through the recursion. So unlikely SCEV's usage, when analyzing %a (the load) inscombine has a context set. This explains the difference in behavior.

Having said all that, I also don't want to block progress on perfection, and this does seem like progress. If you want to land this as is, and we can iterate in tree, I'm completely fine with that. (To be explicit, you can consider this a long winded LGTM.)

(Edited to clarify instcombine bit)

[reames]

Thinking about it further, there's one property that results from this approach that I really don't like. After this patch, there will be cases where setting a context instruction *pessimizes* the result returned over not including one. That's really not supposed to happen. In particular, it means that for some use cases (analyzing assume calls) forgetting a context instruction now becomes a miscompile. That seems unpleasant.

[reames]

Continuing from my last comment, I've come to believe this change is fatally flawed. Let me explain the problem I see. I haven't found a practical test case yet, so it's possible I'm wrong about this.

As noted previously, when analyzing an assume, we must pass in a context instruction to prevent using the assumption in forming facts about the conditions contributing to the assume (when that assume is in the entry block and involves an argument). The problem is that SCEV does not do so, and in fact, can not. As a result, SCEV will infer facts about the values which hold because of the assume. If we can trick any SCEV based transform pass into optimizing the assume condition, we've created the exact condition that the ephemeral logic code exists to prevent.

Until this concern has been addressed, please consider my previous LGTM revoked.

[nikic]

In D97092#2576234, @reames wrote:

As noted previously, when analyzing an assume, we must pass in a context instruction to prevent using the assumption in forming facts about the conditions contributing to the assume (when that assume is in the entry block and involves an argument). The problem is that SCEV does not do so, and in fact, can not. As a result, SCEV will infer facts about the values which hold because of the assume. If we can trick any SCEV based transform pass into optimizing the assume condition, we've created the exact condition that the ephemeral logic code exists to prevent.

You're correct, but I don't think you've followed this thought to its logical conclusion. The difference between the different approaches we have isn't whether ephemeral values get ignored, it's whether they get ignored intentionally, or accidentally.

foo(int a, int b) {
    assume(a != 0);
    assume(b != 0);
}
foo(int a, int b) {
    assume(b != 0);
    assume(a != 0);
}

This patch is going to use both assumption consistently. Approaches that set context to the first instruction will use the second assume in each function, but not the first. In either case, if the analysis result is used to fold the assume conditions, we may end up eliminating non-redundant assumes.

This is a problem that will affect any approach that uses assumes on the value itself without an explicit context instruction that guarantees that assume conditions will not get folded. And I think you're right that we should avoid this. That does mean that all four patches are ultimately broken (heh).

For SCEV, the right approach would probably be to do something similar to LVI, and take assumptions into account not directly on the value itself, but on each use, i.e. assume(x >= 0); x >> 1 would apply the assume only when computing the range of x >> 1.

[reames]

In D97092#2576506, @nikic wrote:

And I think you're right that we should avoid this. That does mean that all four patches are ultimately broken (heh).

Unfortunately, I think you're right. I spent way more time this weekend trying to find a principled work around, and nothing I've found so far works. I'm not quite ready to admit defeat here, but this does appear to be a hard to bypass problem.

One point worth highlighting is that the bad thing we're trying to avoid is a loss of the information encoded in an assume. It's not a correctness issue. From a purely pragmatic perspective, we may wish to explore whether the benefit of increased inference is worth the information loss. I suspect that tradeoff is different for each patch, and I have not really explored in that direction yet. It's also worth noting that the current mechanism does allow some assumes to be removed, so we wouldn't be adding that behavior.

For SCEV, the right approach would probably be to do something similar to LVI, and take assumptions into account not directly on the value itself, but on each use, i.e. assume(x >= 0); x >> 1 would apply the assume only when computing the range of x >> 1.

Unfortunately, this would be a fairly major redesign of SCEV. I don't think this is a practical path forward. The main problem is that SCEV doesn't track an explicit use list for SCEVExprs.

[reames]

One idea on an alternate approach we could explore...

In the langref, we have an alternate way of spelling assumes using operand bundles. The key advantage of that approach (in the context of this discussion), is that there are no ephemeral icmps generated. We still have to concern ourselves with not eliminating assumes, but at least the assumes are themselves direct uses of the values we're inferring facts about.

If we were to extend the operand bundle syntax to allow arbitrary predicates, we could allow the use of the operand bundle assumes without a context, and simply restrict transform passes from *directly* simplifying assume operands. The only tricky case I see here is equalities as CSE would tend to replace the operands in the deopt bundle if e.g. instsimplify knew two values were equivalent from the assume. (I haven't fully thought this through.)

If we do pursue this, we'd need to untangle the operand bundle form handling from the knowledge transfer work, but that doesn't seem challenging. I'm not sure why those are coupled currently anyways.

[jdoerfert]

[EDIT: I wrote this before I saw the last comment ;) ]

If you move the information into the operand bundle: llvm.assume(i1 true) ["icmp.eq"(%a, %b)] ["icmp.le"(%p, 0)] this problem goes away, doesn't it?
If so, there is also the outline approach which has many other benefits (https://lists.llvm.org/pipermail/llvm-dev/2019-December/137632.html):

llvm.assume(i1 true) ["assertion_fn"(%a, %b, %p)]
static void assertion_fn(%a, %b, %p) {
  %c0 = icmp eq %a, %b
  llvm.assume(%c0)
  %c1 = icmp le %p, 0
  llvm.assume(%c1)
  // or ret `and c0, c1`
}

[nikic]

Just to clarify one thing: The (general) ephemeral value problem is a bit more complicated in that we actually *do* want to fold assume conditions -- just not on themselves. For example, if you have assume(x > 0); assume(x > 1);, then it is expected that the second assume gets folded away, because it is implied by the first and thus redundant. I don't think assume operand bundles fundamentally change the picture here, they just make it easier to identify ephemeral values.

[jdoerfert]

EDIT: submitted a half-baked answer I forgot I was typing with a new one -.- after hitting the "quote" button the old text was basically hidden.

In D97092#2579184, @reames wrote:

One idea on an alternate approach we could explore...

In the langref, we have an alternate way of spelling assumes using operand bundles. The key advantage of that approach (in the context of this discussion), is that there are no ephemeral icmps generated. We still have to concern ourselves with not eliminating assumes, but at least the assumes are themselves direct uses of the values we're inferring facts about.

If we were to extend the operand bundle syntax to allow arbitrary predicates, we could allow the use of the operand bundle assumes without a context, and simply restrict transform passes from *directly* simplifying assume operands. The only tricky case I see here is equalities as CSE would tend to replace the operands in the deopt bundle if e.g. instsimplify knew two values were equivalent from the assume. (I haven't fully thought this through.)

I think operand bundles are not "accidentally" removed because it is easy to determine if they are assume bundle uses. (I would argue that you don't want to optimize "unknown" bundle uses in general but that is a different conversation.)

If we do pursue this, we'd need to untangle the operand bundle form handling from the knowledge transfer work, but that doesn't seem challenging. I'm not sure why those are coupled currently anyways.

Because that was the only use case. Untangling is eventually needed for sure.

In D97092#2579797, @nikic wrote:

Just to clarify one thing: The (general) ephemeral value problem is a bit more complicated in that we actually *do* want to fold assume conditions -- just not on themselves. For example, if you have assume(x > 0); assume(x > 1);, then it is expected that the second assume gets folded away, because it is implied by the first and thus redundant. I don't think assume operand bundles fundamentally change the picture here, they just make it easier to identify ephemeral values.

It does because you can identify assume uses easily. So you can ask if x > 1 is known not using the particular use of x for the reasoning.

llvm/lib/Analysis/ValueTracking.cpp

bool llvm::isValidAssumeForContext(const Instruction *Inv,
   // There are two restrictions on the use of an assume:
   //  1. The assume must dominate the context (or the control flow must
   //     reach the assume whenever it reaches the context).
   //  2. The context must not be in the assume's set of ephemeral values
   //     (otherwise we will use the assume to prove that the condition
   //     feeding the assume is trivially true, thus causing the removal of
   //     the assume).
 
-  if (Inv->getParent() == CxtI->getParent()) {
+  auto GuaranteedToExecuteInvFrom = [&](BasicBlock::const_iterator I) {
+    // We limit the scan distance between the context instruction and the assume
+    // to avoid a compile-time explosion. This limit is chosen arbitrarily, so
+    // it can be adjusted if needed (could be turned into a cl::opt).
+    unsigned ScanLimit = 15;
+    for (BasicBlock::const_iterator IE(Inv); I != IE; ++I)
+      if (!isGuaranteedToTransferExecutionToSuccessor(&*I) || --ScanLimit == 0)
+        return false;
+    return true;
+  };
+
+  const BasicBlock *InvBB = Inv->getParent();
+  if (!CxtI) {
+    // If there is no context instruction, assume the start of the entry block
+    // as context, and see whether the assume is guaranteed reachable from
+    // there.
+    if (InvBB != &InvBB->getParent()->getEntryBlock())
+      return false;
+
+    return GuaranteedToExecuteInvFrom(InvBB->begin());
+  }
+
+  if (InvBB == CxtI->getParent()) {
     // If Inv and CtxI are in the same block, check if the assume (Inv) is first
     // in the BB.
     if (Inv->comesBefore(CxtI))
       return true;
 
     // Don't let an assume affect itself - this would cause the problems
     // `isEphemeralValueOf` is trying to prevent, and it would also make
     // the loop below go out of bounds.
     if (Inv == CxtI)
       return false;
 
     // The context comes first, but they're both in the same block.
     // Make sure there is nothing in between that might interrupt
     // the control flow, not even CxtI itself.
-    // We limit the scan distance between the assume and its context instruction
-    // to avoid a compile-time explosion. This limit is chosen arbitrarily, so
-    // it can be adjusted if needed (could be turned into a cl::opt).
-    unsigned ScanLimit = 15;
-    for (BasicBlock::const_iterator I(CxtI), IE(Inv); I != IE; ++I)
-      if (!isGuaranteedToTransferExecutionToSuccessor(&*I) || --ScanLimit == 0)
-        return false;
-
-    return !isEphemeralValueOf(Inv, CxtI);
+    return GuaranteedToExecuteInvFrom(CxtI->getIterator()) &&
+           !isEphemeralValueOf(Inv, CxtI);
   }
 
   // Inv and CxtI are in different blocks.
   if (DT) {
     if (DT->dominates(Inv, CxtI))
       return true;
-  } else if (Inv->getParent() == CxtI->getParent()->getSinglePredecessor()) {
+  } else if (InvBB == CxtI->getParent()->getSinglePredecessor()) {
     // We don't have a DT, but this trivially dominates.
     return true;
   }
 
   return false;
 }
 
 static bool cmpExcludesZero(CmpInst::Predicate Pred, const Value *RHS) {
if (cmpExcludesZero(Pred, RHS) && isValidAssumeForContext(I, Q.CxtI, Q.DT))
       return true;
   }
 
   return false;
 }
 
 static void computeKnownBitsFromAssume(const Value *V, KnownBits &Known,
                                        unsigned Depth, const Query &Q) {
-  // Use of assumptions is context-sensitive. If we don't have a context, we
-  // cannot use them!
-  if (!Q.AC || !Q.CxtI)
+  if (!Q.AC)
     return;
 
   unsigned BitWidth = Known.getBitWidth();
 
   // Refine Known set if the pointer alignment is set by assume bundles.
   if (V->getType()->isPointerTy()) {
     if (RetainedKnowledge RK = getKnowledgeValidInContext(
             V, {Attribute::Alignment}, Q.CxtI, Q.DT, Q.AC)) {
       Known.Zero.setLowBits(Log2_32(RK.ArgValue));
     }
   }
 
   // Note that the patterns below need to be kept in sync with the code
   // in AssumptionCache::updateAffectedValues.
 
   for (auto &AssumeVH : Q.AC->assumptionsFor(V)) {
     if (!AssumeVH)
       continue;
     CallInst *I = cast<CallInst>(AssumeVH);
-    assert(I->getParent()->getParent() == Q.CxtI->getParent()->getParent() &&
-           "Got assumption for the wrong function!");
     if (Q.isExcluded(I))
       continue;
 
     // Warning: This loop can end up being somewhat performance sensitive.
     // We're running this loop for once for each value queried resulting in a
     // runtime of ~O(#assumes * #values).
 
     assert(I->getCalledFunction()->getIntrinsicID() == Intrinsic::assume &&

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: backedge-taken count is (-1 + %count)<nsw>
 ; CHECK-NEXT:  Loop %loop: max backedge-taken count is 3
-; CHECK-NEXT:  Loop %loop: Predicated backedge-taken count is (-1 + %count)
+; CHECK-NEXT:  Loop %loop: Predicated backedge-taken count is (-1 + %count)<nsw>
 ; CHECK-NEXT:   Predicates:
 ; CHECK:       Loop %loop: Trip multiple is 1
 ;
 entry:
   %cmp = icmp ult i64 %count, 5
   tail call void @llvm.assume(i1 %cmp)
   %cmp18.not = icmp eq i64 %count, 0
   br i1 %cmp18.not, label %exit, label %loop

llvm/test/Analysis/ScalarEvolution/ranges.ll

;
   ret i64 %ashr
 }
 
 
 define i32 @shl(i32 %a) {
 ; CHECK-LABEL: 'shl'
 ; CHECK-NEXT:  Classifying expressions for: @shl
 ; CHECK-NEXT:    %res = shl i32 %a, 2
-; CHECK-NEXT:    --> (4 * %a) U: [0,-3) S: [-2147483648,2147483645)
+; CHECK-NEXT:    --> (4 * %a)<nuw><nsw> U: [0,4093) S: [0,4093)
 ; CHECK-NEXT:  Determining loop execution counts for: @shl
 ;
   %res = shl i32 %a, 2
   %pos = icmp ult i32 %a, 1024
   call void @llvm.assume(i1 %pos)
   ret i32 %res
 }
 
 define i32 @lshr(i32 %a) {
 ; CHECK-LABEL: 'lshr'
 ; CHECK-NEXT:  Classifying expressions for: @lshr
 ; CHECK-NEXT:    %res = lshr i32 %a, 31
-; CHECK-NEXT:    --> (%a /u -2147483648) U: [0,2) S: [0,2)
+; CHECK-NEXT:    --> (%a /u -2147483648) U: [0,1) S: [0,1)
 ; CHECK-NEXT:  Determining loop execution counts for: @lshr
 ;
   %res = lshr i32 %a, 31
   %pos = icmp sge i32 %a, 0
   call void @llvm.assume(i1 %pos)
   ret i32 %res
 }
 
 
 define i32 @udiv(i32 %a) {
 ; CHECK-LABEL: 'udiv'
 ; CHECK-NEXT:  Classifying expressions for: @udiv
 ; CHECK-NEXT:    %res = udiv i32 %a, -2147483648
-; CHECK-NEXT:    --> (%a /u -2147483648) U: [0,2) S: [0,2)
+; CHECK-NEXT:    --> (%a /u -2147483648) U: [0,1) S: [0,1)
 ; CHECK-NEXT:  Determining loop execution counts for: @udiv
 ;
   %res = udiv i32 %a, 2147483648
   %pos = icmp sge i32 %a, 0
   call void @llvm.assume(i1 %pos)
   ret i32 %res
 }
 
 define i64 @sext(i8 %a) {
 ; CHECK-LABEL: 'sext'
 ; CHECK-NEXT:  Classifying expressions for: @sext
 ; CHECK-NEXT:    %res = sext i8 %a to i64
-; CHECK-NEXT:    --> (sext i8 %a to i64) U: [-128,128) S: [-128,128)
+; CHECK-NEXT:    --> (zext i8 %a to i64) U: [0,128) S: [0,128)
 ; CHECK-NEXT:  Determining loop execution counts for: @sext
 ;
   %res = sext i8 %a to i64
   %pos = icmp sge i8 %a, 0
   call void @llvm.assume(i1 %pos)
   ret i64 %res
 }
 
 define i64 @zext(i8 %a) {
 ; CHECK-LABEL: 'zext'
 ; CHECK-NEXT:  Classifying expressions for: @zext
 ; CHECK-NEXT:    %res = zext i8 %a to i64
-; CHECK-NEXT:    --> (zext i8 %a to i64) U: [0,256) S: [0,256)
+; CHECK-NEXT:    --> (zext i8 %a to i64) U: [0,128) S: [0,128)
 ; CHECK-NEXT:  Determining loop execution counts for: @zext
 ;
   %res = zext i8 %a to i64
   %pos = icmp sge i8 %a, 0
   call void @llvm.assume(i1 %pos)
   ret i64 %res
 }

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-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 0)
 ; CHECK-NEXT:    call void @dummy(i32 2)
 ; CHECK-NEXT:    ret void
 ;
   %cmp1 = icmp slt i32 %x, 0
   call void @llvm.assume(i1 %cmp1)
   br i1 %c, label %true1, label %false1
 
 true1:

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[] = {
     {