[ConstExpr] Don't create div/rem expressions

[nikic]

Summary

This removes creation of udiv/sdiv/urem/srem constant expressions, in preparation for their removal. I've added a ConstantExpr::isDesirableBinOp() predicate to determine whether an expression should be created for a certain operator.

With this patch, div/rem expressions can still be created through explicit IR/bitcode -- forbidding them entirely will be the next step.

[nikic]

I think I'll do some additional work on the IRBuilderFolder first.

[nikic]

Be more thorough about not creating div/rem expressions, update tests.

[nikic]

Check for desirable binops in one more place.

[nhaehnle]

LGTM, one suggestion though.

llvm/lib/IR/Constants.cpp

2368–2379 ↗

(On Diff #442100)

Is the plan to successively make more ops undesirable? Perhaps this should be a whitelist instead of a blacklist.

[nikic]

llvm/lib/IR/Constants.cpp

2368–2379 ↗

(On Diff #442100)

I went with the "Why don't we have both?" approach here and explicitly listed both the desirable and undesirable binops. And yes, I plan to successively move these until only add and sub are left in the bottom list.

llvm/include/llvm/Analysis/TargetFolder.h

public:
   Value *FoldOr(Value *LHS, Value *RHS) const override {
     auto *LC = dyn_cast<Constant>(LHS);
     auto *RC = dyn_cast<Constant>(RHS);
     if (LC && RC)
       return Fold(ConstantExpr::getOr(LC, RC));
     return nullptr;
   }
 
-  Value *FoldUDiv(Value *LHS, Value *RHS, bool IsExact) const override {
+  Value *FoldBinOp(Instruction::BinaryOps Opcode, Value *LHS,
+                   Value *RHS) const {
     auto *LC = dyn_cast<Constant>(LHS);
     auto *RC = dyn_cast<Constant>(RHS);
     if (LC && RC)
-      return Fold(ConstantExpr::getUDiv(LC, RC, IsExact));
+      return ConstantFoldBinaryOpOperands(Opcode, LC, RC, DL);
     return nullptr;
   }
 
+  Value *FoldUDiv(Value *LHS, Value *RHS, bool IsExact) const override {
+    return FoldBinOp(Instruction::UDiv, LHS, RHS);
+  }
+
   Value *FoldSDiv(Value *LHS, Value *RHS, bool IsExact) const override {
-    auto *LC = dyn_cast<Constant>(LHS);
-    auto *RC = dyn_cast<Constant>(RHS);
-    if (LC && RC)
-      return Fold(ConstantExpr::getSDiv(LC, RC, IsExact));
-    return nullptr;
+    return FoldBinOp(Instruction::SDiv, LHS, RHS);
   }
 
   Value *FoldURem(Value *LHS, Value *RHS) const override {
-    auto *LC = dyn_cast<Constant>(LHS);
-    auto *RC = dyn_cast<Constant>(RHS);
-    if (LC && RC)
-      return Fold(ConstantExpr::getURem(LC, RC));
-    return nullptr;
+    return FoldBinOp(Instruction::URem, LHS, RHS);
   }
 
   Value *FoldSRem(Value *LHS, Value *RHS) const override {
-    auto *LC = dyn_cast<Constant>(LHS);
-    auto *RC = dyn_cast<Constant>(RHS);
-    if (LC && RC)
-      return Fold(ConstantExpr::getSRem(LC, RC));
-    return nullptr;
+    return FoldBinOp(Instruction::SRem, LHS, RHS);
   }
 
   Value *FoldICmp(CmpInst::Predicate P, Value *LHS, Value *RHS) const override {
     auto *LC = dyn_cast<Constant>(LHS);
     auto *RC = dyn_cast<Constant>(RHS);
     if (LC && RC)
       return ConstantExpr::getCompare(P, LC, RC);
     return nullptr;

llvm/include/llvm/IR/ConstantFolder.h

public:
   Value *FoldOr(Value *LHS, Value *RHS) const override {
     auto *LC = dyn_cast<Constant>(LHS);
     auto *RC = dyn_cast<Constant>(RHS);
     if (LC && RC)
       return ConstantExpr::getOr(LC, RC);
     return nullptr;
   }
 
-  Value *FoldUDiv(Value *LHS, Value *RHS, bool IsExact) const override {
+  Value *FoldBinOp(Instruction::BinaryOps Opcode, Value *LHS,
+                   Value *RHS) const {
     auto *LC = dyn_cast<Constant>(LHS);
     auto *RC = dyn_cast<Constant>(RHS);
     if (LC && RC)
-      return ConstantExpr::getUDiv(LC, RC, IsExact);
+      return ConstantFoldBinaryInstruction(Opcode, LC, RC);
     return nullptr;
   }
 
+  Value *FoldUDiv(Value *LHS, Value *RHS, bool IsExact) const override {
+    return FoldBinOp(Instruction::UDiv, LHS, RHS);
+  }
+
   Value *FoldSDiv(Value *LHS, Value *RHS, bool IsExact) const override {
-    auto *LC = dyn_cast<Constant>(LHS);
-    auto *RC = dyn_cast<Constant>(RHS);
-    if (LC && RC)
-      return ConstantExpr::getSDiv(LC, RC, IsExact);
-    return nullptr;
+    return FoldBinOp(Instruction::SDiv, LHS, RHS);
   }
 
   Value *FoldURem(Value *LHS, Value *RHS) const override {
-    auto *LC = dyn_cast<Constant>(LHS);
-    auto *RC = dyn_cast<Constant>(RHS);
-    if (LC && RC)
-      return ConstantExpr::getURem(LC, RC);
-    return nullptr;
+    return FoldBinOp(Instruction::URem, LHS, RHS);
   }
 
   Value *FoldSRem(Value *LHS, Value *RHS) const override {
-    auto *LC = dyn_cast<Constant>(LHS);
-    auto *RC = dyn_cast<Constant>(RHS);
-    if (LC && RC)
-      return ConstantExpr::getSRem(LC, RC);
-    return nullptr;
+    return FoldBinOp(Instruction::SRem, LHS, RHS);
   }
 
   Value *FoldICmp(CmpInst::Predicate P, Value *LHS, Value *RHS) const override {
     auto *LC = dyn_cast<Constant>(LHS);
     auto *RC = dyn_cast<Constant>(RHS);
     if (LC && RC)
       return ConstantExpr::getCompare(P, LC, RC);
     return nullptr;

llvm/lib/Analysis/ScalarEvolution.cpp

if (Constant *C = BuildConstantFromSCEV(SM->getOperand(0))) {
         if (!C2 || C2->getType()->isPointerTy())
           return nullptr;
         C = ConstantExpr::getMul(C, C2);
       }
       return C;
     }
     return nullptr;
   }
-  case scUDivExpr: {
-    const SCEVUDivExpr *SU = cast<SCEVUDivExpr>(V);
-    if (Constant *LHS = BuildConstantFromSCEV(SU->getLHS()))
-      if (Constant *RHS = BuildConstantFromSCEV(SU->getRHS()))
-        if (LHS->getType() == RHS->getType())
-          return ConstantExpr::getUDiv(LHS, RHS);
-    return nullptr;
-  }
+  case scUDivExpr:
   case scSMaxExpr:
   case scUMaxExpr:
   case scSMinExpr:
   case scUMinExpr:
   case scSequentialUMinExpr:
     return nullptr; // TODO: smax, umax, smin, umax, umin_seq.
   }
   llvm_unreachable("Unknown SCEV kind!");

llvm/lib/IR/ConstantFold.cpp

Constant *Factor =
         ConstantInt::get(CurrIdx->getType()->getScalarType(), NumElements);
     if (UseVector)
       Factor = ConstantDataVector::getSplat(
           IsPrevIdxVector
               ? cast<FixedVectorType>(PrevIdx->getType())->getNumElements()
               : cast<FixedVectorType>(CurrIdx->getType())->getNumElements(),
           Factor);
 
-    NewIdxs[i] = ConstantExpr::getSRem(CurrIdx, Factor);
+    NewIdxs[i] =
+        ConstantFoldBinaryInstruction(Instruction::SRem, CurrIdx, Factor);
 
-    Constant *Div = ConstantExpr::getSDiv(CurrIdx, Factor);
+    Constant *Div =
+        ConstantFoldBinaryInstruction(Instruction::SDiv, CurrIdx, Factor);
+
+    // We're working on either ConstantInt or vectors of ConstantInt,
+    // so these should always fold.
+    assert(NewIdxs[i] != nullptr && Div != nullptr && "Should have folded");
 
     unsigned CommonExtendedWidth =
         std::max(PrevIdx->getType()->getScalarSizeInBits(),
                  Div->getType()->getScalarSizeInBits());
     CommonExtendedWidth = std::max(CommonExtendedWidth, 64U);
 
     // Before adding, extend both operands to i64 to avoid
     // overflow trouble.

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

case Intrinsic::fshr: {
     Value *Op0 = II->getArgOperand(0), *Op1 = II->getArgOperand(1);
     Type *Ty = II->getType();
     unsigned BitWidth = Ty->getScalarSizeInBits();
     Constant *ShAmtC;
     if (match(II->getArgOperand(2), m_ImmConstant(ShAmtC)) &&
         !ShAmtC->containsConstantExpression()) {
       // Canonicalize a shift amount constant operand to modulo the bit-width.
       Constant *WidthC = ConstantInt::get(Ty, BitWidth);
-      Constant *ModuloC = ConstantExpr::getURem(ShAmtC, WidthC);
+      Constant *ModuloC =
+          ConstantFoldBinaryOpOperands(Instruction::URem, ShAmtC, WidthC, DL);
+      if (!ModuloC)
+        return nullptr;
       if (ModuloC != ShAmtC)
         return replaceOperand(*II, 2, ModuloC);
 
       assert(ConstantExpr::getICmp(ICmpInst::ICMP_UGT, WidthC, ShAmtC) ==
                  ConstantInt::getTrue(CmpInst::makeCmpResultType(Ty)) &&
              "Shift amount expected to be modulo bitwidth");
 
       // Canonicalize funnel shift right by constant to funnel shift left. This