CodeGenPrepare: Avoid and/or i1 in select conditions.

[MatzeB]

Summary

This transforms:
select((C0 & C1), a, b) -> select(C0, select(C1, a, b), b)
select((C0 | C1), a, b) -> select(C0, a, select(C1, a, b))

The result is better on most targets as C0 and C1 do not need to be
materialized into an integer register but can stay flags.

[hfinkel]

In my early tests the transformation was benficial on arm, aarch64, x86 but of course not on powerpc. Either the powerpc target should normalize into the other direction or we add another TargetTransformInfo flag that tells InstCombine which is the preferred form. I am not sure which to pick.

This is fine for PPC too. LLVM's PPC backend stores boolean values in CR bit registers, and on modern cores with isel, this transformation seems fairly neutral. Your first example goes from:

.L.test_select_and:
cmpw 0, 3, 6
cmpw 1, 3, 7
crandc 20, 4, 0
isel 3, 4, 5, 20
blr

to:

.L.test_select_andr:
cmpw 0, 3, 7
cmpw 7, 3, 6
isel 4, 4, 5, 0
isel 3, 5, 4, 28
blr

On a P7/P8, this seems pretty neutral (both the crandc and the isel are cracked). On the A2, you've increased the critical path length by 1 cycle (isel takes two cycles, but crandc only takes one). Nevertheless, I think that I can adjust for that during isel fairly easily.

The real question, as far as InstCombine goes, is does this make the most-useful canonical form? I'd tend to think that the answer is no, because the logical operators seem more likely to be amenable to further simplification than chains of selects. I could certainly be wrong, however. Also, not all cores have conditional moves (although many now do). Another option is to put this in DAGCombine (or CodeGenPrep), and there you might as well make it target customizable (I'd likely disable it for the PPC A2).

[MatzeB]

New Version: This expects the middleend to have selects normalized to selects with and/or conditions (see http://reviews.llvm.org/D7450). The Code to break it into a sequence of multiple selects is now in the CodeGenPrepare pass and relies on a TargetLowering hook to test whether the transformation is useful.

[MatzeB]

On a side note: Ahmed just mentioned a snipped from SelectionDAGBuilder to me that has pretty much the same logic I do for selects implemented for branches:

// If this is a series of conditions that are or'd or and'd together, emit

// this as a sequence of branches instead of setcc's with and/or operations.
// As long as jumps are not expensive, this should improve performance.
// For example, instead of something like:
//     cmp A, B
//     C = seteq
//     cmp D, E
//     F = setle
//     or C, F
//     jnz foo
// Emit:
//     cmp A, B
//     je foo
//     cmp D, E
//     jle foo
//

...

no idea why that is in SelectionDAGBuilder, it also doesn't seem strictly beneficial to all targets to me...

[hfinkel]

In D7399#119931, @MatzeB wrote:

On a side note: Ahmed just mentioned a snipped from SelectionDAGBuilder to me that has pretty much the same logic I do for selects implemented for branches:

// If this is a series of conditions that are or'd or and'd together, emit

// this as a sequence of branches instead of setcc's with and/or operations.
// As long as jumps are not expensive, this should improve performance.
// For example, instead of something like:
//     cmp A, B
//     C = seteq
//     cmp D, E
//     F = setle
//     or C, F
//     jnz foo
// Emit:
//     cmp A, B
//     je foo
//     cmp D, E
//     jle foo
//

...

no idea why that is in SelectionDAGBuilder, it also doesn't seem strictly beneficial to all targets to me...

It's not (and it was pointed out to me in a different thread a couple of months ago); which function does this again? I keep forgetting to fix this... (my current plan is to turn it off when TLI->hasMultipleConditionRegisters() is true, which is only the case on PPC AFAIK).

[MatzeB]

SelectionDAGBuilder::visitBr

[MatzeB]

ping

[hfinkel]

llvm/trunk/lib/Transforms/InstCombine/InstCombineSelect.cpp

1195 ↗

(On Diff #19492)

I think that you want to explicitly add And to the worklist here (assuming that the builder has not constant-folded it).

if (Instruction *AndI = dyn_cast<Instruction>(And))
  Worklist.Add(AndI);

otherwise we might not actually revisit it until the next main outer instcombine iteration.

lib/Transforms/InstCombine/InstCombineSelect.cpp

if (ShouldNotVal)
     V = Builder->CreateXor(V, ValC);
 
   // Apply an offset if needed.
   if (Offset)
     V = Builder->CreateAdd(V, Offset);
   return V;
 }
 
+/// Returns true if all users of @p Val are Select instructions.
+static bool onlySelectAsUser(const Value &Val) {
+  for (const Use &U : Val.uses()) {
+    Instruction *User = cast<Instruction>(U.getUser());
+    if (User->getOpcode() != Instruction::Select)
+      return false;
+  }
+  return true;
+}
+
 Instruction *InstCombiner::visitSelectInst(SelectInst &SI) {
   Value *CondVal = SI.getCondition();
   Value *TrueVal = SI.getTrueValue();
   Value *FalseVal = SI.getFalseValue();
 
   if (Value *V =
           SimplifySelectInst(CondVal, TrueVal, FalseVal, DL, TLI, DT, AC))
     return ReplaceInstUsesWith(SI, V);
if (Value *V = SimplifyDemandedVectorElts(&SI, AllOnesEltMask, UndefElts)) {
       if (V != &SI)
         return ReplaceInstUsesWith(SI, V);
       return &SI;
     }
 
     if (isa<ConstantAggregateZero>(CondVal)) {
       return ReplaceInstUsesWith(SI, FalseVal);
     }
+  } else {
+    // Avoid arithmetic on i1 types if we can express it with a series of
+    // selects this usually results in better target code as C0 and C1
+    // don't need to be materialized in an integer register.
+
+    // select((C0 & C1), a, b) -> select(C0, select(C1, a, b), b)
+    if (const Instruction *And = dyn_cast<Instruction>(CondVal))
+      if (And->getOpcode() == Instruction::And && onlySelectAsUser(*CondVal)) {
+        Value *InnerSelect = Builder->CreateSelect(And->getOperand(1), TrueVal,
+                                                   FalseVal, SI.getName()+".0");
+        SI.setOperand(0, And->getOperand(0));
+        SI.setOperand(1, InnerSelect);
+        return &SI;
+      }
+    // select((C0 | C1), a, b) -> select(C0, a, select(C1, a, b))
+    if (const Instruction *Or = dyn_cast<Instruction>(CondVal))
+      if (Or->getOpcode() == Instruction::Or && onlySelectAsUser(*CondVal)) {
+        Value *InnerSelect = Builder->CreateSelect(Or->getOperand(1), TrueVal,
+                                                   FalseVal, SI.getName()+".0");
+        SI.setOperand(0, Or->getOperand(0));
+        SI.setOperand(2, InnerSelect);
+        return &SI;
+      }
   }
 
   return nullptr;
 }

