[ConstExpr] Remove div/rem constant expressions

[nikic]

Summary

D128820 stopped creating div/rem constant expressions by default; this patch removes support for them entirely.

The getUDiv(), getExactUDiv(), getSDiv(), getExactSDiv(), getURem() and getSRem() on ConstantExpr are removed, and ConstantExpr::get() now only accepts binary operators for which ConstantExpr::isSupportedBinOp() returns true. Uses of these methods may be replaced either by corresponding IRBuilder methods, or ConstantFoldBinaryOpOperands (if a constant result is required).

On the C API side, LLVMConstUDiv, LLVMConstExactUDiv, LLVMConstSDiv, LLVMConstExactSDiv, LLVMConstURem and LLVMConstSRem are removed and corresponding LLVMBuild methods should be used.

Importantly, this also means that constant expressions can no longer trap! This patch still keeps the canTrap() method to minimize diff -- I plan to drop it in a separate NFC patch (but could fold that into here as well).

[reames]

LGTM.

Not required, but I'd encourage you to avoid deleting the tests. I spot checked and didn't see any where removing wasn't at least defensible, but I'd generally prefer to see the constant exprs replaces with instructions and the tests kept as much as possible. I worry that tests which appear to exercise only trapping constants might be the only trapping coverage we have at all for a given transform.

llvm/bindings/go/llvm/ir.go

 func ConstSub(lhs, rhs Value) (v Value)       { v.C = C.LLVMConstSub(lhs.C, rhs.C); return }
 func ConstNSWSub(lhs, rhs Value) (v Value)    { v.C = C.LLVMConstNSWSub(lhs.C, rhs.C); return }
 func ConstNUWSub(lhs, rhs Value) (v Value)    { v.C = C.LLVMConstNUWSub(lhs.C, rhs.C); return }
 func ConstFSub(lhs, rhs Value) (v Value)      { v.C = C.LLVMConstFSub(lhs.C, rhs.C); return }
 func ConstMul(lhs, rhs Value) (v Value)       { v.C = C.LLVMConstMul(lhs.C, rhs.C); return }
 func ConstNSWMul(lhs, rhs Value) (v Value)    { v.C = C.LLVMConstNSWMul(lhs.C, rhs.C); return }
 func ConstNUWMul(lhs, rhs Value) (v Value)    { v.C = C.LLVMConstNUWMul(lhs.C, rhs.C); return }
 func ConstFMul(lhs, rhs Value) (v Value)      { v.C = C.LLVMConstFMul(lhs.C, rhs.C); return }
-func ConstUDiv(lhs, rhs Value) (v Value)      { v.C = C.LLVMConstUDiv(lhs.C, rhs.C); return }
-func ConstSDiv(lhs, rhs Value) (v Value)      { v.C = C.LLVMConstSDiv(lhs.C, rhs.C); return }
-func ConstExactSDiv(lhs, rhs Value) (v Value) { v.C = C.LLVMConstExactSDiv(lhs.C, rhs.C); return }
 func ConstFDiv(lhs, rhs Value) (v Value)      { v.C = C.LLVMConstFDiv(lhs.C, rhs.C); return }
-func ConstURem(lhs, rhs Value) (v Value)      { v.C = C.LLVMConstURem(lhs.C, rhs.C); return }
-func ConstSRem(lhs, rhs Value) (v Value)      { v.C = C.LLVMConstSRem(lhs.C, rhs.C); return }
 func ConstFRem(lhs, rhs Value) (v Value)      { v.C = C.LLVMConstFRem(lhs.C, rhs.C); return }
 func ConstAnd(lhs, rhs Value) (v Value)       { v.C = C.LLVMConstAnd(lhs.C, rhs.C); return }
 func ConstOr(lhs, rhs Value) (v Value)        { v.C = C.LLVMConstOr(lhs.C, rhs.C); return }
 func ConstXor(lhs, rhs Value) (v Value)       { v.C = C.LLVMConstXor(lhs.C, rhs.C); return }
 
 func ConstICmp(pred IntPredicate, lhs, rhs Value) (v Value) {
   v.C = C.LLVMConstICmp(C.LLVMIntPredicate(pred), lhs.C, rhs.C)
   return

llvm/bindings/ocaml/llvm/llvm.ml

 external const_sub : llvalue -> llvalue -> llvalue = "LLVMConstSub"
 external const_nsw_sub : llvalue -> llvalue -> llvalue = "LLVMConstNSWSub"
 external const_nuw_sub : llvalue -> llvalue -> llvalue = "LLVMConstNUWSub"
 external const_fsub : llvalue -> llvalue -> llvalue = "LLVMConstFSub"
 external const_mul : llvalue -> llvalue -> llvalue = "LLVMConstMul"
 external const_nsw_mul : llvalue -> llvalue -> llvalue = "LLVMConstNSWMul"
 external const_nuw_mul : llvalue -> llvalue -> llvalue = "LLVMConstNUWMul"
 external const_fmul : llvalue -> llvalue -> llvalue = "LLVMConstFMul"
-external const_udiv : llvalue -> llvalue -> llvalue = "LLVMConstUDiv"
-external const_sdiv : llvalue -> llvalue -> llvalue = "LLVMConstSDiv"
-external const_exact_sdiv : llvalue -> llvalue -> llvalue = "LLVMConstExactSDiv"
 external const_fdiv : llvalue -> llvalue -> llvalue = "LLVMConstFDiv"
-external const_urem : llvalue -> llvalue -> llvalue = "LLVMConstURem"
-external const_srem : llvalue -> llvalue -> llvalue = "LLVMConstSRem"
 external const_frem : llvalue -> llvalue -> llvalue = "LLVMConstFRem"
 external const_and : llvalue -> llvalue -> llvalue = "LLVMConstAnd"
 external const_or : llvalue -> llvalue -> llvalue = "LLVMConstOr"
 external const_xor : llvalue -> llvalue -> llvalue = "LLVMConstXor"
 external const_icmp : Icmp.t -> llvalue -> llvalue -> llvalue
                     = "llvm_const_icmp"
 external const_fcmp : Fcmp.t -> llvalue -> llvalue -> llvalue
                     = "llvm_const_fcmp"

llvm/bindings/ocaml/llvm/llvm.mli

(** [const_nuw_mul c1 c2] returns the constant product of two constants with
     no unsigned wrapping. The result is undefined if the sum overflows.
     See the method [llvm::ConstantExpr::getNSWMul]. *)
 val const_nuw_mul : llvalue -> llvalue -> llvalue
 
 (** [const_fmul c1 c2] returns the constant product of two constants floats.
     See the method [llvm::ConstantExpr::getFMul]. *)
 val const_fmul : llvalue -> llvalue -> llvalue
 
-(** [const_udiv c1 c2] returns the constant quotient [c1 / c2] of two unsigned
-    integer constants.
-    See the method [llvm::ConstantExpr::getUDiv]. *)
-val const_udiv : llvalue -> llvalue -> llvalue
-
-(** [const_sdiv c1 c2] returns the constant quotient [c1 / c2] of two signed
-    integer constants.
-    See the method [llvm::ConstantExpr::getSDiv]. *)
-val const_sdiv : llvalue -> llvalue -> llvalue
-
-(** [const_exact_sdiv c1 c2] returns the constant quotient [c1 / c2] of two
-    signed integer constants. The result is undefined if the result is rounded
-    or overflows. See the method [llvm::ConstantExpr::getExactSDiv]. *)
-val const_exact_sdiv : llvalue -> llvalue -> llvalue
-
 (** [const_fdiv c1 c2] returns the constant quotient [c1 / c2] of two floating
     point constants.
     See the method [llvm::ConstantExpr::getFDiv]. *)
 val const_fdiv : llvalue -> llvalue -> llvalue
 
-(** [const_urem c1 c2] returns the constant remainder [c1 MOD c2] of two
-    unsigned integer constants.
-    See the method [llvm::ConstantExpr::getURem]. *)
-val const_urem : llvalue -> llvalue -> llvalue
-
-(** [const_srem c1 c2] returns the constant remainder [c1 MOD c2] of two
-    signed integer constants.
-    See the method [llvm::ConstantExpr::getSRem]. *)
-val const_srem : llvalue -> llvalue -> llvalue
-
 (** [const_frem c1 c2] returns the constant remainder [c1 MOD c2] of two
     signed floating point constants.
     See the method [llvm::ConstantExpr::getFRem]. *)
 val const_frem : llvalue -> llvalue -> llvalue
 
 (** [const_and c1 c2] returns the constant bitwise [AND] of two integer
     constants.
     See the method [llvm::ConstantExpr::getAnd]. *)

llvm/docs/ReleaseNotes.rst

 ----------------------
 
 * Renamed ``llvm.experimental.vector.extract`` intrinsic to ``llvm.vector.extract``.
 * Renamed ``llvm.experimental.vector.insert`` intrinsic to ``llvm.vector.insert``.
 * The constant expression variants of the following instructions have been
   removed:
   * ``extractvalue``
   * ``insertvalue``
+  * ``udiv``
+  * ``sdiv``
+  * ``urem``
+  * ``srem``
 
 Changes to building LLVM
 ------------------------
 
 * Omitting ``CMAKE_BUILD_TYPE`` when using a single configuration generator is now
   an error. You now have to pass ``-DCMAKE_BUILD_TYPE=<type>`` in order to configure
   LLVM. This is done to help new users of LLVM select the correct type: since building
   LLVM in Debug mode is very resource intensive, we want to make sure that new users
* Add ``LLVMGetAggregateElement`` function as a wrapper for
   only instances of ``ConstantDataSequential``.
 
 * The following functions for creating constant expressions have been removed,
   because the underlying constant expressions are no longer supported. Instead,
   an instruction should be created using the ``LLVMBuildXYZ`` APIs, which will
   constant fold the operands if possible and create an instruction otherwise:
   * ``LLVMConstExtractValue``
   * ``LLVMConstInsertValue``
+  * ``LLVMConstUDiv``
+  * ``LLVMConstExactUDiv``
+  * ``LLVMConstSDiv``
+  * ``LLVMConstExactSDiv``
+  * ``LLVMConstURem``
+  * ``LLVMConstSRem``
 
 Changes to the Go bindings
 --------------------------
 
 
 Changes to the FastISel infrastructure
 --------------------------------------
 

llvm/include/llvm-c/Core.h

 LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 LLVMValueRef LLVMConstNSWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 LLVMValueRef LLVMConstNUWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 LLVMValueRef LLVMConstFSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 LLVMValueRef LLVMConstNSWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 LLVMValueRef LLVMConstNUWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
-LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
-LLVMValueRef LLVMConstExactUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
-LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
-LLVMValueRef LLVMConstExactSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
-LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
-LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
                            LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
                            LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);

