[InstCombine] fold more constant divisor to select-of-constants divisor

[Chenbing.Zheng]

Summary

This patch slove TODO left in div.ll.

By adding a parameter to function FoldOpIntoSelect， we can fold more Ops to Select.
For this example, we tend to fold the division instruction, so we no longer care whether SelectInst is one use.

[RKSimon]

llvm/lib/Transforms/InstCombine/InstCombineInternal.h

626

'Tend' sounds odd to me - maybe something like 'FoldWithMultiUse' to be more descriptive?

llvm/test/Transforms/InstCombine/div.ll

18

Are these changes from this patch or should you regenerate the file before hand to get rid of seperate changes like this?

[Chenbing.Zheng]

address comments

[Chenbing.Zheng]

llvm/lib/Transforms/InstCombine/InstCombineInternal.h

626

'Tend' sounds odd to me - maybe something like 'FoldWithMultiUse' to be more descriptive?

Thanks for suggestion, it is mush batter

[RKSimon]

LGTM - cheers

llvm/lib/Transforms/InstCombine/InstCombineInternal.h

public:
   /// BB1: BO = binop X, Y
   /// BB3: phi [BO, BB1], [(binop C1, C2), BB2]
   Instruction *foldBinopWithPhiOperands(BinaryOperator &BO);
 
   /// Given an instruction with a select as one operand and a constant as the
   /// other operand, try to fold the binary operator into the select arguments.
   /// This also works for Cast instructions, which obviously do not have a
   /// second operand.
-  Instruction *FoldOpIntoSelect(Instruction &Op, SelectInst *SI);
+  Instruction *FoldOpIntoSelect(Instruction &Op, SelectInst *SI,
+                                bool FoldWithMultiUse = false);
 
   /// This is a convenience wrapper function for the above two functions.
   Instruction *foldBinOpIntoSelectOrPhi(BinaryOperator &I);
 
   Instruction *foldAddWithConstant(BinaryOperator &Add);
 
   /// Try to rotate an operation below a PHI node, using PHI nodes for
   /// its operands.

llvm/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

Instruction *InstCombinerImpl::commonIDivTransforms(BinaryOperator &I) {
   if (simplifyDivRemOfSelectWithZeroOp(I))
     return &I;
 
   // If the divisor is a select-of-constants, try to constant fold all div ops:
   // C / (select Cond, TrueC, FalseC) --> select Cond, (C / TrueC), (C / FalseC)
   // TODO: Adapt simplifyDivRemOfSelectWithZeroOp to allow this and other folds.
   if (match(Op0, m_ImmConstant()) &&
       match(Op1, m_Select(m_Value(), m_ImmConstant(), m_ImmConstant()))) {
-    if (Instruction *R = FoldOpIntoSelect(I, cast<SelectInst>(Op1)))
+    if (Instruction *R = FoldOpIntoSelect(I, cast<SelectInst>(Op1),
+                                          /*FoldWithMultiUse*/ true))
       return R;
   }
 
   const APInt *C2;
   if (match(Op1, m_APInt(C2))) {
     Value *X;
     const APInt *C1;
 

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

static Value *foldOperationIntoSelectOperand(Instruction &I, Value *SO,
 
   Value *NewBO = Builder.CreateBinOp(cast<BinaryOperator>(&I)->getOpcode(), Op0,
                                      Op1, SO->getName() + ".op");
   if (auto *NewBOI = dyn_cast<Instruction>(NewBO))
     NewBOI->copyIRFlags(&I);
   return NewBO;
 }
 
-Instruction *InstCombinerImpl::FoldOpIntoSelect(Instruction &Op,
-                                                SelectInst *SI) {
-  // Don't modify shared select instructions.
-  if (!SI->hasOneUse())
+Instruction *InstCombinerImpl::FoldOpIntoSelect(Instruction &Op, SelectInst *SI,
+                                                bool FoldWithMultiUse) {
+  // Don't modify shared select instructions unless set FoldWithMultiUse
+  if (!SI->hasOneUse() && !FoldWithMultiUse)
     return nullptr;
 
   Value *TV = SI->getTrueValue();
   Value *FV = SI->getFalseValue();
   if (!(isa<Constant>(TV) || isa<Constant>(FV)))
     return nullptr;
 
   // Bool selects with constant operands can be folded to logical ops.

llvm/test/Transforms/InstCombine/div.ll

;
   %B = sdiv i32 %A, 1
   ret i32 %B
 }
 
 define i32 @test2(i32 %A) {
 ; CHECK-LABEL: @test2(
 ; CHECK-NEXT:    [[B:%.*]] = lshr i32 [[A:%.*]], 3
 ; CHECK-NEXT:    ret i32 [[B]]
 ;
   %B = udiv i32 %A, 8
   ret i32 %B
 }
 
 define i32 @sdiv_by_minus1(i32 %A) {
 ; CHECK-LABEL: @sdiv_by_minus1(
 ; CHECK-NEXT:    [[B:%.*]] = sub i32 0, [[A:%.*]]
 ; CHECK-NEXT:    ret i32 [[B]]

 ; CHECK-NEXT:    [[R:%.*]] = select i1 [[B:%.*]], i32 3, i32 -14
 ; CHECK-NEXT:    ret i32 [[R]]
 ;
   %s = select i1 %b, i32 12, i32 -3
   %r = sdiv i32 42, %s
   ret i32 %r
 }
 
-; TODO: sdiv should still be replaced by select.
-
 define i32 @sdiv_constant_dividend_select_of_constants_divisor_use(i1 %b) {
 ; CHECK-LABEL: @sdiv_constant_dividend_select_of_constants_divisor_use(
 ; CHECK-NEXT:    [[S:%.*]] = select i1 [[B:%.*]], i32 12, i32 -3
 ; CHECK-NEXT:    call void @use(i32 [[S]])
-; CHECK-NEXT:    [[R:%.*]] = sdiv i32 42, [[S]]
+; CHECK-NEXT:    [[R:%.*]] = select i1 [[B]], i32 3, i32 -14
 ; CHECK-NEXT:    ret i32 [[R]]
 ;
   %s = select i1 %b, i32 12, i32 -3
   call void @use(i32 %s)
   %r = sdiv i32 42, %s
   ret i32 %r
 }
 

 ; CHECK-NEXT:    [[R:%.*]] = select i1 [[B:%.*]], i32 3, i32 0
 ; CHECK-NEXT:    ret i32 [[R]]
 ;
   %s = select i1 %b, i32 12, i32 -3
   %r = udiv i32 42, %s
   ret i32 %r
 }
 
-; TODO: udiv should still be replaced by select.
-
 define i32 @udiv_constant_dividend_select_of_constants_divisor_use(i1 %b) {
 ; CHECK-LABEL: @udiv_constant_dividend_select_of_constants_divisor_use(
 ; CHECK-NEXT:    [[S:%.*]] = select i1 [[B:%.*]], i32 12, i32 -3
 ; CHECK-NEXT:    call void @use(i32 [[S]])
-; CHECK-NEXT:    [[R:%.*]] = udiv i32 42, [[S]]
+; CHECK-NEXT:    [[R:%.*]] = select i1 [[B]], i32 3, i32 0
 ; CHECK-NEXT:    ret i32 [[R]]
 ;
   %s = select i1 %b, i32 12, i32 -3
   call void @use(i32 %s)
   %r = udiv i32 42, %s
   ret i32 %r
 }