[CVP][NFCI] Refactor truncated binary operator creation out of processUDivOrURem()

[spatel]

It's fine as a clean-up, but would it be better still to use IRBuilder?

[lebedev.ri]

In D47117#1105928, @spatel wrote:

It's fine as a clean-up, but would it be better still to use IRBuilder?

I can certainly do that, but that will do constant propagation; do we want that here?

[spatel]

In D47117#1105974, @lebedev.ri wrote:

In D47117#1105928, @spatel wrote:

It's fine as a clean-up, but would it be better still to use IRBuilder?

I can certainly do that, but that will do constant propagation; do we want that here?

Hmm...not sure what the trade-off would be in that case. Do you have an example in mind?

[craig.topper]

IRBuilder constant folding can be disable by declaring it as IRBuilder<NoFolder>

lib/Transforms/Scalar/CorrelatedValuePropagation.cpp

static bool hasPositiveOperands(BinaryOperator *SDI, LazyValueInfo *LVI) {
   for (Value *O : SDI->operands()) {
     auto Result = LVI->getPredicateAt(ICmpInst::ICMP_SGE, O, Zero, SDI);
     if (Result != LazyValueInfo::True)
       return false;
   }
   return true;
 }
 
+// NOTE: do not forget to call Instr->eraseFromParent(); afterwards!
+BinaryOperator *CreateTruncatedBO(BinaryOperator *Instr, unsigned NewWidth) {
+  auto *TruncTy = Type::getIntNTy(Instr->getContext(), NewWidth);
+  auto *LHS = CastInst::Create(Instruction::Trunc, Instr->getOperand(0),
+                               TruncTy, Instr->getName() + ".lhs.trunc", Instr);
+  auto *RHS = CastInst::Create(Instruction::Trunc, Instr->getOperand(1),
+                               TruncTy, Instr->getName() + ".rhs.trunc", Instr);
+  auto *BO = BinaryOperator::Create(Instr->getOpcode(), LHS, RHS,
+                                    Instr->getName(), Instr);
+  auto *Zext = CastInst::Create(Instruction::ZExt, BO, Instr->getType(),
+                                Instr->getName() + ".zext", Instr);
+  Instr->replaceAllUsesWith(Zext);
+  return BO;
+}
+
 /// Try to shrink a udiv/urem's width down to the smallest power of two that's
 /// sufficient to contain its operands.
 static bool processUDivOrURem(BinaryOperator *Instr, LazyValueInfo *LVI) {
   assert(Instr->getOpcode() == Instruction::UDiv ||
          Instr->getOpcode() == Instruction::URem);
   if (Instr->getType()->isVectorTy())
     return false;
 
static bool processUDivOrURem(BinaryOperator *Instr, LazyValueInfo *LVI) {
   unsigned NewWidth = std::max<unsigned>(
       PowerOf2Ceil(OperandRange.getUnsignedMax().getActiveBits()), 8);
   // NewWidth might be greater than OrigWidth if OrigWidth is not a power of
   // two.
   if (NewWidth >= OrigWidth)
     return false;
 
   ++NumUDivs;
-  auto *TruncTy = Type::getIntNTy(Instr->getContext(), NewWidth);
-  auto *LHS = CastInst::Create(Instruction::Trunc, Instr->getOperand(0), TruncTy,
-                               Instr->getName() + ".lhs.trunc", Instr);
-  auto *RHS = CastInst::Create(Instruction::Trunc, Instr->getOperand(1), TruncTy,
-                               Instr->getName() + ".rhs.trunc", Instr);
-  auto *BO =
-      BinaryOperator::Create(Instr->getOpcode(), LHS, RHS, Instr->getName(), Instr);
-  auto *Zext = CastInst::Create(Instruction::ZExt, BO, Instr->getType(),
-                                Instr->getName() + ".zext", Instr);
+  auto *BO = CreateTruncatedBO(Instr, NewWidth);
   if (BO->getOpcode() == Instruction::UDiv)
     BO->setIsExact(Instr->isExact());
-
-  Instr->replaceAllUsesWith(Zext);
   Instr->eraseFromParent();
   return true;
 }
 
 static bool processSRem(BinaryOperator *SDI, LazyValueInfo *LVI) {
   if (SDI->getType()->isVectorTy() || !hasPositiveOperands(SDI, LVI))
     return false;