llvm/include/llvm/IR/Constants.h

static Constant *getAdd(Constant *C1, Constant *C2, bool HasNUW = false,
                           bool HasNSW = false);
   static Constant *getFAdd(Constant *C1, Constant *C2);
   static Constant *getSub(Constant *C1, Constant *C2, bool HasNUW = false,
                           bool HasNSW = false);
   static Constant *getFSub(Constant *C1, Constant *C2);
   static Constant *getMul(Constant *C1, Constant *C2, bool HasNUW = false,
                           bool HasNSW = false);
   static Constant *getFMul(Constant *C1, Constant *C2);
-  static Constant *getUDiv(Constant *C1, Constant *C2, bool isExact = false);
-  static Constant *getSDiv(Constant *C1, Constant *C2, bool isExact = false);
   static Constant *getFDiv(Constant *C1, Constant *C2);
-  static Constant *getURem(Constant *C1, Constant *C2);
-  static Constant *getSRem(Constant *C1, Constant *C2);
   static Constant *getFRem(Constant *C1, Constant *C2);
   static Constant *getAnd(Constant *C1, Constant *C2);
   static Constant *getOr(Constant *C1, Constant *C2);
   static Constant *getXor(Constant *C1, Constant *C2);
   static Constant *getUMin(Constant *C1, Constant *C2);
   static Constant *getShl(Constant *C1, Constant *C2, bool HasNUW = false,
                           bool HasNSW = false);
   static Constant *getLShr(Constant *C1, Constant *C2, bool isExact = false);
public:
   static Constant *getNSWShl(Constant *C1, Constant *C2) {
     return getShl(C1, C2, false, true);
   }
 
   static Constant *getNUWShl(Constant *C1, Constant *C2) {
     return getShl(C1, C2, true, false);
   }
 
-  static Constant *getExactSDiv(Constant *C1, Constant *C2) {
-    return getSDiv(C1, C2, true);
-  }
-
-  static Constant *getExactUDiv(Constant *C1, Constant *C2) {
-    return getUDiv(C1, C2, true);
-  }
-
   static Constant *getExactAShr(Constant *C1, Constant *C2) {
     return getAShr(C1, C2, true);
   }
 
   static Constant *getExactLShr(Constant *C1, Constant *C2) {
     return getLShr(C1, C2, true);
   }
 
public:
   /// implementation details of ConstantExpr outside of Constants.cpp, which
   /// would make it harder to remove ConstantExprs altogether.
   Instruction *getAsInstruction(Instruction *InsertBefore = nullptr) const;
 
   /// Whether creating a constant expression for this binary operator is
   /// desirable.
   static bool isDesirableBinOp(unsigned Opcode);
 
+  /// Whether creating a constant expression for this binary operator is
+  /// supported.
+  static bool isSupportedBinOp(unsigned Opcode);
+
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Value *V) {
     return V->getValueID() == ConstantExprVal;
   }
 
 private:
   // Shadow Value::setValueSubclassData with a private forwarding method so that
   // subclasses cannot accidentally use it.

llvm/lib/AsmParser/LLParser.cpp

ID.ConstantVal = ConstantExpr::getCast((Instruction::CastOps)Opc,
                                                  SrcVal, DestTy);
     ID.Kind = ValID::t_Constant;
     return false;
   }
   case lltok::kw_extractvalue:
     return error(ID.Loc, "extractvalue constexprs are no longer supported");
   case lltok::kw_insertvalue:
     return error(ID.Loc, "insertvalue constexprs are no longer supported");
+  case lltok::kw_udiv:
+    return error(ID.Loc, "udiv constexprs are no longer supported");
+  case lltok::kw_sdiv:
+    return error(ID.Loc, "sdiv constexprs are no longer supported");
+  case lltok::kw_urem:
+    return error(ID.Loc, "urem constexprs are no longer supported");
+  case lltok::kw_srem:
+    return error(ID.Loc, "srem constexprs are no longer supported");
   case lltok::kw_icmp:
   case lltok::kw_fcmp: {
     unsigned PredVal, Opc = Lex.getUIntVal();
     Constant *Val0, *Val1;
     Lex.Lex();
     if (parseCmpPredicate(PredVal, Opc) ||
         parseToken(lltok::lparen, "expected '(' in compare constantexpr") ||
         parseGlobalTypeAndValue(Val0) ||
bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS, Type *ExpectedTy) {
   }
   // Binary Operators.
   case lltok::kw_add:
   case lltok::kw_fadd:
   case lltok::kw_sub:
   case lltok::kw_fsub:
   case lltok::kw_mul:
   case lltok::kw_fmul:
-  case lltok::kw_udiv:
-  case lltok::kw_sdiv:
   case lltok::kw_fdiv:
-  case lltok::kw_urem:
-  case lltok::kw_srem:
   case lltok::kw_frem:
   case lltok::kw_shl:
   case lltok::kw_lshr:
   case lltok::kw_ashr: {
     bool NUW = false;
     bool NSW = false;
     bool Exact = false;
     unsigned Opc = Lex.getUIntVal();

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

#endif
   return TypeID;
 }
 
 static bool isConstExprSupported(uint8_t Opcode) {
   // These are not real constant expressions, always consider them supported.
   if (Opcode >= BitcodeConstant::FirstSpecialOpcode)
     return true;
 
+  if (Instruction::isBinaryOp(Opcode))
+    return ConstantExpr::isSupportedBinOp(Opcode);
+
   return !ExpandConstantExprs;
 }
 
 Expected<Value *> BitcodeReader::materializeValue(unsigned StartValID,
                                                   BasicBlock *InsertBB) {
   // Quickly handle the case where there is no BitcodeConstant to resolve.
   if (StartValID < ValueList.size() && ValueList[StartValID] &&
       !isa<BitcodeConstant>(ValueList[StartValID]))

llvm/lib/IR/Constants.cpp

case Constant::ConstantExprVal:
     else
       llvm_unreachable("Unexpected constant expr");
     break;
   default:
     llvm_unreachable("Unexpected constant");
   }
 }
 
-static bool canTrapImpl(const Constant *C,
-                        SmallPtrSetImpl<const Constant *> &NonTrappingOps) {
-  assert(C->getType()->isFirstClassType() &&
-         "Cannot evaluate non-first-class types!");
-  // ConstantExpr or ConstantAggregate trap if any operands can trap.
-  if (isa<ConstantExpr>(C) || isa<ConstantAggregate>(C)) {
-    for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i) {
-      const Constant *Op = cast<Constant>(C->getOperand(i));
-      if (isa<ConstantExpr>(Op) || isa<ConstantAggregate>(Op)) {
-        if (NonTrappingOps.insert(Op).second && canTrapImpl(Op, NonTrappingOps))
-          return true;
-      }
-    }
-  }
-
-  // The only leafs that can trap are constant expressions.
-  const ConstantExpr *CE = dyn_cast<ConstantExpr>(C);
-  if (!CE)
-    return false;
-
-  // Otherwise, only specific operations can trap.
-  switch (CE->getOpcode()) {
-  default:
-    return false;
-  case Instruction::SDiv:
-  case Instruction::SRem:
-    // Signed div/rem can trap for SignedMin / -1.
-    if (!CE->getOperand(0)->isNotMinSignedValue() &&
-        (!isa<ConstantInt>(CE->getOperand(1)) ||
-         CE->getOperand(1)->isAllOnesValue()))
-      return true;
-    LLVM_FALLTHROUGH;
-  case Instruction::UDiv:
-  case Instruction::URem:
-    // Div and rem can trap if the RHS is not known to be non-zero.
-    return !isa<ConstantInt>(CE->getOperand(1)) ||
-           CE->getOperand(1)->isNullValue();
-  }
-}
-
 bool Constant::canTrap() const {
-  SmallPtrSet<const Constant *, 4> NonTrappingOps;
-  return canTrapImpl(this, NonTrappingOps);
+  return false;
 }
 
 /// Check if C contains a GlobalValue for which Predicate is true.
 static bool
 ConstHasGlobalValuePredicate(const Constant *C,
                              bool (*Predicate)(const GlobalValue *)) {
   SmallPtrSet<const Constant *, 8> Visited;
   SmallVector<const Constant *, 8> WorkList;
#endif
   return pImpl->ExprConstants.getOrCreate(C->getType(), Key);
 }
 
 Constant *ConstantExpr::get(unsigned Opcode, Constant *C1, Constant *C2,
                             unsigned Flags, Type *OnlyIfReducedTy) {
   // Check the operands for consistency first.
   assert(Instruction::isBinaryOp(Opcode) &&
          "Invalid opcode in binary constant expression");
+  assert(isSupportedBinOp(Opcode) &&
+         "Binop not supported as constant expression");
   assert(C1->getType() == C2->getType() &&
          "Operand types in binary constant expression should match");
 
 #ifndef NDEBUG
   switch (Opcode) {
   case Instruction::Add:
   case Instruction::Sub:
   case Instruction::Mul:
bool ConstantExpr::isDesirableBinOp(unsigned Opcode) {
   case Instruction::FDiv:
   case Instruction::FRem:
     return true;
   default:
     llvm_unreachable("Argument must be binop opcode");
   }
 }
 
+bool ConstantExpr::isSupportedBinOp(unsigned Opcode) {
+  switch (Opcode) {
+  case Instruction::UDiv:
+  case Instruction::SDiv:
+  case Instruction::URem:
+  case Instruction::SRem:
+    return false;
+  case Instruction::Add:
+  case Instruction::Sub:
+  case Instruction::Mul:
+  case Instruction::Shl:
+  case Instruction::LShr:
+  case Instruction::AShr:
+  case Instruction::And:
+  case Instruction::Or:
+  case Instruction::Xor:
+  case Instruction::FAdd:
+  case Instruction::FSub:
+  case Instruction::FMul:
+  case Instruction::FDiv:
+  case Instruction::FRem:
+    return true;
+  default:
+    llvm_unreachable("Argument must be binop opcode");
+  }
+}
+
 Constant *ConstantExpr::getSizeOf(Type* Ty) {
   // sizeof is implemented as: (i64) gep (Ty*)null, 1
   // Note that a non-inbounds gep is used, as null isn't within any object.
   Constant *GEPIdx = ConstantInt::get(Type::getInt32Ty(Ty->getContext()), 1);
   Constant *GEP = getGetElementPtr(
       Ty, Constant::getNullValue(PointerType::getUnqual(Ty)), GEPIdx);
   return getPtrToInt(GEP,
                      Type::getInt64Ty(Ty->getContext()));
unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
                    (HasNSW ? OverflowingBinaryOperator::NoSignedWrap   : 0);
   return get(Instruction::Mul, C1, C2, Flags);
 }
 
 Constant *ConstantExpr::getFMul(Constant *C1, Constant *C2) {
   return get(Instruction::FMul, C1, C2);
 }
 
-Constant *ConstantExpr::getUDiv(Constant *C1, Constant *C2, bool isExact) {
-  return get(Instruction::UDiv, C1, C2,
-             isExact ? PossiblyExactOperator::IsExact : 0);
-}
-
-Constant *ConstantExpr::getSDiv(Constant *C1, Constant *C2, bool isExact) {
-  return get(Instruction::SDiv, C1, C2,
-             isExact ? PossiblyExactOperator::IsExact : 0);
-}
-
 Constant *ConstantExpr::getFDiv(Constant *C1, Constant *C2) {
   return get(Instruction::FDiv, C1, C2);
 }
 
-Constant *ConstantExpr::getURem(Constant *C1, Constant *C2) {
-  return get(Instruction::URem, C1, C2);
-}
-
-Constant *ConstantExpr::getSRem(Constant *C1, Constant *C2) {
-  return get(Instruction::SRem, C1, C2);
-}
-
 Constant *ConstantExpr::getFRem(Constant *C1, Constant *C2) {
   return get(Instruction::FRem, C1, C2);
 }
 
 Constant *ConstantExpr::getAnd(Constant *C1, Constant *C2) {
   return get(Instruction::And, C1, C2);
 }
 

llvm/lib/IR/Core.cpp

return wrap(ConstantExpr::getNUWMul(unwrap<Constant>(LHSConstant),
                                       unwrap<Constant>(RHSConstant)));
 }
 
 LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
   return wrap(ConstantExpr::getFMul(unwrap<Constant>(LHSConstant),
                                     unwrap<Constant>(RHSConstant)));
 }
 
-LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
-  return wrap(ConstantExpr::getUDiv(unwrap<Constant>(LHSConstant),
-                                    unwrap<Constant>(RHSConstant)));
-}
-
-LLVMValueRef LLVMConstExactUDiv(LLVMValueRef LHSConstant,
-                                LLVMValueRef RHSConstant) {
-  return wrap(ConstantExpr::getExactUDiv(unwrap<Constant>(LHSConstant),
-                                         unwrap<Constant>(RHSConstant)));
-}
-
-LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
-  return wrap(ConstantExpr::getSDiv(unwrap<Constant>(LHSConstant),
-                                    unwrap<Constant>(RHSConstant)));
-}
-
-LLVMValueRef LLVMConstExactSDiv(LLVMValueRef LHSConstant,
-                                LLVMValueRef RHSConstant) {
-  return wrap(ConstantExpr::getExactSDiv(unwrap<Constant>(LHSConstant),
-                                         unwrap<Constant>(RHSConstant)));
-}
-
 LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
   return wrap(ConstantExpr::getFDiv(unwrap<Constant>(LHSConstant),
                                     unwrap<Constant>(RHSConstant)));
 }
 
-LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
-  return wrap(ConstantExpr::getURem(unwrap<Constant>(LHSConstant),
-                                    unwrap<Constant>(RHSConstant)));
-}
-
-LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
-  return wrap(ConstantExpr::getSRem(unwrap<Constant>(LHSConstant),
-                                    unwrap<Constant>(RHSConstant)));
-}
-
 LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
   return wrap(ConstantExpr::getFRem(unwrap<Constant>(LHSConstant),
                                     unwrap<Constant>(RHSConstant)));
 }
 
 LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
   return wrap(ConstantExpr::getAnd(unwrap<Constant>(LHSConstant),
                                    unwrap<Constant>(RHSConstant)));

llvm/test/Assembler/flags.ll

; CHECK: ret i64 sub nuw nsw (i64 ptrtoint (i64* @addr to i64), i64 91)
   ret i64 sub nsw nuw (i64 ptrtoint (i64* @addr to i64), i64 91)
 }
 
 define i64 @mul_both_ce() {
 ; CHECK: ret i64 mul nuw nsw (i64 ptrtoint (i64* @addr to i64), i64 91)
   ret i64 mul nuw nsw (i64 ptrtoint (i64* @addr to i64), i64 91)
 }
 
-define i64 @sdiv_exact_ce() {
-; CHECK: ret i64 sdiv exact (i64 ptrtoint (i64* @addr to i64), i64 91)
-  ret i64 sdiv exact (i64 ptrtoint (i64* @addr to i64), i64 91)
-}
-
-define i64 @udiv_exact_ce() {
-; CHECK: ret i64 udiv exact (i64 ptrtoint (i64* @addr to i64), i64 91)
-  ret i64 udiv exact (i64 ptrtoint (i64* @addr to i64), i64 91)
-}
-
 define i64 @ashr_exact_ce() {
 ; CHECK: ret i64 ashr exact (i64 ptrtoint (i64* @addr to i64), i64 9)
   ret i64 ashr exact (i64 ptrtoint (i64* @addr to i64), i64 9)
 }
 
 define i64 @lshr_exact_ce() {
 ; CHECK: ret i64 lshr exact (i64 ptrtoint (i64* @addr to i64), i64 9)
   ret i64 lshr exact (i64 ptrtoint (i64* @addr to i64), i64 9)
; CHECK: ret i64 sub (i64 ptrtoint (i64* @addr to i64), i64 91)
   ret i64 sub (i64 ptrtoint (i64* @addr to i64), i64 91)
 }
 
 define i64 @mul_plain_ce() {
 ; CHECK: ret i64 mul (i64 ptrtoint (i64* @addr to i64), i64 91)
   ret i64 mul (i64 ptrtoint (i64* @addr to i64), i64 91)
 }
 
-define i64 @sdiv_plain_ce() {
-; CHECK: ret i64 sdiv (i64 ptrtoint (i64* @addr to i64), i64 91)
-  ret i64 sdiv (i64 ptrtoint (i64* @addr to i64), i64 91)
-}
-
 define i64* @gep_plain_ce() {
 ; CHECK: ret i64* getelementptr (i64, i64* @addr, i64 171)
         ret i64* getelementptr (i64, i64* @addr, i64 171)
 }
 
 define i64 @add_both_reversed_ce() {
 ; CHECK: ret i64 add nuw nsw (i64 ptrtoint (i64* @addr to i64), i64 91)
   ret i64 add nsw nuw (i64 ptrtoint (i64* @addr to i64), i64 91)

llvm/test/Bindings/OCaml/core.ml

let test_constants () =
    * CHECK: @const_sub = global i64 sub
    * CHECK: @const_nsw_sub = global i64 sub nsw
    * CHECK: @const_nuw_sub = global i64 sub nuw
    * CHECK: @const_fsub = global double fsub
    * CHECK: @const_mul = global i64 mul
    * CHECK: @const_nsw_mul = global i64 mul nsw
    * CHECK: @const_nuw_mul = global i64 mul nuw
    * CHECK: @const_fmul = global double fmul
-   * CHECK: @const_udiv = global i64 udiv
-   * CHECK: @const_sdiv = global i64 sdiv
-   * CHECK: @const_exact_sdiv = global i64 sdiv exact
    * CHECK: @const_fdiv = global double fdiv
-   * CHECK: @const_urem = global i64 urem
-   * CHECK: @const_srem = global i64 srem
    * CHECK: @const_frem = global double frem
    * CHECK: @const_and = global i64 and
    * CHECK: @const_or = global i64 or
    * CHECK: @const_xor = global i64 xor
    * CHECK: @const_icmp = global i1 icmp sle
    * CHECK: @const_fcmp = global i1 fcmp ole
    *)
   let void_ptr = pointer_type i8_type in
let test_constants () =
   ignore (define_global "const_sub" (const_sub foldbomb five) m);
   ignore (define_global "const_nsw_sub" (const_nsw_sub foldbomb five) m);
   ignore (define_global "const_nuw_sub" (const_nuw_sub foldbomb five) m);
   ignore (define_global "const_fsub" (const_fsub ffoldbomb ffive) m);
   ignore (define_global "const_mul" (const_mul foldbomb five) m);
   ignore (define_global "const_nsw_mul" (const_nsw_mul foldbomb five) m);
   ignore (define_global "const_nuw_mul" (const_nuw_mul foldbomb five) m);
   ignore (define_global "const_fmul" (const_fmul ffoldbomb ffive) m);
-  ignore (define_global "const_udiv" (const_udiv foldbomb five) m);
-  ignore (define_global "const_sdiv" (const_sdiv foldbomb five) m);
-  ignore (define_global "const_exact_sdiv" (const_exact_sdiv foldbomb five) m);
   ignore (define_global "const_fdiv" (const_fdiv ffoldbomb ffive) m);
-  ignore (define_global "const_urem" (const_urem foldbomb five) m);
-  ignore (define_global "const_srem" (const_srem foldbomb five) m);
   ignore (define_global "const_frem" (const_frem ffoldbomb ffive) m);
   ignore (define_global "const_and" (const_and foldbomb five) m);
   ignore (define_global "const_or" (const_or foldbomb five) m);
   ignore (define_global "const_xor" (const_xor foldbomb five) m);
   ignore (define_global "const_icmp" (const_icmp Icmp.Sle foldbomb five) m);
   ignore (define_global "const_fcmp" (const_fcmp Fcmp.Ole ffoldbomb ffive) m);
 
   group "constant casts";

llvm/test/CodeGen/X86/critical-edge-split-2.ll

-; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
-; RUN: llc < %s -mtriple=x86_64-unknown-unknown | FileCheck %s
-
-%0 = type <{ %1, %1 }>
-%1 = type { i8, i8, i8, i8 }
-
-@g_2 = dso_local global %0 zeroinitializer
-@g_4 = dso_local global %1 zeroinitializer, align 4
-
-; PR8642
-define i16 @test1(i1 zeroext %C, ptr nocapture %argv) nounwind ssp {
-; CHECK-LABEL: test1:
-; CHECK:       # %bb.0: # %entry
-; CHECK-NEXT:    movw $1, %ax
-; CHECK-NEXT:    testl %edi, %edi
-; CHECK-NEXT:    jne .LBB0_2
-; CHECK-NEXT:  # %bb.1: # %cond.false.i
-; CHECK-NEXT:    movl $g_2+4, %eax
-; CHECK-NEXT:    xorl %ecx, %ecx
-; CHECK-NEXT:    cmpq $g_4, %rax
-; CHECK-NEXT:    sete %cl
-; CHECK-NEXT:    movl $1, %eax
-; CHECK-NEXT:    xorl %edx, %edx
-; CHECK-NEXT:    divl %ecx
-; CHECK-NEXT:    movl %edx, %eax
-; CHECK-NEXT:  .LBB0_2: # %cond.end.i
-; CHECK-NEXT:    # kill: def $ax killed $ax killed $eax
-; CHECK-NEXT:    retq
-
-entry:
-  br i1 %C, label %cond.end.i, label %cond.false.i
-
-cond.false.i:
-  br label %cond.end.i
-
-cond.end.i:
-  %call1 = phi i16 [ trunc (i32 srem (i32 1, i32 zext (i1 icmp eq (ptr getelementptr inbounds (%0, ptr @g_2, i64 0, i32 1, i32 0), ptr @g_4) to i32)) to i16), %cond.false.i ], [ 1, %entry ]
-  ret i16 %call1
-}
-

llvm/test/CodeGen/X86/nonconst-static-div.ll

-; RUN: not --crash llc -mtriple=i686-linux-gnu < %s 2>&1 | FileCheck %s
-
-; Targets only support a limited set of relocations. Make sure that unusual
-; constant expressions (and in particular potentially trapping ones involving
-; division) are already rejected when lowering the Constant to the MC layer,
-; rather than only when trying to emit a relocation. This makes sure that an
-; error is reported when targeting assembly (without -filetype=obj).
-
-@g = external global i32
-@g2 = global i64 sdiv (i64 3, i64 ptrtoint (ptr @g to i64))
-
-; CHECK: Unsupported expression in static initializer: sdiv

llvm/test/CodeGen/X86/pr33396.ll

-; Make sure we don't crash because we have stale loop infos.
-; REQUIRES: asserts
-; RUN: llc -o /dev/null -verify-loop-info %s
-
-target triple = "x86_64-unknown-linux-gnu"
-
-@global = external global [2 x i8], align 2
-@global.1 = external global [2 x i8], align 2
-
-define void @patatino(i8 %tinky) {
-bb:
-  br label %bb1
-
-bb1:
-  br i1 icmp ne (ptr getelementptr ([2 x i8], ptr @global.1, i64 0, i64 1),
-                 ptr getelementptr ([2 x i8], ptr @global, i64 0, i64 1)), label %bb2, label %bb3
-
-bb2:
-  br label %bb3
-
-bb3:
-  %tmp = phi i32 [ 60, %bb2 ],
-                 [ sdiv (i32 60, i32 zext (i1 icmp eq (ptr getelementptr ([2 x i8], ptr @global.1, i64 0, i64 1),
-                                           ptr getelementptr ([2 x i8], ptr @global, i64 0, i64 1)) to i32)), %bb1 ]
-  %tmp4 = icmp slt i8 %tinky, -4
-  br label %bb1
-}

llvm/test/CodeGen/X86/pr49839-trapping-aggregate.ll

-; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
-; RUN: llc -mtriple=x86_64-- < %s | FileCheck %s
-
-@g = global i32 0
-
-define <1 x i64> @trapping_const_agg(i1 %c, i1 %c2) {
-; CHECK-LABEL: trapping_const_agg:
-; CHECK:       # %bb.0: # %entry
-; CHECK-NEXT:    testb $1, %dil
-; CHECK-NEXT:    je .LBB0_4
-; CHECK-NEXT:  # %bb.1: # %if
-; CHECK-NEXT:    testb $1, %sil
-; CHECK-NEXT:    je .LBB0_4
-; CHECK-NEXT:  # %bb.2: # %if.end_crit_edge
-; CHECK-NEXT:    movl $1, %eax
-; CHECK-NEXT:    xorl %edx, %edx
-; CHECK-NEXT:    idivq g@GOTPCREL(%rip)
-; CHECK-NEXT:    movq %rdx, %rax
-; CHECK-NEXT:    retq
-; CHECK-NEXT:  .LBB0_4: # %end2
-; CHECK-NEXT:    xorl %eax, %eax
-; CHECK-NEXT:    retq
-entry:
-  br i1 %c, label %if, label %end
-if:
-  br i1 %c2, label %end, label %end2
-end:
-  %phi = phi <1 x i64> [ zeroinitializer, %entry ], [ <i64 srem (i64 1, i64 ptrtoint (ptr @g to i64))>, %if ]
-  ret <1 x i64> %phi
-
-end2:
-  ret <1 x i64> zeroinitializer
-}

llvm/test/CodeGen/X86/selectiondag-dominator.ll

-; Make sure we don't crash because we have a stale dominator tree.
-; PR33266
-; REQUIRES: asserts
-; RUN: llc -o /dev/null -verify-dom-info %s
-
-target triple = "x86_64-unknown-linux-gnu"
-
-@global = external global [8 x [8 x [4 x i8]]], align 2
-@global.1 = external global { i8, [3 x i8] }, align 4
-
-define void @patatino() local_unnamed_addr {
-bb:
-  br label %bb1
-
-bb1:
-  br label %bb2
-
-bb2:
-  br i1 icmp ne (ptr getelementptr inbounds ({ i8, [3 x i8] }, ptr @global.1, i64 0, i32 0), ptr getelementptr inbounds ([8 x [8 x [4 x i8]]], ptr @global, i64 0, i64 6, i64 6, i64 2)), label %bb4, label %bb3
-
-bb3:
-  br i1 icmp eq (i64 ashr (i64 shl (i64 zext (i32 srem (i32 7, i32 zext (i1 icmp eq (ptr getelementptr inbounds ({ i8, [3 x i8] }, ptr @global.1, i64 0, i32 0), ptr getelementptr inbounds ([8 x [8 x [4 x i8]]], ptr @global, i64 0, i64 6, i64 6, i64 2)) to i32)) to i64), i64 56), i64 56), i64 0), label %bb5, label %bb4
-
-bb4:
-  %tmp = phi i64 [ ashr (i64 shl (i64 zext (i32 srem (i32 7, i32 zext (i1 icmp eq (ptr getelementptr inbounds ({ i8, [3 x i8] }, ptr @global.1, i64 0, i32 0), ptr getelementptr inbounds ([8 x [8 x [4 x i8]]], ptr @global, i64 0, i64 6, i64 6, i64 2)) to i32)) to i64), i64 56), i64 56), %bb3 ], [ 7, %bb2 ]
-  ret void
-
-bb5:
-  ret void
-}

llvm/test/Transforms/GlobalOpt/constant-can-trap.ll