test/Transforms/InstCombine/select.ll

entry:
   call void @scribble_on_i128(i128* %x2)
   call void @scribble_on_i128(i128* %y)
   %tmp = load i8** %x1
   store i8* %tmp, i8** %y1
   %p = select i1 %flag, i128* %x2, i128* %y
   %v = load i128* %p
   ret i128 %v
 }
+
+define i32 @test_select_and(i32 %a, i32 %r0, i32 %r1, i32 %v1, i32 %v2) {
+  ; CHECK-LABEL: @test_select_and(
+  ; CHECK: %[[C0:.*]] = icmp sge i32 %a, %v1
+  ; CHECK-NEXT: %[[C1:.*]] = icmp slt i32 %a, %v2
+  ; CHECK-NEXT: %[[SEL0:.*]] = select i1 %[[C1]], i32 %r0, i32 %r1
+  ; CHECK-NEXT: %[[SEL1:.*]] = select i1 %[[C0]], i32 %[[SEL0]], i32 %r1
+  ; CHECK-NEXT: ret i32 %[[SEL1]]
+  %c0 = icmp sge i32 %a, %v1
+  %c1 = icmp slt i32 %a, %v2
+  %and = and i1 %c0, %c1
+  %res = select i1 %and, i32 %r0, i32 %r1
+  ret i32 %res
+}
+
+define i32 @test_select_or(i32 %a, i32 %r0, i32 %r1, i32 %v1, i32 %v2) {
+  ; CHECK-LABEL: @test_select_or(
+  ; CHECK: %[[C0:.*]] = icmp sge i32 %a, %v1
+  ; CHECK-NEXT: %[[C1:.*]] = icmp slt i32 %a, %v2
+  ; CHECK-NEXT: %[[SEL0:.*]] = select i1 %[[C1]], i32 %r0, i32 %r1
+  ; CHECK-NEXT: %[[SEL1:.*]] = select i1 %[[C0]], i32 %r0, i32 %[[SEL0]]
+  ; CHECK-NEXT: ret i32 %[[SEL1]]
+  %c0 = icmp sge i32 %a, %v1
+  %c1 = icmp slt i32 %a, %v2
+  %and = or i1 %c0, %c1
+  %res = select i1 %and, i32 %r0, i32 %r1
+  ret i32 %res
+}

test/Transforms/Reassociate/basictest.ll

 ; CHECK-NEXT: ret i32
 }
 
 ; Do not reassociate expressions of type i1
 define i32 @test15(i32 %X1, i32 %X2, i32 %X3) {
   %A = icmp ne i32 %X1, 0
   %B = icmp slt i32 %X2, %X3
   %C = and i1 %A, %B
-  %D = select i1 %C, i32 %X1, i32 0
+  %D = zext i1 %C to i32
   ret i32 %D
 ; CHECK-LABEL: @test15
 ; CHECK: and i1 %A, %B
 }