[InstSimplify] Simplify icmp between Shl instructions of the same value

[MattDevereau]

Summary

[InstSimplify] Simplify icmp between Shl instructions of the same value

define i1 @compare_vscales() {
  %vscale = call i64 @llvm.vscale.i64()
  %vscalex2 = shl nuw nsw i64 %vscale, 1
  %vscalex4 = shl nuw nsw i64 %vscale, 2
  %cmp = icmp ult i64 %vscalex2, %vscalex4
  ret i1 %cmp
}

This IR is currently emitted by LLVM. This icmp is redundant as this snippet
can be simplified to true or false as both operands originate from the same
@llvm.vscale.i64() call.

Proof of concept:
https://alive2.llvm.org/ce/z/KCrE8j
https://alive2.llvm.org/ce/z/wH8vBN

[sdesmalen]

llvm/lib/Analysis/InstructionSimplify.cpp

3652

Does it matter that this is value is vscale ?

I would expect that:

• (X << C1) < (X << C2) == true for any value X for any C1 < C2
• (X << C1) <= (X << C2) == true for any value X for any C1 <= C2
• (X << C1) > (X << C2) == true for any value X for any C1 > C2
• ...

[MattDevereau]

llvm/lib/Analysis/InstructionSimplify.cpp

3652

Very true, I think I got a bit too tunnel visioned on the original test case. I will replace the vscale checks with m_Value for LHS and m_Deferred for RHS, and remove any references to vscale in names

[dmgreen]

llvm/lib/Analysis/InstructionSimplify.cpp

3652

Make sure you check the value isn't 0, and it can be good to provide alive proofs.

[MattDevereau]

llvm/lib/Analysis/InstructionSimplify.cpp

3652

Noted, thank you

[MattDevereau]

llvm/lib/Analysis/InstructionSimplify.cpp

3652

https://alive2.llvm.org/ce/z/UAsDSn This alive test shows the transformation is not valid for the case where value is 0, however
I'm not sure how to write a test to assert the not-zero 0 check here, something simple like