-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -passes=globalopt < %s -S | FileCheck %s
-
-@i = internal unnamed_addr global i32 1, align 4
-@r = internal global i64 0, align 8
-
-; negative test for store-once-global - the urem constant expression must not be speculated
-
-declare dso_local void @use(i32)
-
-define i32 @cantrap_constant() {
-; CHECK-LABEL: @cantrap_constant(
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* @i, align 4
-; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp eq i32 [[TMP0]], 0
-; CHECK-NEXT:    [[NOT_TOBOOL:%.*]] = xor i1 [[TOBOOL]], true
-; CHECK-NEXT:    [[SPEC_SELECT:%.*]] = zext i1 [[NOT_TOBOOL]] to i32
-; CHECK-NEXT:    tail call void @use(i32 [[SPEC_SELECT]])
-; CHECK-NEXT:    br i1 [[TOBOOL]], label [[IF_THEN:%.*]], label [[EXIT:%.*]]
-; CHECK:       if.then:
-; CHECK-NEXT:    store i32 trunc (i64 urem (i64 7, i64 zext (i1 icmp eq (i64* inttoptr (i64 1 to i64*), i64* @r) to i64)) to i32), i32* @i, align 4
-; CHECK-NEXT:    br label [[EXIT]]
-; CHECK:       exit:
-; CHECK-NEXT:    ret i32 0
-;
-entry:
-  %0 = load i32, i32* @i, align 4
-  %tobool = icmp eq i32 %0, 0
-  %not.tobool = xor i1 %tobool, true
-  %spec.select = zext i1 %not.tobool to i32
-  tail call void @use(i32 %spec.select)
-  br i1 %tobool, label %if.then, label %exit
-
-if.then:
-  store i32 trunc (i64 urem (i64 7, i64 zext (i1 icmp eq (i64* inttoptr (i64 1 to i64*), i64* @r) to i64)) to i32), i32* @i, align 4
-  br label %exit
-
-exit:
-  ret i32 0
-}
-
-; negative test for store-once-global - the srem constant expression must not be speculated
-
-@b1 = internal global i64* null, align 8
-@d1 = internal unnamed_addr global i32 0, align 2
-
-define void @maytrap() {
-; CHECK-LABEL: @maytrap(
-; CHECK-NEXT:    store i32 srem (i32 7, i32 zext (i1 icmp eq (i64** inttoptr (i64 16 to i64**), i64** @b1) to i32)), i32* @d1, align 2
-; CHECK-NEXT:    ret void
-;
-  store i32 srem (i32 7, i32 zext (i1 icmp eq (i64** inttoptr (i64 16 to i64**), i64** @b1) to i32)), i32* @d1, align 2
-  ret void
-}
-
-define i32 @main1() {
-; CHECK-LABEL: @main1(
-; CHECK-NEXT:    [[T0:%.*]] = load i32, i32* @d1, align 2
-; CHECK-NEXT:    ret i32 [[T0]]
-;
-  %t0 = load i32, i32* @d1, align 2
-  ret i32 %t0
-}
-
-; This is fine to optimize as a store-once-global constant because the expression can't trap
-
-@b2 = internal global i64* null, align 8
-@d2 = internal unnamed_addr global i32 0, align 2
-
-define void @maynottrap() {
-; CHECK-LABEL: @maynottrap(
-; CHECK-NEXT:    store i1 true, i1* @d2, align 1
-; CHECK-NEXT:    ret void
-;
-  store i32 mul (i32 7, i32 zext (i1 icmp eq (i64** inttoptr (i64 16 to i64**), i64** @b2) to i32)), i32* @d2, align 2
-  ret void
-}
-
-define i32 @main2() {
-; CHECK-LABEL: @main2(
-; CHECK-NEXT:    [[T0_B:%.*]] = load i1, i1* @d2, align 1
-; CHECK-NEXT:    [[T0:%.*]] = select i1 [[T0_B]], i32 mul (i32 zext (i1 icmp eq (i64** inttoptr (i64 16 to i64**), i64** @b2) to i32), i32 7), i32 0
-; CHECK-NEXT:    ret i32 [[T0]]
-;
-  %t0 = load i32, i32* @d2, align 2
-  ret i32 %t0
-}

llvm/test/Transforms/GlobalOpt/ctor-list-opt-constexpr.ll

 @X2 = global %struct.bar zeroinitializer, align 8
 @llvm.global_ctors = appending global [2 x %0] [%0 { i32 65535, void ()* @init1, i8* null }, %0 { i32 65535, void ()* @init2, i8* null }]
 
 ; PR8710 - GlobalOpt shouldn't change the global's initializer to have this
 ; arbitrary constant expression, the code generator can't handle it.
 define internal void @init1() {
 entry:
   %tmp = getelementptr inbounds %struct.foo, %struct.foo* @X, i32 0, i32 0
-  store i32* inttoptr (i64 sdiv (i64 ptrtoint (i32* @G to i64), i64 ptrtoint (i32* @H to i64)) to i32*), i32** %tmp, align 8
+  store i32* inttoptr (i64 xor (i64 ptrtoint (i32* @G to i64), i64 ptrtoint (i32* @H to i64)) to i32*), i32** %tmp, align 8
   ret void
 }
 ; CHECK-LABEL: @init1(
 ; CHECK: store i32*
 
 ; PR11705 - ptrtoint isn't safe in general in global initializers.
 define internal void @init2() {
 entry:
   %tmp = getelementptr inbounds %struct.bar, %struct.bar* @X2, i32 0, i32 0
   store i128 ptrtoint (i32* @G to i128), i128* %tmp, align 16
   ret void
 }
 ; CHECK-LABEL: @init2(
 ; CHECK: store i128

llvm/test/Transforms/InstCombine/indexed-gep-compares.ll

bb7:                                              ; preds = %bb10, %entry-block
   %phi = phi i64* [ @pr30402, %entry ], [ getelementptr inbounds (i64, i64* @pr30402, i32 1), %bb7 ]
   %cmp = icmp eq i64* %phi, getelementptr inbounds (i64, i64* @pr30402, i32 1)
   br i1 %cmp, label %bb10, label %bb7
 
 bb10:
   ret i1 %cmp
 }
 
-; It is not generally safe to hoist an expression (sdiv) that may trap.
-
-define i1 @PR50906() {
-; CHECK-LABEL: @PR50906(
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    br label [[LOOP:%.*]]
-; CHECK:       loop:
-; CHECK-NEXT:    [[PHI:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ 1, [[NEXT:%.*]] ]
-; CHECK-NEXT:    br label [[NEXT]]
-; CHECK:       next:
-; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[PHI]], sdiv (i32 7, i32 ptrtoint (i1 ()* @PR50906 to i32))
-; CHECK-NEXT:    br i1 [[CMP]], label [[EXIT:%.*]], label [[LOOP]]
-; CHECK:       exit:
-; CHECK-NEXT:    ret i1 [[CMP]]
-;
-entry:
-  br label %loop
-
-loop:
-  %phi = phi i32 [ 0, %entry ], [ 1, %next ]
-  br label %next
-
-next:
-  %cmp = icmp sgt i32 sdiv (i32 7, i32 ptrtoint (i1 ()* @PR50906 to i32)), %phi
-  br i1 %cmp, label %exit, label %loop
-
-exit:
-  ret i1 %cmp
-}
-
 declare i32 @__gxx_personality_v0(...)
 
 define i1 @test8(i64* %in, i64 %offset) {
 ; CHECK-LABEL: @test8(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[LD:%.*]] = load i64, i64* [[IN:%.*]], align 8
 ; CHECK-NEXT:    [[TMP0:%.*]] = trunc i64 [[LD]] to i32
 ; CHECK-NEXT:    [[CASTI8:%.*]] = inttoptr i32 [[TMP0]] to i8*

llvm/test/Transforms/InstSimplify/phi.ll

 A:
   br label %EXIT
 B:
   br label %EXIT
 EXIT:
   %r = phi i8 [poison, %A], [poison, %B]
   ret i8 %r
 }
-
-@g = extern_weak global i32
-
-define i64 @pr49839_with_poison(i1 %c) {
-; CHECK-LABEL: @pr49839_with_poison(
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    br i1 [[C:%.*]], label [[IF:%.*]], label [[JOIN:%.*]]
-; CHECK:       if:
-; CHECK-NEXT:    br label [[JOIN]]
-; CHECK:       join:
-; CHECK-NEXT:    [[PHI:%.*]] = phi i64 [ poison, [[IF]] ], [ srem (i64 1, i64 ptrtoint (ptr @g to i64)), [[ENTRY:%.*]] ]
-; CHECK-NEXT:    ret i64 [[PHI]]
-;
-entry:
-  br i1 %c, label %if, label %join
-
-if:
-  br label %join
-
-join:
-  %phi = phi i64 [ poison, %if ], [ srem (i64 1, i64 ptrtoint (ptr @g to i64)) , %entry ]
-  ret i64 %phi
-}
-
-define i64 @pr49839_without_poison(i1 %c) {
-; CHECK-LABEL: @pr49839_without_poison(
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    br i1 [[C:%.*]], label [[IF:%.*]], label [[JOIN:%.*]]
-; CHECK:       if:
-; CHECK-NEXT:    br label [[JOIN]]
-; CHECK:       join:
-; CHECK-NEXT:    ret i64 srem (i64 1, i64 ptrtoint (ptr @g to i64))
-;
-entry:
-  br i1 %c, label %if, label %join
-
-if:
-  br label %join
-
-join:
-  %phi = phi i64 [ srem (i64 1, i64 ptrtoint (ptr @g to i64)), %if ], [ srem (i64 1, i64 ptrtoint (ptr @g to i64)) , %entry ]
-  ret i64 %phi
-}
-
-define <1 x i64> @pr49839_vector(i1 %c) {
-; CHECK-LABEL: @pr49839_vector(
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    br i1 [[C:%.*]], label [[IF:%.*]], label [[JOIN:%.*]]
-; CHECK:       if:
-; CHECK-NEXT:    br label [[JOIN]]
-; CHECK:       join:
-; CHECK-NEXT:    [[PHI:%.*]] = phi <1 x i64> [ poison, [[IF]] ], [ <i64 srem (i64 1, i64 ptrtoint (ptr @g to i64))>, [[ENTRY:%.*]] ]
-; CHECK-NEXT:    ret <1 x i64> [[PHI]]
-;
-entry:
-  br i1 %c, label %if, label %join
-
-if:
-  br label %join
-
-join:
-  %phi = phi <1 x i64> [ poison, %if ], [ <i64 srem (i64 1, i64 ptrtoint (ptr @g to i64))>, %entry ]
-  ret <1 x i64> %phi
-}

llvm/test/Transforms/LoopVectorize/X86/masked_load_store.ll

 
 for.end:                                          ; preds = %for.inc
   ret void
 }
 
 @a = common global [1 x i32*] zeroinitializer, align 8
 @c = common global i32* null, align 8
 
-; The loop here should not be vectorized due to trapping
-; constant expression
-
-define void @foo5(i32* nocapture %A, i32* nocapture readnone %B, i32* nocapture readonly %trigger) local_unnamed_addr #0 {
-; AVX-LABEL: @foo5(
-; AVX-NEXT:  entry:
-; AVX-NEXT:    br label [[FOR_BODY:%.*]]
-; AVX:       for.body:
-; AVX-NEXT:    [[INDVARS_IV:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[FOR_INC:%.*]] ]
-; AVX-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[TRIGGER:%.*]], i64 [[INDVARS_IV]]
-; AVX-NEXT:    [[TMP0:%.*]] = load i32, i32* [[ARRAYIDX]], align 4
-; AVX-NEXT:    [[CMP1:%.*]] = icmp slt i32 [[TMP0]], 100
-; AVX-NEXT:    br i1 [[CMP1]], label [[IF_THEN:%.*]], label [[FOR_INC]]
-; AVX:       if.then:
-; AVX-NEXT:    [[ARRAYIDX7:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i64 [[INDVARS_IV]]
-; AVX-NEXT:    store i32 sdiv (i32 1, i32 zext (i1 icmp eq (i32** getelementptr inbounds ([1 x i32*], [1 x i32*]* @a, i64 1, i64 0), i32** @c) to i32)), i32* [[ARRAYIDX7]], align 4
-; AVX-NEXT:    br label [[FOR_INC]]
-; AVX:       for.inc:
-; AVX-NEXT:    [[INDVARS_IV_NEXT]] = add nuw nsw i64 [[INDVARS_IV]], 1
-; AVX-NEXT:    [[EXITCOND:%.*]] = icmp eq i64 [[INDVARS_IV_NEXT]], 10000
-; AVX-NEXT:    br i1 [[EXITCOND]], label [[FOR_END:%.*]], label [[FOR_BODY]]
-; AVX:       for.end:
-; AVX-NEXT:    ret void
-;
-; AVX512-LABEL: @foo5(
-; AVX512-NEXT:  entry:
-; AVX512-NEXT:    br label [[FOR_BODY:%.*]]
-; AVX512:       for.body:
-; AVX512-NEXT:    [[INDVARS_IV:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[FOR_INC:%.*]] ]
-; AVX512-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[TRIGGER:%.*]], i64 [[INDVARS_IV]]
-; AVX512-NEXT:    [[TMP0:%.*]] = load i32, i32* [[ARRAYIDX]], align 4
-; AVX512-NEXT:    [[CMP1:%.*]] = icmp slt i32 [[TMP0]], 100
-; AVX512-NEXT:    br i1 [[CMP1]], label [[IF_THEN:%.*]], label [[FOR_INC]]
-; AVX512:       if.then:
-; AVX512-NEXT:    [[ARRAYIDX7:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i64 [[INDVARS_IV]]
-; AVX512-NEXT:    store i32 sdiv (i32 1, i32 zext (i1 icmp eq (i32** getelementptr inbounds ([1 x i32*], [1 x i32*]* @a, i64 1, i64 0), i32** @c) to i32)), i32* [[ARRAYIDX7]], align 4
-; AVX512-NEXT:    br label [[FOR_INC]]
-; AVX512:       for.inc:
-; AVX512-NEXT:    [[INDVARS_IV_NEXT]] = add nuw nsw i64 [[INDVARS_IV]], 1
-; AVX512-NEXT:    [[EXITCOND:%.*]] = icmp eq i64 [[INDVARS_IV_NEXT]], 10000
-; AVX512-NEXT:    br i1 [[EXITCOND]], label [[FOR_END:%.*]], label [[FOR_BODY]]
-; AVX512:       for.end:
-; AVX512-NEXT:    ret void
-;
-entry:
-  br label %for.body
-
-for.body:                                         ; preds = %for.inc, %entry
-  %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.inc ]
-  %arrayidx = getelementptr inbounds i32, i32* %trigger, i64 %indvars.iv
-  %0 = load i32, i32* %arrayidx, align 4
-  %cmp1 = icmp slt i32 %0, 100
-  br i1 %cmp1, label %if.then, label %for.inc
-
-if.then:                                          ; preds = %for.body
-  %arrayidx7 = getelementptr inbounds i32, i32* %A, i64 %indvars.iv
-  store i32 sdiv (i32 1, i32 zext (i1 icmp eq (i32** getelementptr inbounds ([1 x i32*], [1 x i32*]* @a, i64 1, i64 0), i32** @c) to i32)), i32* %arrayidx7, align 4
-  br label %for.inc
-
-for.inc:                                          ; preds = %for.body, %if.then
-  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
-  %exitcond = icmp eq i64 %indvars.iv.next, 10000
-  br i1 %exitcond, label %for.end, label %for.body
-
-for.end:                                          ; preds = %for.inc
-  ret void
-}
-
 ; Reverse loop
 ;void foo6(double *in, double *out, unsigned size, int *trigger) {
 ;
 ;  for (int i=SIZE-1; i>=0; i--) {
 ;    if (trigger[i] > 0) {
 ;      out[i] = in[i] + (double) 0.5;
 ;    }
 ;  }

llvm/test/Transforms/LoopVectorize/if-conversion.ll

 
 @a = common global [1 x i32*] zeroinitializer, align 8
 @c = common global i32* null, align 8
 
 ; We use to if convert this loop. This is not safe because there is a trapping
 ; constant expression.
 ; PR16729
 
-; CHECK-LABEL: trapping_constant_expression
-; CHECK-NOT: or <4 x i32>
-
-define i32 @trapping_constant_expression() {
-entry:
-  br label %for.body
-
-for.body:
-  %inc3 = phi i32 [ 0, %entry ], [ %inc, %cond.end ]
-  %or2 = phi i32 [ 0, %entry ], [ %or, %cond.end ]
-  br i1 icmp eq (i32** getelementptr inbounds ([1 x i32*], [1 x i32*]* @a, i64 0, i64 0), i32** @c), label %cond.false, label %cond.end
-
-cond.false:
-  br label %cond.end
-
-cond.end:
-  %cond = phi i32 [ sdiv (i32 1, i32 zext (i1 icmp eq (i32** getelementptr inbounds ([1 x i32*], [1 x i32*]* @a, i64 0, i64 0), i32** @c) to i32)), %cond.false ], [ 0, %for.body ]
-  %or = or i32 %or2, %cond
-  %inc = add nsw i32 %inc3, 1
-  %cmp = icmp slt i32 %inc, 128
-  br i1 %cmp, label %for.body, label %for.end
-
-for.end:
-  ret i32 %or
-}
-
-; Neither should we if-convert if there is an instruction operand that is a
-; trapping constant expression.
-; PR16729
-
-; CHECK-LABEL: trapping_constant_expression2
-; CHECK-NOT: or <4 x i32>
-
-define i32 @trapping_constant_expression2() {
-entry:
-  br label %for.body
-
-for.body:
-  %inc3 = phi i32 [ 0, %entry ], [ %inc, %cond.end ]
-  %or2 = phi i32 [ 0, %entry ], [ %or, %cond.end ]
-  br i1 icmp eq (i32** getelementptr inbounds ([1 x i32*], [1 x i32*]* @a, i64 0, i64 0), i32** @c), label %cond.false, label %cond.end
-
-cond.false:
-  %cond.1 = or i32 %inc3, sdiv (i32 1, i32 zext (i1 icmp eq (i32** getelementptr inbounds ([1 x i32*], [1 x i32*]* @a, i64 0, i64 1), i32** @c) to i32))
-  br label %cond.end
-
-cond.end:
-  %cond = phi i32 [ %cond.1, %cond.false ], [ %inc3, %for.body ]
-  %or = or i32 %or2, %cond
-  %inc = add nsw i32 %inc3, 1
-  %cmp = icmp slt i32 %inc, 128
-  br i1 %cmp, label %for.body, label %for.end
-
-for.end:
-  ret i32 %or
-}
-
 ; Handle PHI with single incoming value having a full mask.
 ; PR34523
 
 ; CHECK-LABEL: PR34523
 ; CHECK: vector.body
 
 define void @PR34523() {
 bb1:

llvm/test/Transforms/SimplifyCFG/2006-10-19-UncondDiv.ll

-; PR957
-; RUN: opt < %s -simplifycfg -simplifycfg-require-and-preserve-domtree=1 -S | FileCheck %s
-
-; CHECK-NOT: select
-
-@G = extern_weak global i32
-
-define i32 @test(i32 %tmp) {
-cond_false179:
-  %tmp181 = icmp eq i32 %tmp, 0    ; <i1> [#uses=1]
-  br i1 %tmp181, label %cond_true182, label %cond_next185
-cond_true182:   ; preds = %cond_false179
-  br label %cond_next185
-cond_next185:   ; preds = %cond_true182, %cond_false179
-  %d0.3 = phi i32 [ udiv (i32 1, i32 ptrtoint (i32* @G to i32)), %cond_true182 ], [ %tmp, %cond_false179 ]    ; <i32> [#uses=1]
-  ret i32 %d0.3
-}
-
-define i32 @test2(i32 %tmp) {
-cond_false179:
-  %tmp181 = icmp eq i32 %tmp, 0    ; <i1> [#uses=1]
-  br i1 %tmp181, label %cond_true182, label %cond_next185
-cond_true182:   ; preds = %cond_false179
-  br label %cond_next185
-cond_next185:   ; preds = %cond_true182, %cond_false179
-  %d0.3 = phi i32 [ udiv (i32 1, i32 ptrtoint (i32* @G to i32)), %cond_true182 ], [ %tmp, %cond_false179 ]    ; <i32> [#uses=1]
-  call i32 @test( i32 4 )   ; <i32>:0 [#uses=0]
-  ret i32 %d0.3
-}

llvm/test/Transforms/SimplifyCFG/ConditionalTrappingConstantExpr.ll

-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -simplifycfg -simplifycfg-require-and-preserve-domtree=1 -S | FileCheck %s
-
-@G = extern_weak global i32
-
-; PR3354
-; Do not merge bb1 into the entry block, it might trap.
-
-define i32 @admiral(i32 %a, i32 %b) {
-; CHECK-LABEL: @admiral(
-; CHECK-NEXT:    [[C:%.*]] = icmp sle i32 [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    br i1 [[C]], label [[COMMON_RET:%.*]], label [[BB1:%.*]]
-; CHECK:       bb1:
-; CHECK-NEXT:    [[D:%.*]] = icmp sgt i32 sdiv (i32 -32768, i32 ptrtoint (i32* @G to i32)), 0
-; CHECK-NEXT:    [[SPEC_SELECT:%.*]] = select i1 [[D]], i32 927, i32 42
-; CHECK-NEXT:    br label [[COMMON_RET]]
-; CHECK:       common.ret:
-; CHECK-NEXT:    [[COMMON_RET_OP:%.*]] = phi i32 [ 42, [[TMP0:%.*]] ], [ [[SPEC_SELECT]], [[BB1]] ]
-; CHECK-NEXT:    ret i32 [[COMMON_RET_OP]]
-;
-  %c = icmp sle i32 %a, %b
-  br i1 %c, label %bb2, label %bb1
-bb1:
-  %d = icmp sgt i32 sdiv (i32 -32768, i32 ptrtoint (i32* @G to i32)), 0
-  br i1 %d, label %bb6, label %bb2
-bb2:
-  ret i32 42
-bb6:
-  ret i32 927
-}
-
-define i32 @ackbar(i1 %c) {
-; CHECK-LABEL: @ackbar(
-; CHECK-NEXT:    br i1 [[C:%.*]], label [[BB5:%.*]], label [[COMMON_RET:%.*]]
-; CHECK:       bb5:
-; CHECK-NEXT:    [[SPEC_SELECT:%.*]] = select i1 icmp sgt (i32 sdiv (i32 32767, i32 ptrtoint (i32* @G to i32)), i32 0), i32 42, i32 927
-; CHECK-NEXT:    br label [[COMMON_RET]]
-; CHECK:       common.ret:
-; CHECK-NEXT:    [[COMMON_RET_OP:%.*]] = phi i32 [ 42, [[TMP0:%.*]] ], [ [[SPEC_SELECT]], [[BB5]] ]
-; CHECK-NEXT:    ret i32 [[COMMON_RET_OP]]
-;
-  br i1 %c, label %bb5, label %bb6
-bb5:
-  br i1 icmp sgt (i32 sdiv (i32 32767, i32 ptrtoint (i32* @G to i32)), i32 0), label %bb6, label %bb7
-bb6:
-  ret i32 42
-bb7:
-  ret i32 927
-}
-
-; FP ops don't trap by default, so this is safe to hoist.
-
-define i32 @tarp(i1 %c) {
-; CHECK-LABEL: @tarp(
-; CHECK-NEXT:  common.ret:
-; CHECK-NEXT:    [[C_NOT:%.*]] = xor i1 [[C:%.*]], true
-; CHECK-NEXT:    [[BRMERGE:%.*]] = or i1 [[C_NOT]], fcmp oeq (float fdiv (float 3.000000e+00, float sitofp (i32 ptrtoint (i32* @G to i32) to float)), float 1.000000e+00)
-; CHECK-NEXT:    [[COMMON_RET_OP:%.*]] = select i1 [[BRMERGE]], i32 42, i32 927
-; CHECK-NEXT:    ret i32 [[COMMON_RET_OP]]
-;
-  br i1 %c, label %bb8, label %bb9
-bb8:
-  br i1 fcmp oeq (float fdiv (float 3.0, float sitofp (i32 ptrtoint (i32* @G to i32) to float)), float 1.0), label %bb9, label %bb10
-bb9:
-  ret i32 42
-bb10:
-  ret i32 927
-}
-
-@g = external global i32
-
-define <1 x i64> @trapping_const_agg(i1 %c) {
-; CHECK-LABEL: @trapping_const_agg(
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    br i1 [[C:%.*]], label [[IF:%.*]], label [[END:%.*]]
-; CHECK:       if:
-; CHECK-NEXT:    br label [[END]]
-; CHECK:       end:
-; CHECK-NEXT:    [[PHI:%.*]] = phi <1 x i64> [ zeroinitializer, [[ENTRY:%.*]] ], [ <i64 srem (i64 1, i64 ptrtoint (i32* @g to i64))>, [[IF]] ]
-; CHECK-NEXT:    ret <1 x i64> [[PHI]]
-;
-entry:
-  br i1 %c, label %if, label %end
-
-if:
-  br label %end
-
-end:
-  %phi = phi <1 x i64> [ zeroinitializer, %entry ], [ <i64 srem (i64 1, i64 ptrtoint (i32* @g to i64))>, %if ]
-  ret <1 x i64> %phi
-}
-
-define i64 @pt56038_sdiv_minus_one(i1 %c) {
-; CHECK-LABEL: @pt56038_sdiv_minus_one(
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    br i1 [[C:%.*]], label [[IF:%.*]], label [[END:%.*]]
-; CHECK:       if:
-; CHECK-NEXT:    br label [[END]]
-; CHECK:       end:
-; CHECK-NEXT:    [[PHI:%.*]] = phi i64 [ sdiv (i64 ptrtoint (i32* @g to i64), i64 -1), [[IF]] ], [ 0, [[ENTRY:%.*]] ]
-; CHECK-NEXT:    ret i64 [[PHI]]
-;
-entry:
-  br i1 %c, label %if, label %end
-
-if:
-  br label %end
-
-end:
-  %phi = phi i64 [ sdiv (i64 ptrtoint (i32* @g to i64), i64 -1), %if ], [ 0, %entry ]
-  ret i64 %phi
-}
-
-define i64 @pt56038_srem_not_minus_one(i1 %c) {
-; CHECK-LABEL: @pt56038_srem_not_minus_one(
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[SPEC_SELECT:%.*]] = select i1 [[C:%.*]], i64 sdiv (i64 ptrtoint (i32* @g to i64), i64 -2), i64 0
-; CHECK-NEXT:    ret i64 [[SPEC_SELECT]]
-;
-entry:
-  br i1 %c, label %if, label %end
-
-if:
-  br label %end
-
-end:
-  %phi = phi i64 [ sdiv (i64 ptrtoint (i32* @g to i64), i64 -2), %if ], [ 0, %entry ]
-  ret i64 %phi
-}
-
-define i64 @pt56038_sdiv_signed_min(i1 %c) {
-; CHECK-LABEL: @pt56038_sdiv_signed_min(
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    br i1 [[C:%.*]], label [[IF:%.*]], label [[END:%.*]]
-; CHECK:       if:
-; CHECK-NEXT:    br label [[END]]
-; CHECK:       end:
-; CHECK-NEXT:    [[PHI:%.*]] = phi i64 [ sdiv (i64 -9223372036854775808, i64 ptrtoint (i32* @g to i64)), [[IF]] ], [ 0, [[ENTRY:%.*]] ]
-; CHECK-NEXT:    ret i64 [[PHI]]
-;
-entry:
-  br i1 %c, label %if, label %end
-
-if:
-  br label %end
-
-end:
-  %phi = phi i64 [ sdiv (i64 -9223372036854775808, i64 ptrtoint (i32* @g to i64)), %if ], [ 0, %entry ]
-  ret i64 %phi
-}
-
-define i64 @pt56038_sdiv_not_signed_min_but_maybe_div_by_zero(i1 %c) {
-; CHECK-LABEL: @pt56038_sdiv_not_signed_min_but_maybe_div_by_zero(
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    br i1 [[C:%.*]], label [[IF:%.*]], label [[END:%.*]]
-; CHECK:       if:
-; CHECK-NEXT:    br label [[END]]
-; CHECK:       end:
-; CHECK-NEXT:    [[PHI:%.*]] = phi i64 [ sdiv (i64 -9223372036854775807, i64 ptrtoint (i32* @g to i64)), [[IF]] ], [ 0, [[ENTRY:%.*]] ]
-; CHECK-NEXT:    ret i64 [[PHI]]
-;
-entry:
-  br i1 %c, label %if, label %end
-
-if:
-  br label %end
-
-end:
-  %phi = phi i64 [ sdiv (i64 -9223372036854775807, i64 ptrtoint (i32* @g to i64)), %if ], [ 0, %entry ]
-  ret i64 %phi
-}

llvm/test/Transforms/SimplifyCFG/PR16069.ll

-; NOTE: Assertions have been autogenerated by update_test_checks.py
-; RUN: opt < %s -simplifycfg -simplifycfg-require-and-preserve-domtree=1 -S | FileCheck %s
-
-@b = extern_weak global i32
-
-define i32 @foo(i1 %y) {
-; CHECK-LABEL: @foo(
-; CHECK:         [[COND_I:%.*]] = phi i32 [ srem (i32 1, i32 zext (i1 icmp eq (i32* @b, i32* null) to i32)), %bb2 ], [ 0, %0 ]
-; CHECK-NEXT:    ret i32 [[COND_I]]
-;
-  br i1 %y, label %bb1, label %bb2
-bb1:
-  br label %bb3
-bb2:
-  br label %bb3
-bb3:
-  %cond.i = phi i32 [ 0, %bb1 ], [ srem (i32 1, i32 zext (i1 icmp eq (i32* @b, i32* null) to i32)), %bb2 ]
-  ret i32 %cond.i
-}
-
-define i32 @foo2(i1 %x) {
-; CHECK-LABEL: @foo2(
-; CHECK:         [[COND:%.*]] = phi i32 [ 0, %bb1 ], [ srem (i32 1, i32 zext (i1 icmp eq (i32* @b, i32* null) to i32)), %bb0 ]
-; CHECK-NEXT:    ret i32 [[COND]]
-;
-bb0:
-  br i1 %x, label %bb1, label %bb2
-bb1:
-  br label %bb2
-bb2:
-  %cond = phi i32 [ 0, %bb1 ], [ srem (i32 1, i32 zext (i1 icmp eq (i32* @b, i32* null) to i32)), %bb0 ]
-  ret i32 %cond
-}

llvm/test/Transforms/SimplifyCFG/PR17073.ll

-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -simplifycfg -simplifycfg-require-and-preserve-domtree=1 -S | FileCheck %s
-
-; In PR17073 ( http://llvm.org/pr17073 ), we illegally hoisted an operation that can trap.
-; The first test confirms that we don't do that when the trapping op is reached by the current BB (block1).
-; The second test confirms that we don't do that when the trapping op is reached by the previous BB (entry).
-; The third test confirms that we can still do this optimization for an operation (add) that doesn't trap.
-; The tests must be complicated enough to prevent previous SimplifyCFG actions from optimizing away
-; the instructions that we're checking for.
-
-target datalayout = "e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128"
-target triple = "i386-apple-macosx10.9.0"
-
-@a = common global i32 0, align 4
-@b = common global i8 0, align 1
-
-define i32* @can_trap1() {
-; CHECK-LABEL: @can_trap1(
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* @a, align 4
-; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp eq i32 [[TMP0]], 0
-; CHECK-NEXT:    br i1 [[TOBOOL]], label [[EXIT:%.*]], label [[BLOCK1:%.*]]
-; CHECK:       block1:
-; CHECK-NEXT:    br i1 icmp eq (i32* bitcast (i8* @b to i32*), i32* @a), label [[EXIT]], label [[BLOCK2:%.*]]
-; CHECK:       block2:
-; CHECK-NEXT:    br label [[EXIT]]
-; CHECK:       exit:
-; CHECK-NEXT:    [[STOREMERGE:%.*]] = phi i32* [ null, [[ENTRY:%.*]] ], [ null, [[BLOCK2]] ], [ select (i1 icmp eq (i64 urem (i64 2, i64 zext (i1 icmp eq (i32* bitcast (i8* @b to i32*), i32* @a) to i64)), i64 0), i32* null, i32* @a), [[BLOCK1]] ]
-; CHECK-NEXT:    ret i32* [[STOREMERGE]]
-;
-entry:
-  %0 = load i32, i32* @a, align 4
-  %tobool = icmp eq i32 %0, 0
-  br i1 %tobool, label %exit, label %block1
-
-block1:
-  br i1 icmp eq (i32* bitcast (i8* @b to i32*), i32* @a), label %exit, label %block2
-
-block2:
-  br label %exit
-
-exit:
-  %storemerge = phi i32* [ null, %entry ],[ null, %block2 ], [ select (i1 icmp eq (i64 urem (i64 2, i64 zext (i1 icmp eq (i32* bitcast (i8* @b to i32*), i32* @a) to i64)), i64 0), i32* null, i32* @a), %block1 ]
-  ret i32* %storemerge
-}
-
-define i32* @can_trap2() {
-; CHECK-LABEL: @can_trap2(
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* @a, align 4
-; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp eq i32 [[TMP0]], 0
-; CHECK-NEXT:    br i1 [[TOBOOL]], label [[EXIT:%.*]], label [[BLOCK1:%.*]]
-; CHECK:       block1:
-; CHECK-NEXT:    br label [[EXIT]]
-; CHECK:       exit:
-; CHECK-NEXT:    [[STOREMERGE:%.*]] = phi i32* [ select (i1 icmp eq (i64 urem (i64 2, i64 zext (i1 icmp eq (i32* bitcast (i8* @b to i32*), i32* @a) to i64)), i64 0), i32* null, i32* @a), [[ENTRY:%.*]] ], [ null, [[BLOCK1]] ]
-; CHECK-NEXT:    ret i32* [[STOREMERGE]]
-;
-entry:
-  %0 = load i32, i32* @a, align 4
-  %tobool = icmp eq i32 %0, 0
-  br i1 %tobool, label %exit, label %block1
-
-block1:
-  br i1 icmp eq (i32* bitcast (i8* @b to i32*), i32* @a), label %exit, label %block2
-
-block2:
-  br label %exit
-
-exit:
-  %storemerge = phi i32* [ select (i1 icmp eq (i64 urem (i64 2, i64 zext (i1 icmp eq (i32* bitcast (i8* @b to i32*), i32* @a) to i64)), i64 0), i32* null, i32* @a), %entry ],[ null, %block2 ], [ null, %block1 ]
-  ret i32* %storemerge
-}
-
-define i32* @cannot_trap() {
-; CHECK-LABEL: @cannot_trap(
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* @a, align 4
-; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp eq i32 [[TMP0]], 0
-; CHECK-NEXT:    [[SPEC_SELECT:%.*]] = select i1 icmp eq (i32* bitcast (i8* @b to i32*), i32* @a), i32* select (i1 icmp eq (i64 add (i64 zext (i1 icmp eq (i32* bitcast (i8* @b to i32*), i32* @a) to i64), i64 2), i64 0), i32* null, i32* @a), i32* null
-; CHECK-NEXT:    [[STOREMERGE:%.*]] = select i1 [[TOBOOL]], i32* null, i32* [[SPEC_SELECT]]
-; CHECK-NEXT:    ret i32* [[STOREMERGE]]
-;
-entry:
-  %0 = load i32, i32* @a, align 4
-  %tobool = icmp eq i32 %0, 0
-  br i1 %tobool, label %exit, label %block1
-
-block1:
-  br i1 icmp eq (i32* bitcast (i8* @b to i32*), i32* @a), label %exit, label %block2
-
-block2:
-  br label %exit
-
-exit:
-  %storemerge = phi i32* [ null, %entry ],[ null, %block2 ], [ select (i1 icmp eq (i64 add (i64 2, i64 zext (i1 icmp eq (i32* bitcast (i8* @b to i32*), i32* @a) to i64)), i64 0), i32* null, i32* @a), %block1 ]
-  ret i32* %storemerge
-}

llvm/unittests/Analysis/ValueTrackingTest.cpp

TEST_F(ComputeKnownBitsTest, ComputeKnownBitsGEPWithRangeNoOverlap) {
   EXPECT_EQ(Known.Zero.getZExtValue(), ~512llu & ~(64llu - 1));
   EXPECT_EQ(Known.One.getZExtValue(), 512u | 32u);
   // The known range is not precise given computeKnownBits works
   // with the masks of zeros and ones, not the ranges.
   EXPECT_EQ(Known.getMinValue(), 544);
   EXPECT_EQ(Known.getMaxValue(), 575);
 }
 
-TEST_F(ComputeKnownBitsTest, ComputeKnownBitsCrash) {
-  parseAssembly(
-      "@g.a = external global i16, align 1\n"
-      "define i16 @test(i16 %i) {\n"
-      "entry:\n"
-      "  %0 = icmp slt i16 sub (i16 0, i16 trunc (i32 udiv (i32 ptrtoint (i16* @g.a to i32), i32 -1) to i16)), 0\n"
-      "  %A = select i1 %0, i16 trunc (i32 udiv (i32 ptrtoint (i16* @g.a to i32), i32 -1) to i16), i16 sub (i16 0, i16 trunc (i32 udiv (i32 ptrtoint (i16* @g.a to i32), i32 -1) to i16))\n"
-      "  ret i16 %A\n"
-      "}\n");
-  AssumptionCache AC(*F);
-  KnownBits Known = computeKnownBits(
-      A, M->getDataLayout(), /* Depth */ 0, &AC, F->front().getTerminator());
-}
-
 TEST_F(ValueTrackingTest, HaveNoCommonBitsSet) {
   {
     // Check for an inverted mask: (X & ~M) op (Y & M).
     auto M = parseModule(R"(
   define i32 @test(i32 %X, i32 %Y, i32 %M) {
     %1 = xor i32 %M, -1
     %LHS = and i32 %1, %X
     %RHS = and i32 %Y, %M

llvm/unittests/IR/ConstantsTest.cpp

 //===- llvm/unittest/IR/ConstantsTest.cpp - Constants unit tests ----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/Constants.h"
 #include "llvm-c/Core.h"
 #include "llvm/AsmParser/Parser.h"
+#include "llvm/IR/ConstantFold.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/SourceMgr.h"
 #include "gtest/gtest.h"
 
TEST(ConstantsTest, Integer_i1) {
   EXPECT_EQ(Poison, ConstantExpr::getAShr(One, One));
 
   // @n = constant i1 mul(i1 -1, i1 1)
   // @n = constant i1 true
   EXPECT_EQ(One, ConstantExpr::getMul(NegOne, One));
 
   // @o = constant i1 sdiv(i1 -1, i1 1) ; overflow
   // @o = constant i1 true
-  EXPECT_EQ(One, ConstantExpr::getSDiv(NegOne, One));
+  EXPECT_EQ(One, ConstantFoldBinaryInstruction(Instruction::SDiv, NegOne, One));
 
   // @p = constant i1 sdiv(i1 1 , i1 -1); overflow
   // @p = constant i1 true
-  EXPECT_EQ(One, ConstantExpr::getSDiv(One, NegOne));
+  EXPECT_EQ(One, ConstantFoldBinaryInstruction(Instruction::SDiv, One, NegOne));
 
   // @q = constant i1 udiv(i1 -1, i1 1)
   // @q = constant i1 true
-  EXPECT_EQ(One, ConstantExpr::getUDiv(NegOne, One));
+  EXPECT_EQ(One, ConstantFoldBinaryInstruction(Instruction::UDiv, NegOne, One));
 
   // @r = constant i1 udiv(i1 1, i1 -1)
   // @r = constant i1 true
-  EXPECT_EQ(One, ConstantExpr::getUDiv(One, NegOne));
+  EXPECT_EQ(One, ConstantFoldBinaryInstruction(Instruction::UDiv, One, NegOne));
 
   // @s = constant i1 srem(i1 -1, i1 1) ; overflow
   // @s = constant i1 false
-  EXPECT_EQ(Zero, ConstantExpr::getSRem(NegOne, One));
-
-  // @t = constant i1 urem(i1 -1, i1 1)
-  // @t = constant i1 false
-  EXPECT_EQ(Zero, ConstantExpr::getURem(NegOne, One));
+  EXPECT_EQ(Zero,
+            ConstantFoldBinaryInstruction(Instruction::SRem, NegOne, One));
 
   // @u = constant i1 srem(i1  1, i1 -1) ; overflow
   // @u = constant i1 false
-  EXPECT_EQ(Zero, ConstantExpr::getSRem(One, NegOne));
+  EXPECT_EQ(Zero,
+            ConstantFoldBinaryInstruction(Instruction::SRem, One, NegOne));
 }
 
 TEST(ConstantsTest, IntSigns) {
   LLVMContext Context;
   IntegerType *Int8Ty = Type::getInt8Ty(Context);
   EXPECT_EQ(100, ConstantInt::get(Int8Ty, 100, false)->getSExtValue());
   EXPECT_EQ(100, ConstantInt::get(Int8Ty, 100, true)->getSExtValue());
   EXPECT_EQ(100, ConstantInt::getSigned(Int8Ty, 100)->getSExtValue());
CHECK(ConstantExpr::getAdd(P0, P0, false, true),
         "add nsw i32 " P0STR ", " P0STR);
   CHECK(ConstantExpr::getAdd(P0, P0, true, true),
         "add nuw nsw i32 " P0STR ", " P0STR);
   CHECK(ConstantExpr::getFAdd(P1, P1), "fadd float " P1STR ", " P1STR);
   CHECK(ConstantExpr::getSub(P0, P0), "sub i32 " P0STR ", " P0STR);
   CHECK(ConstantExpr::getFSub(P1, P1), "fsub float " P1STR ", " P1STR);
   CHECK(ConstantExpr::getMul(P0, P0), "mul i32 " P0STR ", " P0STR);
   CHECK(ConstantExpr::getFMul(P1, P1), "fmul float " P1STR ", " P1STR);
-  CHECK(ConstantExpr::getUDiv(P0, P0), "udiv i32 " P0STR ", " P0STR);
-  CHECK(ConstantExpr::getSDiv(P0, P0), "sdiv i32 " P0STR ", " P0STR);
   CHECK(ConstantExpr::getFDiv(P1, P1), "fdiv float " P1STR ", " P1STR);
-  CHECK(ConstantExpr::getURem(P0, P0), "urem i32 " P0STR ", " P0STR);
-  CHECK(ConstantExpr::getSRem(P0, P0), "srem i32 " P0STR ", " P0STR);
   CHECK(ConstantExpr::getFRem(P1, P1), "frem float " P1STR ", " P1STR);
   CHECK(ConstantExpr::getAnd(P0, P0), "and i32 " P0STR ", " P0STR);
   CHECK(ConstantExpr::getOr(P0, P0), "or i32 " P0STR ", " P0STR);
   CHECK(ConstantExpr::getXor(P0, P0), "xor i32 " P0STR ", " P0STR);
   CHECK(ConstantExpr::getShl(P0, P0), "shl i32 " P0STR ", " P0STR);
   CHECK(ConstantExpr::getShl(P0, P0, true), "shl nuw i32 " P0STR ", " P0STR);
   CHECK(ConstantExpr::getShl(P0, P0, false, true),
         "shl nsw i32 " P0STR ", " P0STR);
   CHECK(ConstantExpr::getLShr(P0, P0, false), "lshr i32 " P0STR ", " P0STR);
   CHECK(ConstantExpr::getLShr(P0, P0, true),
         "lshr exact i32 " P0STR ", " P0STR);
   CHECK(ConstantExpr::getAShr(P0, P0, false), "ashr i32 " P0STR ", " P0STR);
   CHECK(ConstantExpr::getAShr(P0, P0, true),
         "ashr exact i32 " P0STR ", " P0STR);
 
   CHECK(ConstantExpr::getSExt(P0, Int64Ty), "sext i32 " P0STR " to i64");
   CHECK(ConstantExpr::getZExt(P0, Int64Ty), "zext i32 " P0STR " to i64");
   CHECK(ConstantExpr::getFPTrunc(P2, FloatTy),
         "fptrunc double " P2STR " to float");
   CHECK(ConstantExpr::getFPExtend(P1, DoubleTy),
         "fpext float " P1STR " to double");
 
-  CHECK(ConstantExpr::getExactUDiv(P0, P0), "udiv exact i32 " P0STR ", " P0STR);
-
   CHECK(ConstantExpr::getSelect(P3, P0, P4),
         "select i1 " P3STR ", i32 " P0STR ", i32 " P4STR);
   CHECK(ConstantExpr::getICmp(CmpInst::ICMP_EQ, P0, P4),
         "icmp eq i32 " P0STR ", " P4STR);
   CHECK(ConstantExpr::getFCmp(CmpInst::FCMP_ULT, P1, P5),
         "fcmp ult float " P1STR ", " P5STR);
 
   std::vector<Constant *> V;