[InstCombine] Enhance select icmp and folding

[peixin]

Summary

This folds (a << k) ? 2^k * a : 0 to 2^k * a.

https://alive2.llvm.org/ce/z/_dDRjo

Fix #62155.

Depends on D150069.

[RKSimon]

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

255

Would using m_And(m_Specific(X), m_APInt(C)) avoid the need for this?

259

!C->isMask() ?

[peixin]

Address the comments.

[peixin]

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

255

Thanks. Fixed.

259

Good point. Fixed.

[nikic]

As this does not create a new instruction, it should be part of InstSimplify (probably in simplifySelectWithICmpCond).

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

239

Why exclude vectors? Looks like they should work out of the box?

[peixin]

Address the comments.

1. Move to instsimplify.
2. Add support for vector type.

[goldstein.w.n]

llvm/lib/Analysis/InstructionSimplify.cpp

4411 ↗

(On Diff #514004)

Can we also handle select (icmp ne (and X, C), 0, (shl X, K), 0)?

llvm/test/Transforms/InstSimplify/select.ll

1346 ↗

(On Diff #514004)

Can you split the next tests to a prior patch so we can see the diff this patch generates?

[peixin]

Addressed the comments.

[peixin]

gentle ping

[nikic]

It looks like this should be part of simplifySelectBitTest(), which covers other "select of icmp and" patterns.

[peixin]

In D148420#4291703, @nikic wrote:

It looks like this should be part of simplifySelectBitTest(), which covers other "select of icmp and" patterns.

It seems not, the CondVal in simplifySelectWithICmpCond is ICmp of value and zero. For cases in simplifySelectBitTest, the CondVal is ICmp of value and value.

[nikic]

In D148420#4295784, @peixin wrote:

In D148420#4291703, @nikic wrote:

It looks like this should be part of simplifySelectBitTest(), which covers other "select of icmp and" patterns.

It seems not, the CondVal in simplifySelectWithICmpCond is ICmp of value and zero. For cases in simplifySelectBitTest, the CondVal is ICmp of value and value.

Not sure I follow. Isn't it matching the (X & C) == 0 pattern here? https://github.com/llvm/llvm-project/blob/f6ec56ac5be26ad862e22d0eebb2645d1ad78218/llvm/lib/Analysis/InstructionSimplify.cpp#L4494-L4500

[peixin]

In D148420#4298441, @nikic wrote:

In D148420#4295784, @peixin wrote:

In D148420#4291703, @nikic wrote:

It looks like this should be part of simplifySelectBitTest(), which covers other "select of icmp and" patterns.

It seems not, the CondVal in simplifySelectWithICmpCond is ICmp of value and zero. For cases in simplifySelectBitTest, the CondVal is ICmp of value and value.

Not sure I follow. Isn't it matching the (X & C) == 0 pattern here? https://github.com/llvm/llvm-project/blob/f6ec56ac5be26ad862e22d0eebb2645d1ad78218/llvm/lib/Analysis/InstructionSimplify.cpp#L4494-L4500

OK. I get your idea. You are right. Will fix this.

[nikic]

Just took a closer look at this. This is one of those transforms where we need to be very careful about derefinement, because we're replacing a constant 0 with an instruction that (under the given condition) may refine to zero but is not necessarily equivalent to zero.

In particular, if the shl has nowrap flags, this transform is incorrect: https://alive2.llvm.org/ce/z/EjBRVW

This means we need to drop nowrap flags as part of the transform. I'm afraid this means that my original recommendation to move this to InstSimplify was wrong and this should be in InstCombine after all, as we can only drop nowrap flags there.

[peixin]

In D148420#4315381, @nikic wrote:

Just took a closer look at this. This is one of those transforms where we need to be very careful about derefinement, because we're replacing a constant 0 with an instruction that (under the given condition) may refine to zero but is not necessarily equivalent to zero.

In particular, if the shl has nowrap flags, this transform is incorrect: https://alive2.llvm.org/ce/z/EjBRVW

This means we need to drop nowrap flags as part of the transform. I'm afraid this means that my original recommendation to move this to InstSimplify was wrong and this should be in InstCombine after all, as we can only drop nowrap flags there.

@nikic Thanks for the notice. I was on vacation and just came back today. I will continue this work.

[peixin]

Address the comments from @nikic .

[peixin]

It seems I uploaded the wrong patch.

[peixin]

Upload the right patch.

[peixin]

ping for review @nikic

[goldstein.w.n]

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

613

Two things.

1. I don't think you need the nsw/nuw on the shl
2. This seems like a special case of the generalized transform:

(select (icmp eq (and X, C), C1), (shl C1, K), (shl X, K)) -> (shl X, K).

See:
https://alive2.llvm.org/ce/z/zjrVzM

613

What I mean by point 2, is can you just implement the generalized transform?

[RKSimon]

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

631

If K is a shift value, why not use getZExtValue() and avoid the extra int64_t cast?

[nikic]

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

613

The nsw/nuw here are relevant in that they must be dropped by the transform. They are not a precondition.

622

You'll want to add something like

if (Pred == ICmpInst::ICMP_NE) {
  Pred = ICmpInst::ICMP_EQ;
  std::swap(TVal, FVal);
}

here (and a test case using ne), to make sure you cover the case with swapped operands. (Unless there is some canonicalization here that makes this irrelevant?)

[peixin]

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

613

Is it generated from some source code? I mean, we usually optimize the IR which can be generated from the source code, right?

622

The test cases of ne has been covered. Check test2 in D150069. It seems the InstSimplify has done the canonicalization.

631

countLeadingZeros returns unsigned. We will still need one extra uint64_t cast.

[peixin]

gentle ping

[goldstein.w.n]

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

622

Is it maybe worth extend instsimplify to handle the eq case then?

631

its implicitly casted. At the very least use static_cast instead of C-style.

1783

Would generate prefer you move the replaceInstUsesWith to return of foldSelectIcmpAndZeroShl Think it keeps impl details a bit better contained.

[nikic]

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

622

You can probably get a case where the ne predicate stays if you add an additional use of the icmp (e.g. pass it to a call). But given that it does get canonicalized for the common case, I won't insist...

631

I agree that getZExtValue() makes more sense here, it's semantically an unsigned value.

1783

I don't really get why that would be better. This is a general InstCombine convention: Either your helper returns Instruction and that gets directly returned, or it returns Value and you call replaceInstUsesWith. You'll see this in a lot of the surrounding code. Moving replaceInstUsesWith into the helper also requires passing InstCombiner to it.

[goldstein.w.n]

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

1783

not a hill I'll die on, just think if(Instruction * R = foo()) return R; is the simplest convention to have.

[peixin]

Thanks @goldstein.w.n and @nikic for the comments. Addressed them.

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

622

Got it. Thanks.

631

OK. Fixed.

1783

The code in line 1774-1803 have both of the formats. So it should be OK to use either of them.

[peixin]

Sorry for the continued ping. I hope to finish this patch by the end of next week due to work changes.

[nikic]

Implementation looks fine, but this is missing some test coverage. Can you please also add an alive2 proof to the patch description?

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

628

K -> C2 is the more typical convention

llvm/test/Transforms/InstCombine/select-icmp-and-zero-shl.ll

5–6

@test_eq

29–30

@test_ne

53–54

@test_nuw_dropped

65–66

@test_nsw_dropped

170

Missing tests:

• Multi-use test. Add additional uses of the and, icmp and shift by passing them to a call. We still want to perform the fold in that case.
• Negative test where the leading bits don't match.
• Negative test for non-equality predicate.
• Negative test where the select constant is not 0.
• Negative test where the icmp constant is not 0.

[peixin]

Thanks @nikic for the comments. Addressed them:

1. Add negative and multi-use tests in D150069.
2. Change K -> C2.
3. Add alive2 proof in patch description.
4. Fix the implementation by generating shl instruction instead of unset flags. Unsetting nuw/nsw flags was wrong when shl instruction has other use.

[peixin]

Try to fix builtbot fail on debian x64.

[nikic]

Fix the implementation by generating shl instruction instead of unset flags. Unsetting nuw/nsw flags was wrong when shl instruction has other use.

Generating a new shl isn't wrong, but I think your previous approach was better. The reason is that the shl with and without nowrap flags are going to be GVN/CSEd anyway, and the nowrap flags will be dropped in the process. So it makes more sense to me to directly go to the final form. Losing some nowrap flags is just the cost of this transform.

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

625–639

This avoids duplicating the checks for ne and eq.

[peixin]

In D148420#4486924, @nikic wrote:

Fix the implementation by generating shl instruction instead of unset flags. Unsetting nuw/nsw flags was wrong when shl instruction has other use.

Generating a new shl isn't wrong, but I think your previous approach was better. The reason is that the shl with and without nowrap flags are going to be GVN/CSEd anyway, and the nowrap flags will be dropped in the process. So it makes more sense to me to directly go to the final form. Losing some nowrap flags is just the cost of this transform.

Good to know it. Thanks for it.

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

625–639

Good point. Fixed.

[nikic]

LGTM

I think the alive2 link should be more along these lines: https://alive2.llvm.org/ce/z/dEW3Ak We should check the generic transform, not specific constants.

[peixin]

Fix clang-format issue.

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

 ///   %C = or %A, %B
 ///   %D = select %cond, %C, %A
 /// into:
 ///   %C = select %cond, %B, 0
 ///   %D = or %A, %C
 ///
 /// Assuming that the specified instruction is an operand to the select, return
 /// a bitmask indicating which operands of this instruction are foldable if they
 /// equal the other incoming value of the select.
 static unsigned getSelectFoldableOperands(BinaryOperator *I) {
   switch (I->getOpcode()) {
   case Instruction::Add:
   case Instruction::FAdd:
   case Instruction::Mul:
   case Instruction::FMul:
   case Instruction::And:
   case Instruction::Or:
   case Instruction::Xor:
     return 3;              // Can fold through either operand.
   case Instruction::Sub:   // Can only fold on the amount subtracted.
   case Instruction::FSub:
   case Instruction::FDiv:  // Can only fold on the divisor amount.
   case Instruction::Shl:   // Can only fold on the shift amount.
   case Instruction::LShr:
   case Instruction::AShr:
     return 1;
   default:
     return 0;              // Cannot fold
   }
 }
 
 /// We have (select c, TI, FI), and we know that TI and FI have the same opcode.
 Instruction *InstCombinerImpl::foldSelectOpOp(SelectInst &SI, Instruction *TI,
                                               Instruction *FI) {
   // Don't break up min/max patterns. The hasOneUse checks below prevent that
   // for most cases, but vector min/max with bitcasts can be transformed. If the
   // one-use restrictions are eased for other patterns, we still don't want to
static Instruction *foldSelectICmpAndAnd(Type *SelType, const ICmpInst *Cmp,
   Value *MaskB = HasShift ? Builder.CreateShl(One, Z) : One;
   Value *FullMask = Builder.CreateOr(Y, MaskB);
   Value *MaskedX = Builder.CreateAnd(X, FullMask);
   Value *ICmpNeZero = Builder.CreateIsNotNull(MaskedX);
   return new ZExtInst(ICmpNeZero, SelType);
 }
 
 /// We want to turn:
+///   (select (icmp eq (and X, C1), 0), 0, (shl [nsw/nuw] X, C2));
+///   iff C1 is a mask and the number of its leading zeros is equal to C2
+/// into:
+///   shl X, C2
+static Value *foldSelectICmpAndZeroShl(const ICmpInst *Cmp, Value *TVal,
+                                       Value *FVal,
+                                       InstCombiner::BuilderTy &Builder) {
+  ICmpInst::Predicate Pred;
+  Value *AndVal;
+  if (!match(Cmp, m_ICmp(Pred, m_Value(AndVal), m_Zero())))
+    return nullptr;
+
+  Value *X;
+  const APInt *C2, *C1;
+  if (Pred == ICmpInst::ICMP_EQ) {
+    if (!match(AndVal, m_And(m_Value(X), m_APInt(C1))) ||
+        !match(TVal, m_Zero()) ||
+        !match(FVal, m_Shl(m_Specific(X), m_APInt(C2))))
+      return nullptr;
+  } else if (Pred == ICmpInst::ICMP_NE) {
+    if (!match(AndVal, m_And(m_Value(X), m_APInt(C1))) ||
+        !match(FVal, m_Zero()) ||
+        !match(TVal, m_Shl(m_Specific(X), m_APInt(C2))))
+      return nullptr;
+  } else {
+    return nullptr;
+  }
+
+  if (!C1->isMask() ||
+      C1->countLeadingZeros() != static_cast<unsigned>(C2->getZExtValue()))
+    return nullptr;
+
+  return Builder.CreateShl(X, *C2);
+}
+
+/// We want to turn:
 ///   (select (icmp sgt x, C), lshr (X, Y), ashr (X, Y)); iff C s>= -1
 ///   (select (icmp slt x, C), ashr (X, Y), lshr (X, Y)); iff C s>= 0
 /// into:
 ///   ashr (X, Y)
 static Value *foldSelectICmpLshrAshr(const ICmpInst *IC, Value *TrueVal,
                                      Value *FalseVal,
                                      InstCombiner::BuilderTy &Builder) {
   ICmpInst::Predicate Pred = IC->getPredicate();
if (IsBitTest) {
         return replaceInstUsesWith(SI, V);
     }
   }
 
   if (Instruction *V =
           foldSelectICmpAndAnd(SI.getType(), ICI, TrueVal, FalseVal, Builder))
     return V;
 
+  if (Value *V = foldSelectICmpAndZeroShl(ICI, TrueVal, FalseVal, Builder))
+    return replaceInstUsesWith(SI, V);
+
   if (Instruction *V = foldSelectCtlzToCttz(ICI, TrueVal, FalseVal, Builder))
     return V;
 
   if (Instruction *V = foldSelectZeroOrOnes(ICI, TrueVal, FalseVal, Builder))
     return V;
 
   if (Value *V = foldSelectICmpAndOr(ICI, TrueVal, FalseVal, Builder))
     return replaceInstUsesWith(SI, V);

llvm/test/Transforms/InstCombine/select-icmp-and-zero-shl.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
 
 ; (x << k) ? 2^k * x : 0 --> 2^k * x
 
 define i32 @test_eq(i32 %x) {
 ; CHECK-LABEL: @test_eq(
-; CHECK-NEXT:    [[SHL_MASK:%.*]] = and i32 [[X:%.*]], 1073741823
-; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp eq i32 [[SHL_MASK]], 0
-; CHECK-NEXT:    [[MUL:%.*]] = shl i32 [[X]], 2
-; CHECK-NEXT:    [[COND:%.*]] = select i1 [[TOBOOL]], i32 0, i32 [[MUL]]
+; CHECK-NEXT:    [[COND:%.*]] = shl i32 [[X:%.*]], 2
 ; CHECK-NEXT:    ret i32 [[COND]]
 ;
   %shl.mask = and i32 %x, 1073741823
   %tobool = icmp eq i32 %shl.mask, 0
   %mul = shl i32 %x, 2
   %cond = select i1 %tobool, i32 0, i32 %mul
   ret i32 %cond
 }
 
 define <2 x i32> @test_eq_vect(<2 x i32> %x) {
 ; CHECK-LABEL: @test_eq_vect(
-; CHECK-NEXT:    [[SHL_MASK:%.*]] = and <2 x i32> [[X:%.*]], <i32 1073741823, i32 1073741823>
-; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp eq <2 x i32> [[SHL_MASK]], zeroinitializer
-; CHECK-NEXT:    [[MUL:%.*]] = shl <2 x i32> [[X]], <i32 2, i32 2>
-; CHECK-NEXT:    [[COND:%.*]] = select <2 x i1> [[TOBOOL]], <2 x i32> zeroinitializer, <2 x i32> [[MUL]]
+; CHECK-NEXT:    [[COND:%.*]] = shl <2 x i32> [[X:%.*]], <i32 2, i32 2>
 ; CHECK-NEXT:    ret <2 x i32> [[COND]]
 ;
   %shl.mask = and <2 x i32> %x, <i32 1073741823, i32 1073741823>
   %tobool = icmp eq <2 x i32> %shl.mask, zeroinitializer
   %mul = shl <2 x i32> %x, <i32 2, i32 2>
   %cond = select <2 x i1> %tobool, <2 x i32> zeroinitializer, <2 x i32> %mul
   ret <2 x i32> %cond
 }
 
 define i32 @test_ne(i32 %x) {
 ; CHECK-LABEL: @test_ne(
-; CHECK-NEXT:    [[SHL_MASK:%.*]] = and i32 [[X:%.*]], 1073741823
-; CHECK-NEXT:    [[TOBOOL_NOT_NOT:%.*]] = icmp eq i32 [[SHL_MASK]], 0
-; CHECK-NEXT:    [[MUL:%.*]] = shl i32 [[X]], 2
-; CHECK-NEXT:    [[COND:%.*]] = select i1 [[TOBOOL_NOT_NOT]], i32 0, i32 [[MUL]]
+; CHECK-NEXT:    [[COND:%.*]] = shl i32 [[X:%.*]], 2
 ; CHECK-NEXT:    ret i32 [[COND]]
 ;
   %shl.mask = and i32 %x, 1073741823
   %tobool.not = icmp ne i32 %shl.mask, 0
   %mul = shl i32 %x, 2
   %cond = select i1 %tobool.not, i32 %mul, i32 0
   ret i32 %cond
 }
 
 define <2 x i32> @test_ne_vect(<2 x i32> %x) {
 ; CHECK-LABEL: @test_ne_vect(
-; CHECK-NEXT:    [[SHL_MASK:%.*]] = and <2 x i32> [[X:%.*]], <i32 1073741823, i32 1073741823>
-; CHECK-NEXT:    [[TOBOOL_NOT_NOT:%.*]] = icmp eq <2 x i32> [[SHL_MASK]], zeroinitializer
-; CHECK-NEXT:    [[MUL:%.*]] = shl <2 x i32> [[X]], <i32 2, i32 2>
-; CHECK-NEXT:    [[COND:%.*]] = select <2 x i1> [[TOBOOL_NOT_NOT]], <2 x i32> zeroinitializer, <2 x i32> [[MUL]]
+; CHECK-NEXT:    [[COND:%.*]] = shl <2 x i32> [[X:%.*]], <i32 2, i32 2>
 ; CHECK-NEXT:    ret <2 x i32> [[COND]]
 ;
   %shl.mask = and <2 x i32> %x, <i32 1073741823, i32 1073741823>
   %tobool.not = icmp ne <2 x i32> %shl.mask, zeroinitializer
   %mul = shl <2 x i32> %x, <i32 2, i32 2>
   %cond = select <2 x i1> %tobool.not, <2 x i32> %mul, <2 x i32> zeroinitializer
   ret <2 x i32> %cond
 }
 
 define i32 @test_nuw_dropped(i32 %x) {
 ; CHECK-LABEL: @test_nuw_dropped(
-; CHECK-NEXT:    [[SHL_MASK:%.*]] = and i32 [[X:%.*]], 1073741823
-; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp eq i32 [[SHL_MASK]], 0
-; CHECK-NEXT:    [[MUL:%.*]] = shl nuw i32 [[X]], 2
-; CHECK-NEXT:    [[COND:%.*]] = select i1 [[TOBOOL]], i32 0, i32 [[MUL]]
+; CHECK-NEXT:    [[COND:%.*]] = shl i32 [[X:%.*]], 2
 ; CHECK-NEXT:    ret i32 [[COND]]
 ;
   %shl.mask = and i32 %x, 1073741823
   %tobool = icmp eq i32 %shl.mask, 0
   %mul = shl nuw i32 %x, 2
   %cond = select i1 %tobool, i32 0, i32 %mul
   ret i32 %cond
 }
 
 define i32 @test_nsw_dropped(i32 %x) {
 ; CHECK-LABEL: @test_nsw_dropped(
-; CHECK-NEXT:    [[SHL_MASK:%.*]] = and i32 [[X:%.*]], 1073741823
-; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp eq i32 [[SHL_MASK]], 0
-; CHECK-NEXT:    [[MUL:%.*]] = shl nsw i32 [[X]], 2
-; CHECK-NEXT:    [[COND:%.*]] = select i1 [[TOBOOL]], i32 0, i32 [[MUL]]
+; CHECK-NEXT:    [[COND:%.*]] = shl i32 [[X:%.*]], 2
 ; CHECK-NEXT:    ret i32 [[COND]]
 ;
   %shl.mask = and i32 %x, 1073741823
   %tobool = icmp eq i32 %shl.mask, 0
   %mul = shl nsw i32 %x, 2
   %cond = select i1 %tobool, i32 0, i32 %mul
   ret i32 %cond
 }
 
 declare void @use_multi(i32, i1, i32)
 
 ; This will not be canonicalized.
 define i32 @test_multi_use(i32 %x) {
 ; CHECK-LABEL: @test_multi_use(
 ; CHECK-NEXT:    [[SHL_MASK:%.*]] = and i32 [[X:%.*]], 1073741823
 ; CHECK-NEXT:    [[TOBOOL_NOT:%.*]] = icmp ne i32 [[SHL_MASK]], 0
 ; CHECK-NEXT:    [[MUL:%.*]] = shl i32 [[X]], 2
-; CHECK-NEXT:    [[COND:%.*]] = select i1 [[TOBOOL_NOT]], i32 [[MUL]], i32 0
+; CHECK-NEXT:    [[COND:%.*]] = shl i32 [[X]], 2
 ; CHECK-NEXT:    call void @use_multi(i32 [[SHL_MASK]], i1 [[TOBOOL_NOT]], i32 [[MUL]])
 ; CHECK-NEXT:    ret i32 [[COND]]
 ;
   %shl.mask = and i32 %x, 1073741823
   %tobool.not = icmp ne i32 %shl.mask, 0
   %mul = shl i32 %x, 2
   %cond = select i1 %tobool.not, i32 %mul, i32 0
   call void @use_multi(i32 %shl.mask, i1 %tobool.not, i32 %mul)
   ret i32 %cond
 }
 
 define i32 @test_multi_use_nuw_dropped(i32 %x) {
 ; CHECK-LABEL: @test_multi_use_nuw_dropped(
 ; CHECK-NEXT:    [[SHL_MASK:%.*]] = and i32 [[X:%.*]], 1073741823
 ; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp eq i32 [[SHL_MASK]], 0
 ; CHECK-NEXT:    [[MUL:%.*]] = shl nuw i32 [[X]], 2
-; CHECK-NEXT:    [[COND:%.*]] = select i1 [[TOBOOL]], i32 0, i32 [[MUL]]
+; CHECK-NEXT:    [[COND:%.*]] = shl i32 [[X]], 2
 ; CHECK-NEXT:    call void @use_multi(i32 [[SHL_MASK]], i1 [[TOBOOL]], i32 [[MUL]])
 ; CHECK-NEXT:    ret i32 [[COND]]
 ;
   %shl.mask = and i32 %x, 1073741823
   %tobool = icmp eq i32 %shl.mask, 0
   %mul = shl nuw i32 %x, 2
   %cond = select i1 %tobool, i32 0, i32 %mul
   call void @use_multi(i32 %shl.mask, i1 %tobool, i32 %mul)

 ; CHECK-NEXT:    [[COND:%.*]] = select i1 [[TOBOOL]], i32 0, i32 [[MUL]]
 ; CHECK-NEXT:    ret i32 [[COND]]
 ;
   %shl.mask = and i32 %x, 1073741823
   %tobool = icmp eq i32 %shl.mask, 1
   %mul = shl i32 %x, 2
   %cond = select i1 %tobool, i32 0, i32 %mul
   ret i32 %cond
 }