define i1 @compare_zeroes_foo() {
; CHECK-LABEL: @compare_zeroes_foo(
; CHECK-NEXT:    ret i1 false
;
  %shl1 = shl nuw nsw i64 0, 1
  %shl2 = shl nuw nsw i64 0, 2
  %cmp = icmp ult i64 %shl1, %shl2
  ret i1 %cmp
}

Has already optimized away the shifts by the time it reaches my added function simplifyICmpLShiftedValues, and when LHS and RHS are both ConstantInt 0 this will be optimized to return i1 false by ConstantFoldCompareInstOperands above. I'm not sure if a simple check such as

  ConstantInt *IntLHS, *IntRHS;
  Value* V;
  if (!match(LHS, m_Shl(m_Value(V), m_ConstantInt(IntLHS))) ||
      !match(RHS, m_Shl(m_Deferred(V), m_ConstantInt(IntRHS))) ||
      LHS->getType() != RHS->getType())
    return nullptr;

  if(auto ConstantIntV = dyn_cast<ConstantInt>(V)){
    if(ConstantIntV->isZero())
      return nullptr;
  }
...

Is sufficient or even necessary here.

[spatel]

To generalize the pattern, you probably want to use isKnownNonZero() to check that the shifted value always has some bits set. That function appears to already know that the result of a vscale call is always non zero.
The simplest regression test to verify that would include an or with constant to set some bit(s).

The larger shift needs to have "nuw" (don't shift out any set bits) to guarantee that an unsigned comparison holds; "nuw" and "nsw" are needed to reduce a signed comparison?
Here's a generalized proof for 'ugt':
https://alive2.llvm.org/ce/z/Q6J6qn
You'd need to adapt that for each predicate to make sure we have the right constraints on the transform.

[nikic]

llvm/lib/Analysis/InstructionSimplify.cpp

3654

Prefer m_APInt

3658

Use cast<OverflowingBinaryOperator>, otherwise this might crash for constant expressions.

3692

There is an ICmpInst::compare() helper that takes a predicate and APInts -- this code can probably be simplified based on that?

3962

Should probably be called from simplifyICmpWithBinOp. Also, it looks like a very similar fold already exists there: https://github.com/llvm/llvm-project/blob/bde5d31e96f556fed30bf9120cc6ff05a2116b64/llvm/lib/Analysis/InstructionSimplify.cpp#L3426-L3436 This seems to be the same, just on different operands of the shift. Possibly that could serve as inspiration on how to implement this more compactly.

[MattDevereau]

llvm/lib/Analysis/InstructionSimplify.cpp

3692

ICmpInst::compare() works perfectly, thank you

3962

I've moved this to be inside simplifyICmpWithBinOp and close to where you suggested. However this required checking the 0th operands of the binops for equality instead of comparing the 1st operands of the binops like where you suggested did.

[nikic]

llvm/lib/Analysis/InstructionSimplify.cpp

3264

I don't think the types can differ.

3273

These checks should go through Q.IIQ.

3281

I believe we could return simplifyICmpInst(Pred, ShiftAmountL, ShiftAmountR, Q, MaxRecurse -1) here, without the limitation to constant shift amounts. The only disadvantage to that would be that we would have to require the nuw/nsw flags on both shifts, rather than only on the largest one (as we wouldn't know which one is the largest is without further effort).

This would allow handling comparisons between shl %v, %s and %shl %v, (add nuw %s, 1) or similar.

[MattDevereau]

llvm/lib/Analysis/InstructionSimplify.cpp

3273

I've made them use Q.IIQ now, and I've moved the checks a level higher, since similar code in simplifyICmpWithBinOp exists for when the shift amounts are equal for an ICmp with two shl operands there.

3281

Hopefully I've understood what you mean here and implemented this correctly. I inverted the logic of the matches and replaced return getFalse(getCompareTy(LHS)); with your suggestion which works ok, however returning your suggestion for any non match caused several test failures elsewhere and resulted in some miscompiles

[sdesmalen]

llvm/lib/Analysis/InstructionSimplify.cpp

3258

This function isn't really needed, see my other comment further down for details.

3423

It might be useful to bail out here if this part of the condition is false, such that you can have two indented blocks below:

if (!MaxRecurse || !LBO || !RBO || LBO->getOpcode() != RBO->getOpcode())
  return nullptr;

if (LBO->getOperand(0) == RBO->getOperand(0)) {
  ..
}

if (LBO->getOperand(1) == RBO->getOperand(1)) {
  ..
}

return nullptr;

That avoids having to indent the existing block (LBO->getOperand(1) == RBO->getOperand(1) ) below.

3436

Rather than calling simplifyICmpWithShl here, you can just compare the shift-amounts directly, i.e.

if (Value *V = simplifyICmpInst(Pred, LBO->getOperand(1),
                               RBO->getOperand(1), Q, MaxRecurse - 1))
 return V;

You only need to add an extra check to ensure that LBO->getOperand(0) is known non-zero.

[MattDevereau]

@sdesmalen Thanks, I've put in your comments, the patch looks a lot more compact now.

[nikic]

Can you please include the relevant alive2 proofs for the transform in the patch description? Should be something along the lines of https://alive2.llvm.org/ce/z/KCrE8j and https://alive2.llvm.org/ce/z/wH8vBN I think. Notably, a signed predicate requires *both* nuw and nsw. I don't think this is correctly enforced right now?

Can you please also pre-commit the tests?

[sdesmalen]

llvm/test/Transforms/InstSimplify/compare.ll

2918

nit: this name is a bit confusing, I'm not sure what you mean with 'nuw_nsw_smallest_shift' ?

2933

Can you just use %x and %y instead of @llvm.vscale here?

It would be good also to have at least one positive test with @llvm.vscale(), could you please add one?

[MattDevereau]

llvm/test/Transforms/InstSimplify/compare.ll

2918

The idea here was that based on https://alive2.llvm.org/ce/z/YCbQCH, only the larger shift value needed to have nuw/(nuw && nsw) flags on it for the combine to be valid. However it's probably easier and more versatile to do the more generic combine (https://alive2.llvm.org/ce/z/tSyv_m), so this test can be replaced with something more appropriate

2933

Sure, I will add this and move the tests into a different patch and pre-commit them

[MattDevereau]

@nikic I've precommited the tests, and added your alive examples to the description. I've changed the flag condition to if (!NUW || (ICmpInst::isSigned(Pred) && !NSW)to assert NUW for unsigned and NUW and NSW for signed. I've added two tests neg_icmp_lshr_known_non_zero_slt_no_nuw and neg_icmp_lshr_known_non_zero_ult_no_nuw which assert the correct flag conditions.

[nikic]

LGTM

llvm/test/Transforms/InstSimplify/compare.ll

2886

Based on test name, this was supposed to be ult?

[MattDevereau]

This comment has been deleted.

llvm/test/Transforms/InstSimplify/compare.ll

2886

Correct, I will update this before pushing, thank you.

llvm/lib/Analysis/InstructionSimplify.cpp

static bool trySimplifyICmpWithAdds(CmpInst::Predicate Pred, Value *LHS,
   if (!match(LHS, m_c_Add(m_Value(X), m_APInt(C1))) ||
       !match(RHS, m_c_Add(m_Specific(X), m_APInt(C2))))
     return false;
 
   return (C1->slt(*C2) && C1->isNonNegative()) ||
          (C2->slt(*C1) && C1->isNonPositive());
 }
 
 /// TODO: A large part of this logic is duplicated in InstCombine's
 /// foldICmpBinOp(). We should be able to share that and avoid the code
 /// duplication.
 static Value *simplifyICmpWithBinOp(CmpInst::Predicate Pred, Value *LHS,
                                     Value *RHS, const SimplifyQuery &Q,
                                     unsigned MaxRecurse) {
   BinaryOperator *LBO = dyn_cast<BinaryOperator>(LHS);
   BinaryOperator *RBO = dyn_cast<BinaryOperator>(RHS);
   if (MaxRecurse && (LBO || RBO)) {
     // Analyze the case when either LHS or RHS is an add instruction.
     Value *A = nullptr, *B = nullptr, *C = nullptr, *D = nullptr;
     // LHS = A + B (or A and B are null); RHS = C + D (or C and D are null).
     bool NoLHSWrapProblem = false, NoRHSWrapProblem = false;
     if (LBO && LBO->getOpcode() == Instruction::Add) {
       A = LBO->getOperand(0);
       B = LBO->getOperand(1);
       NoLHSWrapProblem =
           ICmpInst::isEquality(Pred) ||
           (CmpInst::isUnsigned(Pred) &&
            Q.IIQ.hasNoUnsignedWrap(cast<OverflowingBinaryOperator>(LBO))) ||
           (CmpInst::isSigned(Pred) &&
            Q.IIQ.hasNoSignedWrap(cast<OverflowingBinaryOperator>(LBO)));
     }
     if (RBO && RBO->getOpcode() == Instruction::Add) {
       C = RBO->getOperand(0);
       D = RBO->getOperand(1);
       NoRHSWrapProblem =
           ICmpInst::isEquality(Pred) ||
           (CmpInst::isUnsigned(Pred) &&
            Q.IIQ.hasNoUnsignedWrap(cast<OverflowingBinaryOperator>(RBO))) ||
           (CmpInst::isSigned(Pred) &&
            Q.IIQ.hasNoSignedWrap(cast<OverflowingBinaryOperator>(RBO)));
static Value *simplifyICmpWithBinOp(CmpInst::Predicate Pred, Value *LHS,
   // (1 << X) <=u 0x8000 --> true
   if (match(LHS, m_Shl(m_One(), m_Value())) && match(RHS, m_SignMask())) {
     if (Pred == ICmpInst::ICMP_UGT)
       return ConstantInt::getFalse(getCompareTy(RHS));
     if (Pred == ICmpInst::ICMP_ULE)
       return ConstantInt::getTrue(getCompareTy(RHS));
   }
 
-  if (MaxRecurse && LBO && RBO && LBO->getOpcode() == RBO->getOpcode() &&
-      LBO->getOperand(1) == RBO->getOperand(1)) {
+  if (!MaxRecurse || !LBO || !RBO || LBO->getOpcode() != RBO->getOpcode())
+    return nullptr;
+
+  if (LBO->getOperand(0) == RBO->getOperand(0)) {
+    switch (LBO->getOpcode()) {
+    default:
+      break;
+    case Instruction::Shl:
+      bool NUW = Q.IIQ.hasNoUnsignedWrap(LBO) && Q.IIQ.hasNoUnsignedWrap(RBO);
+      bool NSW = Q.IIQ.hasNoSignedWrap(LBO) && Q.IIQ.hasNoSignedWrap(RBO);
+      if (!NUW || (ICmpInst::isSigned(Pred) && !NSW) ||
+          !isKnownNonZero(LBO->getOperand(0), Q.DL))
+        break;
+      if (Value *V = simplifyICmpInst(Pred, LBO->getOperand(1),
+                                      RBO->getOperand(1), Q, MaxRecurse - 1))
+        return V;
+    }
+  }
+
+  if (LBO->getOperand(1) == RBO->getOperand(1)) {
     switch (LBO->getOpcode()) {
     default:
       break;
     case Instruction::UDiv:
     case Instruction::LShr:
       if (ICmpInst::isSigned(Pred) || !Q.IIQ.isExact(LBO) ||
           !Q.IIQ.isExact(RBO))
         break;
       if (Value *V = simplifyICmpInst(Pred, LBO->getOperand(0),
                                       RBO->getOperand(0), Q, MaxRecurse - 1))
         return V;
       break;
     case Instruction::SDiv:
       if (!ICmpInst::isEquality(Pred) || !Q.IIQ.isExact(LBO) ||
           !Q.IIQ.isExact(RBO))
         break;
       if (Value *V = simplifyICmpInst(Pred, LBO->getOperand(0),
                                       RBO->getOperand(0), Q, MaxRecurse - 1))
         return V;
       break;
     case Instruction::AShr:
       if (!Q.IIQ.isExact(LBO) || !Q.IIQ.isExact(RBO))
         break;
       if (Value *V = simplifyICmpInst(Pred, LBO->getOperand(0),
                                       RBO->getOperand(0), Q, MaxRecurse - 1))
         return V;
       break;
     case Instruction::Shl: {
static Value *simplifyICmpWithMinMax(CmpInst::Predicate Pred, Value *LHS,
 
   return nullptr;
 }
 
 static Value *simplifyICmpWithDominatingAssume(CmpInst::Predicate Predicate,
                                                Value *LHS, Value *RHS,
                                                const SimplifyQuery &Q) {
   // Gracefully handle instructions that have not been inserted yet.
   if (!Q.AC || !Q.CxtI || !Q.CxtI->getParent())
     return nullptr;
 
   for (Value *AssumeBaseOp : {LHS, RHS}) {
     for (auto &AssumeVH : Q.AC->assumptionsFor(AssumeBaseOp)) {
       if (!AssumeVH)
         continue;
 
       CallInst *Assume = cast<CallInst>(AssumeVH);
       if (std::optional<bool> Imp = isImpliedCondition(
               Assume->getArgOperand(0), Predicate, LHS, RHS, Q.DL))
         if (isValidAssumeForContext(Assume, Q.CxtI, Q.DT))
           return ConstantInt::get(getCompareTy(LHS), *Imp);
     }
   }
if (Constant *CLHS = dyn_cast<Constant>(LHS)) {
     Pred = CmpInst::getSwappedPredicate(Pred);
   }
   assert(!isa<UndefValue>(LHS) && "Unexpected icmp undef,%X");
 
   Type *ITy = getCompareTy(LHS); // The return type.
 
   // icmp poison, X -> poison
   if (isa<PoisonValue>(RHS))
     return PoisonValue::get(ITy);
 
   // For EQ and NE, we can always pick a value for the undef to make the
   // predicate pass or fail, so we can return undef.
   // Matches behavior in llvm::ConstantFoldCompareInstruction.
   if (Q.isUndefValue(RHS) && ICmpInst::isEquality(Pred))
     return UndefValue::get(ITy);
 
   // icmp X, X -> true/false
static Value *simplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
 
   // If the comparison is with the result of a phi instruction, check whether
   // doing the compare with each incoming phi value yields a common result.
   if (isa<PHINode>(LHS) || isa<PHINode>(RHS))
     if (Value *V = threadCmpOverPHI(Pred, LHS, RHS, Q, MaxRecurse))
       return V;
 
   return nullptr;
 }
 
 Value *llvm::simplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
                               const SimplifyQuery &Q) {
   return ::simplifyICmpInst(Predicate, LHS, RHS, Q, RecursionLimit);
 }
 
 /// Given operands for an FCmpInst, see if we can fold the result.
 /// If not, this returns null.

llvm/test/Transforms/InstSimplify/compare.ll

 ;
   %res = icmp ne ptr @A, @A.alias
   ret i1 %res
 }
 
 
 define i1 @icmp_lshr_known_non_zero_ult_true(i8 %x) {
 ; CHECK-LABEL: @icmp_lshr_known_non_zero_ult_true(
-; CHECK-NEXT:    [[OR:%.*]] = or i8 [[X:%.*]], 1
-; CHECK-NEXT:    [[X1:%.*]] = shl nuw i8 [[OR]], 1
-; CHECK-NEXT:    [[X2:%.*]] = shl nuw i8 [[OR]], 2
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i8 [[X1]], [[X2]]
-; CHECK-NEXT:    ret i1 [[CMP]]
+; CHECK-NEXT:    ret i1 true
 ;
   %or = or i8 %x, 1
   %x1 = shl nuw i8 %or, 1
   %x2 = shl nuw i8 %or, 2
   %cmp = icmp ult i8 %x1, %x2
   ret i1 %cmp
 }
 
 define i1 @icmp_lshr_known_non_zero_ult_false(i8 %x) {
 ; CHECK-LABEL: @icmp_lshr_known_non_zero_ult_false(
-; CHECK-NEXT:    [[OR:%.*]] = or i8 [[X:%.*]], 1
-; CHECK-NEXT:    [[X1:%.*]] = shl nuw i8 [[OR]], 1
-; CHECK-NEXT:    [[X2:%.*]] = shl nuw i8 [[OR]], 2
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ugt i8 [[X1]], [[X2]]
-; CHECK-NEXT:    ret i1 [[CMP]]
+; CHECK-NEXT:    ret i1 false
 ;
   %or = or i8 %x, 1
   %x1 = shl nuw i8 %or, 1
   %x2 = shl nuw i8 %or, 2
   %cmp = icmp ugt i8 %x1, %x2
   ret i1 %cmp
 }
 
 define i1 @icmp_lshr_known_non_zero_slt_true(i8 %x) {
 ; CHECK-LABEL: @icmp_lshr_known_non_zero_slt_true(
-; CHECK-NEXT:    [[OR:%.*]] = or i8 [[X:%.*]], 1
-; CHECK-NEXT:    [[X1:%.*]] = shl nuw nsw i8 [[OR]], 1
-; CHECK-NEXT:    [[X2:%.*]] = shl nuw nsw i8 [[OR]], 2
-; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i8 [[X1]], [[X2]]
-; CHECK-NEXT:    ret i1 [[CMP]]
+; CHECK-NEXT:    ret i1 true
 ;
   %or = or i8 %x, 1
   %x1 = shl nuw nsw i8 %or, 1
   %x2 = shl nuw nsw i8 %or, 2
   %cmp = icmp slt i8 %x1, %x2
   ret i1 %cmp
 }
 
 define i1 @icmp_lshr_known_non_zero_slt_false(i8 %x) {
 ; CHECK-LABEL: @icmp_lshr_known_non_zero_slt_false(
-; CHECK-NEXT:    [[OR:%.*]] = or i8 [[X:%.*]], 1
-; CHECK-NEXT:    [[X1:%.*]] = shl nuw nsw i8 [[OR]], 2
-; CHECK-NEXT:    [[X2:%.*]] = shl nuw nsw i8 [[OR]], 1
-; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i8 [[X1]], [[X2]]
-; CHECK-NEXT:    ret i1 [[CMP]]
+; CHECK-NEXT:    ret i1 false
 ;
   %or = or i8 %x, 1
   %x1 = shl nuw nsw i8 %or, 2
   %x2 = shl nuw nsw i8 %or, 1
   %cmp = icmp slt i8 %x1, %x2
   ret i1 %cmp
 }
 
 define i1 @neg_icmp_lshr_known_non_zero_slt_no_nsw(i8 %x) {
 ; CHECK-LABEL: @neg_icmp_lshr_known_non_zero_slt_no_nsw(
 ; CHECK-NEXT:    [[OR:%.*]] = or i8 [[X:%.*]], 1
 ; CHECK-NEXT:    [[X1:%.*]] = shl nuw i8 [[OR]], 1
 ; CHECK-NEXT:    [[X2:%.*]] = shl nuw i8 [[OR]], 2
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i8 [[X1]], [[X2]]
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %or = or i8 %x, 1
   %x1 = shl nuw i8 %or, 1
   %x2 = shl nuw i8 %or, 2
   %cmp = icmp slt i8 %x1, %x2
   ret i1 %cmp
 }
 
+define i1 @neg_icmp_lshr_known_non_zero_ult_no_nuw(i8 %x) {
+; CHECK-LABEL: @neg_icmp_lshr_known_non_zero_ult_no_nuw(
+; CHECK-NEXT:    [[OR:%.*]] = or i8 [[X:%.*]], 1
+; CHECK-NEXT:    [[X1:%.*]] = shl i8 [[OR]], 1
+; CHECK-NEXT:    [[X2:%.*]] = shl i8 [[OR]], 2
+; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i8 [[X1]], [[X2]]
+; CHECK-NEXT:    ret i1 [[CMP]]
+;
+  %or = or i8 %x, 1
+  %x1 = shl i8 %or, 1
+  %x2 = shl i8 %or, 2
+  %cmp = icmp slt i8 %x1, %x2
+  ret i1 %cmp
+}
+
 define i1 @neg_icmp_lshr_known_non_zero_slt_no_nuw(i8 %x) {
 ; CHECK-LABEL: @neg_icmp_lshr_known_non_zero_slt_no_nuw(
 ; CHECK-NEXT:    [[OR:%.*]] = or i8 [[X:%.*]], 1
 ; CHECK-NEXT:    [[X1:%.*]] = shl nsw i8 [[OR]], 1
 ; CHECK-NEXT:    [[X2:%.*]] = shl nsw i8 [[OR]], 2
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i8 [[X1]], [[X2]]
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;

 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %x1 = shl nuw i8 %x, 2
   %x2 = shl nuw i8 %x, 1
   %cmp = icmp ugt i8 %x1, %x2
   ret i1 %cmp
 }
 
 define i1 @neg_icmp_lshr_unknown_shift(i8 %x, i8 %C1) {
 ; CHECK-LABEL: @neg_icmp_lshr_unknown_shift(
 ; CHECK-NEXT:    [[OR:%.*]] = or i8 [[X:%.*]], 1
 ; CHECK-NEXT:    [[X1:%.*]] = shl nuw i8 [[OR]], 2
 ; CHECK-NEXT:    [[X2:%.*]] = shl nuw i8 [[OR]], [[C1:%.*]]
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ugt i8 [[X1]], [[X2]]
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %or = or i8 %x, 1
   %x1 = shl nuw i8 %or, 2
   %x2 = shl nuw i8 %or, %C1
   %cmp = icmp ugt i8 %x1, %x2
   ret i1 %cmp
 }
 
 define i1 @neg_icmp_lshr_different_shift_values(i8 %x, i8 %y) {
 ; CHECK-LABEL: @neg_icmp_lshr_different_shift_values(
 ; CHECK-NEXT:    [[X1:%.*]] = shl nuw nsw i8 [[X:%.*]], 1
 ; CHECK-NEXT:    [[X2:%.*]] = shl nuw nsw i8 [[Y:%.*]], 2
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i8 [[X1]], [[X2]]
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %x1 = shl nuw nsw i8 %x, 1
   %x2 = shl nuw nsw i8 %y, 2
   %cmp = icmp ult i8 %x1, %x2
   ret i1 %cmp
 }
 
 define i1 @icmp_ult_vscale_true(i8 %x, i8 %y) {
 ; CHECK-LABEL: @icmp_ult_vscale_true(
-; CHECK-NEXT:    [[VSCALE:%.*]] = call i64 @llvm.vscale.i64()
-; CHECK-NEXT:    [[X1:%.*]] = shl nuw nsw i64 [[VSCALE]], 1
-; CHECK-NEXT:    [[X2:%.*]] = shl nuw nsw i64 [[VSCALE]], 2
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i64 [[X1]], [[X2]]
-; CHECK-NEXT:    ret i1 [[CMP]]
+; CHECK-NEXT:    ret i1 true
 ;
   %vscale = call i64 @llvm.vscale.i64()
   %x1 = shl nuw nsw i64 %vscale, 1
   %x2 = shl nuw nsw i64 %vscale, 2
   %cmp = icmp ult i64 %x1, %x2
   ret i1 %cmp
 }
 
 define i1 @icmp_ult_vscale_false(i8 %x, i8 %y) {
 ; CHECK-LABEL: @icmp_ult_vscale_false(
-; CHECK-NEXT:    [[VSCALE:%.*]] = call i64 @llvm.vscale.i64()
-; CHECK-NEXT:    [[X1:%.*]] = shl nuw nsw i64 [[VSCALE]], 1
-; CHECK-NEXT:    [[X2:%.*]] = shl nuw nsw i64 [[VSCALE]], 2
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ugt i64 [[X1]], [[X2]]
-; CHECK-NEXT:    ret i1 [[CMP]]
+; CHECK-NEXT:    ret i1 false
 ;
   %vscale = call i64 @llvm.vscale.i64()
   %x1 = shl nuw nsw i64 %vscale, 1
   %x2 = shl nuw nsw i64 %vscale, 2
   %cmp = icmp ugt i64 %x1, %x2
   ret i1 %cmp
 }
 
 declare i64 @llvm.vscale.i64()
 
 ; TODO: Add coverage for global aliases, link once, etc..
 
 
 attributes #0 = { null_pointer_is_valid }