LLVM IR constant expressions never trap.

[efriedma]

Summary

Currently, constants have a property "Constant::canTrap", which is whether they contain a division that might have undefined behavior. If an instruction has a canTrap constant expression as an operand, and that constant expression contains a division with undefined behavior, the instruction has undefined behavior. For PHI nodes, the behavior is only undefined along the corresponding edges. This isn't documented anywhere in LangRef, but we use it to avoid certain transforms in a few optimization passes. For example, isSafeToSpeculativelyExecute checks whether instructions have a canTrap operand.

In practice, canTrap is almost never true: the only way create such an expression is to do something strange with the address of a global, so the denominator of a division is a complex constant expression. This means we have a lot of complexity with very little test coverage. So it would be nice if we could simplify the rules here.

This patch proposes to give up on the whole "canTrap" thing, and redefine the meaning of division in constant expressions. With this patch, if a constant expression divides by zero, or contains an overflowing divide, the result is poison. This simplifies a bunch of code. It also fixes an infinite loop bug involving a canTrap constant, a PHI, and an unsplittable critical edge. The downside is a slight performance hit: if we do end up with a divide constant expression with a complex denominator, we generate extra code to avoid the trap.

There are a few ways to reduce the performance hit that I haven't tried to implement. On architectures where division never traps, we could avoid generating extra code. We could also try to avoid constant-folding divide instructions that would result in a complex constant expression.

[hfinkel]

Overall, I think that this makes sense. Thanks for proposing this.

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

3224

Please add a comment here explaining that you're guarding against both x/0 and INT_MIN/-1.

test/CodeGen/X86/divide-constant.ll

301

Can you check known bits? I feel like we should somehow know that ptrtoint(@g) isn't zero.

For a test case, we can always do ptrtoint(@g1)/(ptrtoint(@g2)-123456) or similar.

[jdoerfert]

docs/LangRef.rst

3441

I'm not really happy with this formulation.
It basically says that we somewhere define things to be UB and here we say that it is not UB if it is a constant.

lib/Analysis/ValueTracking.cpp

489

V == I implies isa<Instruction>(V) and you can use isSafeToSpeculativelyExecute(I)

[aemerson]

Looks much better, the GISel changes are fine.

[efriedma]

lib/Analysis/ValueTracking.cpp

489

I think you're reading this backwards; isSafeToSpeculativelyExecute only executes if V != I

test/CodeGen/X86/divide-constant.ll

301

I don't think there's any way to prove the value is non-zero here; it's extern_weak.

[hfinkel]

test/CodeGen/X86/divide-constant.ll

301

Indeed. I missed that. I did mean the comment more generally - it seems like we should know that non-weak globals aren't zero. That having been said, looking at the implementation of SelectionDAG::isKnownNeverZero and SelectionDAG::computeKnownBits, etc. they don't seem to know anything about globals, so I suppose that enhancement there would also be needed in order to have an impact on this lowering.

[jdoerfert]

lib/Analysis/ValueTracking.cpp

489

I was, :(

[efriedma]

Address review comments, minor code cleanup, fix ConstantExpr::getAsInstruction, fix regression tests.

[jdoerfert]

Is this still an RFC or by now an accumulation of changes we actually want to make? I added to comments assuming the latter.

lib/IR/Constants.cpp

2966

This can be reasonably separated or you could probably work with the ValueOperands or Ops array. At least I don't (immediately) see that we need to keep this connected to the RFC patch.

test/Transforms/LoopVectorize/X86/masked_load_store.ll

1505 ↗

(On Diff #203924)

I'm unsure about the sentence that talks about history. I think I'd prefer a statement about the semantic we have, thus, "constant expressions never trap, check ...". But I don't feel strongly about this.

[efriedma]

Addressed review comments. Added release note. I think this patch contains all the changes necessary to reflect the change to IR semantics.

I'll send a brief email to llvmdev now, so everyone's aware this is changing.

[lattner]

I commented on the llvmdev thread, but instead of moving this complexity around, I'd really rather see it go away. We should never have supported div/rem constant expressions in the first place...

-Chris

docs/LangRef.rst

``insertvalue (VAL, ELT, IDX0, IDX1, ...)``
     The index list is interpreted in a similar manner as indices in a
     ':ref:`getelementptr <i_getelementptr>`' operation. At least one index
     value must be specified.
 ``OPCODE (LHS, RHS)``
     Perform the specified operation of the LHS and RHS constants. OPCODE
     may be any of the :ref:`binary <binaryops>` or :ref:`bitwise
     binary <bitwiseops>` operations. The constraints on operands are
     the same as those for the corresponding instruction (e.g. no bitwise
-    operations on floating-point values are allowed).
+    operations on floating-point values are allowed). Constant expressions
+    never have undefined behavior; division operations that would have
+    undefined behavior instead produce poison.
 
 Other Values
 ============
 
 .. _inlineasmexprs:
 
 Inline Assembler Expressions
 ----------------------------

include/llvm/Analysis/ValueTracking.h

class Value;
   ///
   /// If the CtxI is NOT specified this method only looks at the instruction
   /// itself and its operands, so if this method returns true, it is safe to
   /// move the instruction as long as the correct dominance relationships for
   /// the operands and users hold.
   ///
   /// This method can return true for instructions that read memory;
   /// for such instructions, moving them may change the resulting value.
-  bool isSafeToSpeculativelyExecute(const Value *V,
+  bool isSafeToSpeculativelyExecute(const Instruction *I,
                                     const Instruction *CtxI = nullptr,
                                     const DominatorTree *DT = nullptr);
 
   /// Returns true if the result or effects of the given instructions \p I
   /// depend on or influence global memory.
   /// Memory dependence arises for example if the instruction reads from
   /// memory or may produce effects or undefined behaviour. Memory dependent
   /// instructions generally cannot be reorderd with respect to other memory

include/llvm/CodeGen/GlobalISel/IRTranslator.h

private:
   bool translateOr(const User &U, MachineIRBuilder &MIRBuilder) {
     return translateBinaryOp(TargetOpcode::G_OR, U, MIRBuilder);
   }
   bool translateXor(const User &U, MachineIRBuilder &MIRBuilder) {
     return translateBinaryOp(TargetOpcode::G_XOR, U, MIRBuilder);
   }
 
   bool translateUDiv(const User &U, MachineIRBuilder &MIRBuilder) {
+    // Non-trapping div for ConstantExpr not yet implemented.
+    if (isa<ConstantExpr>(U))
+      return false;
     return translateBinaryOp(TargetOpcode::G_UDIV, U, MIRBuilder);
   }
   bool translateSDiv(const User &U, MachineIRBuilder &MIRBuilder) {
+    // Non-trapping div for ConstantExpr not yet implemented.
+    if (isa<ConstantExpr>(U))
+      return false;
     return translateBinaryOp(TargetOpcode::G_SDIV, U, MIRBuilder);
   }
   bool translateURem(const User &U, MachineIRBuilder &MIRBuilder) {
+    // Non-trapping div for ConstantExpr not yet implemented.
+    if (isa<ConstantExpr>(U))
+      return false;
     return translateBinaryOp(TargetOpcode::G_UREM, U, MIRBuilder);
   }
   bool translateSRem(const User &U, MachineIRBuilder &MIRBuilder) {
+    // Non-trapping div for ConstantExpr not yet implemented.
+    if (isa<ConstantExpr>(U))
+      return false;
     return translateBinaryOp(TargetOpcode::G_SREM, U, MIRBuilder);
   }
   bool translateIntToPtr(const User &U, MachineIRBuilder &MIRBuilder) {
     return translateCast(TargetOpcode::G_INTTOPTR, U, MIRBuilder);
   }
   bool translatePtrToInt(const User &U, MachineIRBuilder &MIRBuilder) {
     return translateCast(TargetOpcode::G_PTRTOINT, U, MIRBuilder);
   }

include/llvm/IR/Constant.h

public:
   /// Return true if this is a vector constant that includes any undefined
   /// elements.
   bool containsUndefElement() const;
 
   /// Return true if this is a vector constant that includes any constant
   /// expressions.
   bool containsConstantExpression() const;
 
-  /// Return true if evaluation of this constant could trap. This is true for
-  /// things like constant expressions that could divide by zero.
-  bool canTrap() const;
-
   /// Return true if the value can vary between threads.
   bool isThreadDependent() const;
 
   /// Return true if the value is dependent on a dllimport variable.
   bool isDLLImportDependent() const;
 
   /// Return true if the constant has users other than constant expressions and
   /// other dangling things.

lib/Analysis/CodeMetrics.cpp

appendSpeculatableOperands(const Value *V,
                            SmallPtrSetImpl<const Value *> &Visited,
                            SmallVectorImpl<const Value *> &Worklist) {
   const User *U = dyn_cast<User>(V);
   if (!U)
     return;
 
   for (const Value *Operand : U->operands())
     if (Visited.insert(Operand).second)
-      if (isSafeToSpeculativelyExecute(Operand))
+      if (!isa<Instruction>(Operand) ||
+          isSafeToSpeculativelyExecute(cast<Instruction>(Operand)))
         Worklist.push_back(Operand);
 }
 
 static void completeEphemeralValues(SmallPtrSetImpl<const Value *> &Visited,
                                     SmallVectorImpl<const Value *> &Worklist,
                                     SmallPtrSetImpl<const Value *> &EphValues) {
   // Note: We don't speculate PHIs here, so we'll miss instruction chains kept
   // alive only by ephemeral values.

lib/Analysis/ValueTracking.cpp

while (!WorkSet.empty()) {
 
     // If all uses of this value are ephemeral, then so is this value.
     if (llvm::all_of(V->users(), [&](const User *U) {
                                    return EphValues.count(U);
                                  })) {
       if (V == E)
         return true;
 
-      if (V == I || isSafeToSpeculativelyExecute(V)) {
+      if (V == I || !isa<Instruction>(V) ||
+          isSafeToSpeculativelyExecute(cast<Instruction>(V))) {
        EphValues.insert(V);
        if (const User *U = dyn_cast<User>(V))
          for (User::const_op_iterator J = U->op_begin(), JE = U->op_end();
               J != JE; ++J)
            WorkSet.push_back(*J);
       }
     }
   }
for (const User *U : V->users()) {
     if (!II) return false;
 
     if (!II->isLifetimeStartOrEnd())
       return false;
   }
   return true;
 }
 
-bool llvm::isSafeToSpeculativelyExecute(const Value *V,
+bool llvm::isSafeToSpeculativelyExecute(const Instruction *Inst,
                                         const Instruction *CtxI,
                                         const DominatorTree *DT) {
-  const Operator *Inst = dyn_cast<Operator>(V);
-  if (!Inst)
-    return false;
-
-  for (unsigned i = 0, e = Inst->getNumOperands(); i != e; ++i)
-    if (Constant *C = dyn_cast<Constant>(Inst->getOperand(i)))
-      if (C->canTrap())
-        return false;
-
   switch (Inst->getOpcode()) {
   default:
     return true;
   case Instruction::UDiv:
   case Instruction::URem: {
     // x / y is undefined if y == 0.
     const APInt *V;
     if (match(Inst->getOperand(1), m_APInt(V)))

lib/CodeGen/SelectionDAG/FastISel.cpp

if (match(I, m_FNeg(m_Value(X))))
        return selectFNeg(I, X);
     return selectBinaryOp(I, ISD::FSUB);
   }
   case Instruction::Mul:
     return selectBinaryOp(I, ISD::MUL);
   case Instruction::FMul:
     return selectBinaryOp(I, ISD::FMUL);
   case Instruction::SDiv:
+    // Non-trapping div for ConstantExpr not yet implemented.
+    if (isa<ConstantExpr>(I))
+      return false;
     return selectBinaryOp(I, ISD::SDIV);
   case Instruction::UDiv:
+    // Non-trapping div for ConstantExpr not yet implemented.
+    if (isa<ConstantExpr>(I))
+      return false;
     return selectBinaryOp(I, ISD::UDIV);
   case Instruction::FDiv:
     return selectBinaryOp(I, ISD::FDIV);
   case Instruction::SRem:
+    // Non-trapping div for ConstantExpr not yet implemented.
+    if (isa<ConstantExpr>(I))
+      return false;
     return selectBinaryOp(I, ISD::SREM);
   case Instruction::URem:
+    // Non-trapping div for ConstantExpr not yet implemented.
+    if (isa<ConstantExpr>(I))
+      return false;
     return selectBinaryOp(I, ISD::UREM);
   case Instruction::FRem:
     return selectBinaryOp(I, ISD::FREM);
   case Instruction::Shl:
     return selectBinaryOp(I, ISD::SHL);
   case Instruction::LShr:
     return selectBinaryOp(I, ISD::SRL);
   case Instruction::AShr:

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h

private:
   void visitCallBr(const CallBrInst &I);
   void visitResume(const ResumeInst &I);
 
   void visitUnary(const User &I, unsigned Opcode);
   void visitFNeg(const User &I) { visitUnary(I, ISD::FNEG); }
 
   void visitBinary(const User &I, unsigned Opcode);
   void visitShift(const User &I, unsigned Opcode);
+  void visitDivRem(const User &I, unsigned Opcode);
   void visitAdd(const User &I)  { visitBinary(I, ISD::ADD); }
   void visitFAdd(const User &I) { visitBinary(I, ISD::FADD); }
   void visitSub(const User &I)  { visitBinary(I, ISD::SUB); }
   void visitFSub(const User &I);
   void visitMul(const User &I)  { visitBinary(I, ISD::MUL); }
   void visitFMul(const User &I) { visitBinary(I, ISD::FMUL); }
-  void visitURem(const User &I) { visitBinary(I, ISD::UREM); }
-  void visitSRem(const User &I) { visitBinary(I, ISD::SREM); }
+  void visitURem(const User &I) { visitDivRem(I, ISD::UREM); }
+  void visitSRem(const User &I) { visitDivRem(I, ISD::SREM); }
   void visitFRem(const User &I) { visitBinary(I, ISD::FREM); }
-  void visitUDiv(const User &I) { visitBinary(I, ISD::UDIV); }
-  void visitSDiv(const User &I);
+  void visitUDiv(const User &I) { visitDivRem(I, ISD::UDIV); }
+  void visitSDiv(const User &I) { visitDivRem(I, ISD::SDIV); }
   void visitFDiv(const User &I) { visitBinary(I, ISD::FDIV); }
   void visitAnd (const User &I) { visitBinary(I, ISD::AND); }
   void visitOr  (const User &I) { visitBinary(I, ISD::OR); }
   void visitXor (const User &I) { visitBinary(I, ISD::XOR); }
   void visitShl (const User &I) { visitShift(I, ISD::SHL); }
   void visitLShr(const User &I) { visitShift(I, ISD::SRL); }
   void visitAShr(const User &I) { visitShift(I, ISD::SRA); }
   void visitICmp(const User &I);

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

void SelectionDAGBuilder::visitShift(const User &I, unsigned Opcode) {
   Flags.setExact(exact);
   Flags.setNoSignedWrap(nsw);
   Flags.setNoUnsignedWrap(nuw);
   SDValue Res = DAG.getNode(Opcode, getCurSDLoc(), Op1.getValueType(), Op1, Op2,
                             Flags);
   setValue(&I, Res);
 }
 
-void SelectionDAGBuilder::visitSDiv(const User &I) {
+void SelectionDAGBuilder::visitDivRem(const User &I, unsigned Opcode) {
+  if (!isa<Constant>(I))
+    return visitBinary(I, Opcode);
+
+  // Constants aren't allowed to trap, so we have to do something
+  // a bit trickier.
+  //
+  // FIXME: Some targets have a cheap non-trapping div.
   SDValue Op1 = getValue(I.getOperand(0));
   SDValue Op2 = getValue(I.getOperand(1));
-
-  SDNodeFlags Flags;
-  Flags.setExact(isa<PossiblyExactOperator>(&I) &&
-                 cast<PossiblyExactOperator>(&I)->isExact());
-  setValue(&I, DAG.getNode(ISD::SDIV, getCurSDLoc(), Op1.getValueType(), Op1,
-                           Op2, Flags));
+  SDLoc dl(getCurSDLoc());
+  EVT VT = Op1.getValueType();
+  if (Opcode == ISD::UDIV || Opcode == ISD::UREM) {
+    Op2 = DAG.getNode(ISD::UMAX, dl, VT, Op2, DAG.getConstant(1, dl, VT));
+  } else {
+    auto &TLI = DAG.getTargetLoweringInfo();
+    EVT CCVT =
+        TLI.getSetCCResultType(DAG.getDataLayout(), *DAG.getContext(), VT);
+    SDValue IsZero =
+        DAG.getSetCC(dl, CCVT, Op2, DAG.getConstant(0, dl, VT), ISD::SETEQ);
+    SDValue IsNegOne =
+        DAG.getSetCC(dl, CCVT, Op2, DAG.getAllOnesConstant(dl, VT), ISD::SETEQ);
+    auto IntMin = APInt::getSignedMinValue(VT.getScalarSizeInBits());
+    SDValue IsIntMin = DAG.getSetCC(
+        dl, CCVT, Op1, DAG.getConstant(IntMin, dl, VT), ISD::SETEQ);
+    SDValue IsIntMinOverNegOne =
+        DAG.getNode(ISD::AND, dl, CCVT, IsNegOne, IsIntMin);
+    SDValue IsInvalid =
+        DAG.getNode(ISD::OR, dl, CCVT, IsZero, IsIntMinOverNegOne);
+    ISD::NodeType SelectOpCode = VT.isVector() ? ISD::VSELECT : ISD::SELECT;
+    Op2 = DAG.getNode(SelectOpCode, dl, VT, IsInvalid,
+                      DAG.getConstant(1, dl, VT), Op2);
+  }
+
+  SDNodeFlags DivFlags;
+  if (auto *ExactOp = dyn_cast<PossiblyExactOperator>(&I))
+    DivFlags.setExact(ExactOp->isExact());
+  SDValue BinNodeValue = DAG.getNode(Opcode, dl, VT, Op1, Op2, DivFlags);
+  setValue(&I, BinNodeValue);
 }
 
 void SelectionDAGBuilder::visitICmp(const User &I) {
   ICmpInst::Predicate predicate = ICmpInst::BAD_ICMP_PREDICATE;
   if (const ICmpInst *IC = dyn_cast<ICmpInst>(&I))
     predicate = IC->getPredicate();
   else if (const ConstantExpr *IC = dyn_cast<ConstantExpr>(&I))
     predicate = ICmpInst::Predicate(IC->getPredicate());

lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp

void SelectionDAGISel::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.addPreserved<GCModuleInfo>();
   AU.addRequired<TargetLibraryInfoWrapperPass>();
   AU.addRequired<TargetTransformInfoWrapperPass>();
   if (UseMBPI && OptLevel != CodeGenOpt::None)
     AU.addRequired<BranchProbabilityInfoWrapperPass>();
   MachineFunctionPass::getAnalysisUsage(AU);
 }
 
-/// SplitCriticalSideEffectEdges - Look for critical edges with a PHI value that
-/// may trap on it.  In this case we have to split the edge so that the path
-/// through the predecessor block that doesn't go to the phi block doesn't
-/// execute the possibly trapping instruction. If available, we pass domtree
-/// and loop info to be updated when we split critical edges. This is because
-/// SelectionDAGISel preserves these analyses.
-/// This is required for correctness, so it must be done at -O0.
-///
-static void SplitCriticalSideEffectEdges(Function &Fn, DominatorTree *DT,
-                                         LoopInfo *LI) {
-  // Loop for blocks with phi nodes.
-  for (BasicBlock &BB : Fn) {
-    PHINode *PN = dyn_cast<PHINode>(BB.begin());
-    if (!PN) continue;
-
-  ReprocessBlock:
-    // For each block with a PHI node, check to see if any of the input values
-    // are potentially trapping constant expressions.  Constant expressions are
-    // the only potentially trapping value that can occur as the argument to a
-    // PHI.
-    for (BasicBlock::iterator I = BB.begin(); (PN = dyn_cast<PHINode>(I)); ++I)
-      for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
-        ConstantExpr *CE = dyn_cast<ConstantExpr>(PN->getIncomingValue(i));
-        if (!CE || !CE->canTrap()) continue;
-
-        // The only case we have to worry about is when the edge is critical.
-        // Since this block has a PHI Node, we assume it has multiple input
-        // edges: check to see if the pred has multiple successors.
-        BasicBlock *Pred = PN->getIncomingBlock(i);
-        if (Pred->getTerminator()->getNumSuccessors() == 1)
-          continue;
-
-        // Okay, we have to split this edge.
-        SplitCriticalEdge(
-            Pred->getTerminator(), GetSuccessorNumber(Pred, &BB),
-            CriticalEdgeSplittingOptions(DT, LI).setMergeIdenticalEdges());
-        goto ReprocessBlock;
-      }
-  }
-}
-
 static void computeUsesMSVCFloatingPoint(const Triple &TT, const Function &F,
                                          MachineModuleInfo &MMI) {
   // Only needed for MSVC
   if (!TT.isKnownWindowsMSVCEnvironment())
     return;
 
   // If it's already set, nothing to do.
   if (MMI.usesMSVCFloatingPoint())
bool SelectionDAGISel::runOnMachineFunction(MachineFunction &mf) {
   ORE = make_unique<OptimizationRemarkEmitter>(&Fn);
   auto *DTWP = getAnalysisIfAvailable<DominatorTreeWrapperPass>();
   DominatorTree *DT = DTWP ? &DTWP->getDomTree() : nullptr;
   auto *LIWP = getAnalysisIfAvailable<LoopInfoWrapperPass>();
   LoopInfo *LI = LIWP ? &LIWP->getLoopInfo() : nullptr;
 
   LLVM_DEBUG(dbgs() << "\n\n\n=== " << Fn.getName() << "\n");
 
-  SplitCriticalSideEffectEdges(const_cast<Function &>(Fn), DT, LI);
-
   CurDAG->init(*MF, *ORE, this, LibInfo,
    getAnalysisIfAvailable<LegacyDivergenceAnalysis>());
   FuncInfo->set(Fn, *MF, CurDAG);
   SwiftError->setFunction(*MF);
 
   // Now get the optional analyzes if we want to.
   // This is based on the possibly changed OptLevel (after optnone is taken
   // into account).  That's unfortunate but OK because it just means we won't

lib/IR/Constants.cpp

#endif
     // The constant should remove itself from our use list...
     assert((use_empty() || user_back() != V) && "Constant not removed!");
   }
 
   // Value has no outstanding references it is safe to delete it now...
   delete this;
 }
 
-static bool canTrapImpl(const Constant *C,
-                        SmallPtrSetImpl<const ConstantExpr *> &NonTrappingOps) {
-  assert(C->getType()->isFirstClassType() && "Cannot evaluate aggregate vals!");
-  // The only thing that could possibly trap are constant exprs.
-  const ConstantExpr *CE = dyn_cast<ConstantExpr>(C);
-  if (!CE)
-    return false;
-
-  // ConstantExpr traps if any operands can trap.
-  for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i) {
-    if (ConstantExpr *Op = dyn_cast<ConstantExpr>(CE->getOperand(i))) {
-      if (NonTrappingOps.insert(Op).second && canTrapImpl(Op, NonTrappingOps))
-        return true;
-    }
-  }
-
-  // Otherwise, only specific operations can trap.
-  switch (CE->getOpcode()) {
-  default:
-    return false;
-  case Instruction::UDiv:
-  case Instruction::SDiv:
-  case Instruction::URem:
-  case Instruction::SRem:
-    // Div and rem can trap if the RHS is not known to be non-zero.
-    if (!isa<ConstantInt>(CE->getOperand(1)) ||CE->getOperand(1)->isNullValue())
-      return true;
-    return false;
-  }
-}
-
-bool Constant::canTrap() const {
-  SmallPtrSet<const ConstantExpr *, 4> NonTrappingOps;
-  return canTrapImpl(this, NonTrappingOps);
-}
-
 /// 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;
   WorkList.push_back(C);
   Visited.insert(C);
Value *ConstantExpr::handleOperandChangeImpl(Value *From, Value *ToV) {
   // Update to the new value.
   return getContext().pImpl->ExprConstants.replaceOperandsInPlace(
       NewOps, this, From, To, NumUpdated, OperandNo);
 }
 
 Instruction *ConstantExpr::getAsInstruction() {
   SmallVector<Value *, 4> ValueOperands(op_begin(), op_end());
   ArrayRef<Value*> Ops(ValueOperands);
 
   switch (getOpcode()) {
   case Instruction::Trunc:
   case Instruction::ZExt:
   case Instruction::SExt:
   case Instruction::FPTrunc:
   case Instruction::FPExt:
   case Instruction::UIToFP:
   case Instruction::SIToFP:

lib/Transforms/Utils/SimplifyCFG.cpp

 }
 
 /// Compute an abstract "cost" of speculating the given instruction,
 /// which is assumed to be safe to speculate. TCC_Free means cheap,
 /// TCC_Basic means less cheap, and TCC_Expensive means prohibitively
 /// expensive.
 static unsigned ComputeSpeculationCost(const User *I,
                                        const TargetTransformInfo &TTI) {
-  assert(isSafeToSpeculativelyExecute(I) &&
+  assert(!isa<Instruction>(I) ||
+         isSafeToSpeculativelyExecute(cast<Instruction>(I)) &&
          "Instruction is not safe to speculatively execute!");
   return TTI.getUserCost(I);
 }
 
 /// If we have a merge point of an "if condition" as accepted above,
 /// return true if the specified value dominates the block.  We
 /// don't handle the true generality of domination here, just a special case
 /// which works well enough for us.
static bool DominatesMergePoint(Value *V, BasicBlock *BB,
   // It is possible to hit a zero-cost cycle (phi/gep instructions for example),
   // so limit the recursion depth.
   // TODO: While this recursion limit does prevent pathological behavior, it
   // would be better to track visited instructions to avoid cycles.
   if (Depth == MaxSpeculationDepth)
     return false;
 
   Instruction *I = dyn_cast<Instruction>(V);
-  if (!I) {
-    // Non-instructions all dominate instructions, but not all constantexprs
-    // can be executed unconditionally.
-    if (ConstantExpr *C = dyn_cast<ConstantExpr>(V))
-      if (C->canTrap())
-        return false;
+  if (!I)
     return true;
-  }
   BasicBlock *PBB = I->getParent();
 
   // We don't want to allow weird loops that might have the "if condition" in
   // the bottom of this block.
   if (PBB == BB)
     return false;
 
   // If this instruction is defined in a block that contains an unconditional
for (PHINode &PN : Succ->phis()) {
       if (BB1V == BB2V)
         continue;
 
       // Check for passingValueIsAlwaysUndefined here because we would rather
       // eliminate undefined control flow then converting it to a select.
       if (passingValueIsAlwaysUndefined(BB1V, &PN) ||
           passingValueIsAlwaysUndefined(BB2V, &PN))
         return Changed;
-
-      if (isa<ConstantExpr>(BB1V) && !isSafeToSpeculativelyExecute(BB1V))
-        return Changed;
-      if (isa<ConstantExpr>(BB2V) && !isSafeToSpeculativelyExecute(BB2V))
-        return Changed;
     }
   }
 
   // Okay, it is safe to hoist the terminator.
   Instruction *NT = I1->clone();
   BIParent->getInstList().insert(BI->getIterator(), NT);
   if (!NT->getType()->isVoidTy()) {
     I1->replaceAllUsesWith(NT);
if (passingValueIsAlwaysUndefined(OrigV, &PN) ||
       return false;
 
     HaveRewritablePHIs = true;
     ConstantExpr *OrigCE = dyn_cast<ConstantExpr>(OrigV);
     ConstantExpr *ThenCE = dyn_cast<ConstantExpr>(ThenV);
     if (!OrigCE && !ThenCE)
       continue; // Known safe and cheap.
 
-    if ((ThenCE && !isSafeToSpeculativelyExecute(ThenCE)) ||
-        (OrigCE && !isSafeToSpeculativelyExecute(OrigCE)))
-      return false;
     unsigned OrigCost = OrigCE ? ComputeSpeculationCost(OrigCE, TTI) : 0;
     unsigned ThenCost = ThenCE ? ComputeSpeculationCost(ThenCE, TTI) : 0;
     unsigned MaxCost =
         2 * PHINodeFoldingThreshold * TargetTransformInfo::TCC_Basic;
     if (OrigCost + ThenCost > MaxCost)
       return false;
 
     // Account for the cost of an unfolded ConstantExpr which could end up
static bool SimplifyCondBranchToTwoReturns(BranchInst *BI,
   // Unwrap any PHI nodes in the return blocks.
   if (PHINode *TVPN = dyn_cast_or_null<PHINode>(TrueValue))
     if (TVPN->getParent() == TrueSucc)
       TrueValue = TVPN->getIncomingValueForBlock(BI->getParent());
   if (PHINode *FVPN = dyn_cast_or_null<PHINode>(FalseValue))
     if (FVPN->getParent() == FalseSucc)
       FalseValue = FVPN->getIncomingValueForBlock(BI->getParent());
 
-  // In order for this transformation to be safe, we must be able to
-  // unconditionally execute both operands to the return.  This is
-  // normally the case, but we could have a potentially-trapping
-  // constant expression that prevents this transformation from being
-  // safe.
-  if (ConstantExpr *TCV = dyn_cast_or_null<ConstantExpr>(TrueValue))
-    if (TCV->canTrap())
-      return false;
-  if (ConstantExpr *FCV = dyn_cast_or_null<ConstantExpr>(FalseValue))
-    if (FCV->canTrap())
-      return false;
-
   // Okay, we collected all the mapped values and checked them for sanity, and
   // defined to really do this transformation.  First, update the CFG.
   TrueSucc->removePredecessor(BI->getParent());
   FalseSucc->removePredecessor(BI->getParent());
 
   // Insert select instructions where needed.
   Value *BrCond = BI->getCondition();
   if (TrueValue) {
for (auto I = BB->begin(); Cond != &*I; ++I) {
     // Account for the cost of duplicating this instruction into each
     // predecessor.
     NumBonusInsts += PredCount;
     // Early exits once we reach the limit.
     if (NumBonusInsts > BonusInstThreshold)
       return false;
   }
 
-  // Cond is known to be a compare or binary operator.  Check to make sure that
-  // neither operand is a potentially-trapping constant expression.
-  if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Cond->getOperand(0)))
-    if (CE->canTrap())
-      return false;
-  if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Cond->getOperand(1)))
-    if (CE->canTrap())
-      return false;
-
   // Finally, don't infinitely unroll conditional loops.
   BasicBlock *TrueDest = BI->getSuccessor(0);
   BasicBlock *FalseDest = (BI->isConditional()) ? BI->getSuccessor(1) : nullptr;
   if (TrueDest == BB || FalseDest == BB)
     return false;
 
   for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) {
     BasicBlock *PredBlock = *PI;
if (BlockIsSimpleEnoughToThreadThrough(BB)) {
         }
       }
 
       BI->setCondition(NewPN);
       return true;
     }
   }
 
-  if (auto *CE = dyn_cast<ConstantExpr>(BI->getCondition()))
-    if (CE->canTrap())
-      return false;
-
   // If both branches are conditional and both contain stores to the same
   // address, remove the stores from the conditionals and create a conditional
   // merged store at the end.
   if (MergeCondStores && mergeConditionalStores(PBI, BI, DL))
     return true;
 
   // If this is a conditional branch in an empty block, and if any
   // predecessors are a conditional branch to one of our destinations,
static bool SimplifyCondBranchToCondBranch(BranchInst *PBI, BranchInst *BI,
   // isn't BB itself.  If so, this is an infinite loop that will
   // keep getting unwound.
   if (PBI->getSuccessor(PBIOp) == BB)
     return false;
 
   // Do not perform this transformation if it would require
   // insertion of a large number of select instructions. For targets
   // without predication/cmovs, this is a big pessimization.
-
-  // Also do not perform this transformation if any phi node in the common
-  // destination block can trap when reached by BB or PBB (PR17073). In that
-  // case, it would be unsafe to hoist the operation into a select instruction.
-
   BasicBlock *CommonDest = PBI->getSuccessor(PBIOp);
   unsigned NumPhis = 0;
   for (BasicBlock::iterator II = CommonDest->begin(); isa<PHINode>(II);
        ++II, ++NumPhis) {
     if (NumPhis > 2) // Disable this xform.
       return false;
-
-    PHINode *PN = cast<PHINode>(II);
-    Value *BIV = PN->getIncomingValueForBlock(BB);
-    if (ConstantExpr *CE = dyn_cast<ConstantExpr>(BIV))
-      if (CE->canTrap())
-        return false;
-
-    unsigned PBBIdx = PN->getBasicBlockIndex(PBI->getParent());
-    Value *PBIV = PN->getIncomingValue(PBBIdx);
-    if (ConstantExpr *CE = dyn_cast<ConstantExpr>(PBIV))
-      if (CE->canTrap())
-        return false;
   }
 
   // Finally, if everything is ok, fold the branches to logical ops.
   BasicBlock *OtherDest = BI->getSuccessor(BIOp ^ 1);
 
   LLVM_DEBUG(dbgs() << "FOLDING BRs:" << *PBI->getParent()
                     << "AND: " << *BI->getParent());
 

lib/Transforms/Vectorize/LoopVectorizationLegality.cpp

static bool isUniformLoopNest(Loop *Lp, Loop *OuterLp) {
   // Check if nested loops are uniform.
   for (Loop *SubLp : *Lp)
     if (!isUniformLoopNest(SubLp, OuterLp))
       return false;
 
   return true;
 }
 
-/// Check whether it is safe to if-convert this phi node.
-///
-/// Phi nodes with constant expressions that can trap are not safe to if
-/// convert.
-static bool canIfConvertPHINodes(BasicBlock *BB) {
-  for (PHINode &Phi : BB->phis()) {
-    for (Value *V : Phi.incoming_values())
-      if (auto *C = dyn_cast<Constant>(V))
-        if (C->canTrap())
-          return false;
-  }
-  return true;
-}
-
 static Type *convertPointerToIntegerType(const DataLayout &DL, Type *Ty) {
   if (Ty->isPointerTy())
     return DL.getIntPtrType(Ty);
 
   // It is possible that char's or short's overflow when we ask for the loop's
   // trip count, work around this by changing the type size.
   if (Ty->getScalarSizeInBits() < 32)
     return Type::getInt32Ty(Ty->getContext());
bool LoopVectorizationLegality::blockNeedsPredication(BasicBlock *BB) {
   return LoopAccessInfo::blockNeedsPredication(BB, TheLoop, DT);
 }
 
 bool LoopVectorizationLegality::blockCanBePredicated(
     BasicBlock *BB, SmallPtrSetImpl<Value *> &SafePtrs) {
   const bool IsAnnotatedParallel = TheLoop->isAnnotatedParallel();
 
   for (Instruction &I : *BB) {
-    // Check that we don't have a constant expression that can trap as operand.
-    for (Value *Operand : I.operands()) {
-      if (auto *C = dyn_cast<Constant>(Operand))
-        if (C->canTrap())
-          return false;
-    }
     // We might be able to hoist the load.
     if (I.mayReadFromMemory()) {
       auto *LI = dyn_cast<LoadInst>(&I);
       if (!LI)
         return false;
       if (!SafePtrs.count(LI->getPointerOperand())) {
         // !llvm.mem.parallel_loop_access implies if-conversion safety.
         // Otherwise, record that the load needs (real or emulated) masking
for (BasicBlock *BB : TheLoop->blocks()) {
     if (blockNeedsPredication(BB)) {
       if (!blockCanBePredicated(BB, SafePointes)) {
         reportVectorizationFailure(
             "Control flow cannot be substituted for a select",
             "control flow cannot be substituted for a select",
             "NoCFGForSelect", BB->getTerminator());
         return false;
       }
-    } else if (BB != Header && !canIfConvertPHINodes(BB)) {
-      reportVectorizationFailure(
-          "Control flow cannot be substituted for a select",
-          "control flow cannot be substituted for a select",
-          "NoCFGForSelect", BB->getTerminator());
-      return false;
     }
   }
 
   // We can if-convert this loop.
   return true;
 }
 
 // Helper function to canVectorizeLoopNestCFG.

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

 ; CHECK-NEXT:    jne .LBB0_2
 ; CHECK-NEXT:  # %bb.1: # %cond.false.i
 ; CHECK-NEXT:    movl $g_4, %eax
 ; CHECK-NEXT:    movl $g_2+4, %ecx
 ; CHECK-NEXT:    xorl %esi, %esi
 ; CHECK-NEXT:    cmpq %rax, %rcx
 ; CHECK-NEXT:    sete %sil
 ; CHECK-NEXT:    movl $1, %eax
+; CHECK-NEXT:    cmovnel %eax, %esi
+; CHECK-NEXT:    movl $1, %eax
 ; CHECK-NEXT:    xorl %edx, %edx
 ; CHECK-NEXT:    divl %esi
 ; 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

test/CodeGen/X86/divide-constant.ll

+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+; RUN: llc < %s -mtriple=x86_64-linux-gnu -verify-machineinstrs | FileCheck %s -check-prefix=SDAG
+; RUN: llc < %s -mtriple=x86_64-linux-gnu -fast-isel -verify-machineinstrs | FileCheck %s -check-prefix=FAST
+; RUN: llc < %s -mtriple=x86_64-linux-gnu -global-isel -global-isel-abort=0 -verify-machineinstrs | FileCheck %s  -check-prefix=GLOBAL
+
+@g1 = extern_weak global i32
+@g2 = extern_weak global i32
+
+define i32 @test1(i1 %c) {
+; SDAG-LABEL: test1:
+; SDAG:       # %bb.0: # %entry
+; SDAG-NEXT:    movl $g1, %eax
+; SDAG-NEXT:    xorl $-2147483648, %eax # imm = 0x80000000
+; SDAG-NEXT:    movl $g2, %esi
+; SDAG-NEXT:    movl $g2, %ecx
+; SDAG-NEXT:    notl %ecx
+; SDAG-NEXT:    orl %eax, %ecx
+; SDAG-NEXT:    sete %al
+; SDAG-NEXT:    testl %esi, %esi
+; SDAG-NEXT:    sete %cl
+; SDAG-NEXT:    orb %al, %cl
+; SDAG-NEXT:    movl $1, %ecx
+; SDAG-NEXT:    cmovnel %ecx, %esi
+; SDAG-NEXT:    movl $g1, %eax
+; SDAG-NEXT:    cltd
+; SDAG-NEXT:    idivl %esi
+; SDAG-NEXT:    testb $1, %dil
+; SDAG-NEXT:    je .LBB0_2
+; SDAG-NEXT:  # %bb.1:
+; SDAG-NEXT:    movl %eax, %ecx
+; SDAG-NEXT:  .LBB0_2: # %cond.end.i
+; SDAG-NEXT:    movl %ecx, %eax
+; SDAG-NEXT:    retq
+;
+; FAST-LABEL: test1:
+; FAST:       # %bb.0: # %entry
+; FAST-NEXT:    movl $g1, %eax
+; FAST-NEXT:    xorl $-2147483648, %eax # imm = 0x80000000
+; FAST-NEXT:    movl $g2, %esi
+; FAST-NEXT:    movl $g2, %ecx
+; FAST-NEXT:    notl %ecx
+; FAST-NEXT:    orl %eax, %ecx
+; FAST-NEXT:    sete %al
+; FAST-NEXT:    testl %esi, %esi
+; FAST-NEXT:    sete %cl
+; FAST-NEXT:    orb %al, %cl
+; FAST-NEXT:    movl $1, %ecx
+; FAST-NEXT:    cmovnel %ecx, %esi
+; FAST-NEXT:    movl $g1, %eax
+; FAST-NEXT:    cltd
+; FAST-NEXT:    idivl %esi
+; FAST-NEXT:    testb $1, %dil
+; FAST-NEXT:    je .LBB0_2
+; FAST-NEXT:  # %bb.1:
+; FAST-NEXT:    movl %eax, %ecx
+; FAST-NEXT:  .LBB0_2: # %cond.end.i
+; FAST-NEXT:    movl %ecx, %eax
+; FAST-NEXT:    retq
+;
+; GLOBAL-LABEL: test1:
+; GLOBAL:       # %bb.0: # %entry
+; GLOBAL-NEXT:    movl $g1, %eax
+; GLOBAL-NEXT:    xorl $-2147483648, %eax # imm = 0x80000000
+; GLOBAL-NEXT:    movl $g2, %esi
+; GLOBAL-NEXT:    movl $g2, %ecx
+; GLOBAL-NEXT:    notl %ecx
+; GLOBAL-NEXT:    orl %eax, %ecx
+; GLOBAL-NEXT:    sete %al
+; GLOBAL-NEXT:    testl %esi, %esi
+; GLOBAL-NEXT:    sete %cl
+; GLOBAL-NEXT:    orb %al, %cl
+; GLOBAL-NEXT:    movl $1, %ecx
+; GLOBAL-NEXT:    cmovnel %ecx, %esi
+; GLOBAL-NEXT:    movl $g1, %eax
+; GLOBAL-NEXT:    cltd
+; GLOBAL-NEXT:    idivl %esi
+; GLOBAL-NEXT:    testb $1, %dil
+; GLOBAL-NEXT:    je .LBB0_2
+; GLOBAL-NEXT:  # %bb.1:
+; GLOBAL-NEXT:    movl %eax, %ecx
+; GLOBAL-NEXT:  .LBB0_2: # %cond.end.i
+; GLOBAL-NEXT:    movl %ecx, %eax
+; GLOBAL-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:
+  %r = phi i32 [ sdiv (i32 ptrtoint (i32* @g1 to i32), i32 ptrtoint (i32* @g2 to i32)), %entry ], [ 1, %cond.false.i ]
+  ret i32 %r
+}
+
+define i32 @test2(i1 %c) {
+; SDAG-LABEL: test2:
+; SDAG:       # %bb.0: # %entry
+; SDAG-NEXT:    movl $g2, %esi
+; SDAG-NEXT:    cmpl $1, %esi
+; SDAG-NEXT:    movl $1, %ecx
+; SDAG-NEXT:    cmovbel %ecx, %esi
+; SDAG-NEXT:    movl $g1, %eax
+; SDAG-NEXT:    xorl %edx, %edx
+; SDAG-NEXT:    divl %esi
+; SDAG-NEXT:    testb $1, %dil
+; SDAG-NEXT:    je .LBB1_2
+; SDAG-NEXT:  # %bb.1:
+; SDAG-NEXT:    movl %eax, %ecx
+; SDAG-NEXT:  .LBB1_2: # %cond.end.i
+; SDAG-NEXT:    movl %ecx, %eax
+; SDAG-NEXT:    retq
+;
+; FAST-LABEL: test2:
+; FAST:       # %bb.0: # %entry
+; FAST-NEXT:    movl $g2, %esi
+; FAST-NEXT:    cmpl $1, %esi
+; FAST-NEXT:    movl $1, %ecx
+; FAST-NEXT:    cmovbel %ecx, %esi
+; FAST-NEXT:    movl $g1, %eax
+; FAST-NEXT:    xorl %edx, %edx
+; FAST-NEXT:    divl %esi
+; FAST-NEXT:    testb $1, %dil
+; FAST-NEXT:    je .LBB1_2
+; FAST-NEXT:  # %bb.1:
+; FAST-NEXT:    movl %eax, %ecx
+; FAST-NEXT:  .LBB1_2: # %cond.end.i
+; FAST-NEXT:    movl %ecx, %eax
+; FAST-NEXT:    retq
+;
+; GLOBAL-LABEL: test2:
+; GLOBAL:       # %bb.0: # %entry
+; GLOBAL-NEXT:    movl $g2, %esi
+; GLOBAL-NEXT:    cmpl $1, %esi
+; GLOBAL-NEXT:    movl $1, %ecx
+; GLOBAL-NEXT:    cmovbel %ecx, %esi
+; GLOBAL-NEXT:    movl $g1, %eax
+; GLOBAL-NEXT:    xorl %edx, %edx
+; GLOBAL-NEXT:    divl %esi
+; GLOBAL-NEXT:    testb $1, %dil
+; GLOBAL-NEXT:    je .LBB1_2
+; GLOBAL-NEXT:  # %bb.1:
+; GLOBAL-NEXT:    movl %eax, %ecx
+; GLOBAL-NEXT:  .LBB1_2: # %cond.end.i
+; GLOBAL-NEXT:    movl %ecx, %eax
+; GLOBAL-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:
+  %r = phi i32 [ udiv (i32 ptrtoint (i32* @g1 to i32), i32 ptrtoint (i32* @g2 to i32)), %entry ], [ 1, %cond.false.i ]
+  ret i32 %r
+}
+
+define i32 @test3(i1 %c) {
+; SDAG-LABEL: test3:
+; SDAG:       # %bb.0: # %entry
+; SDAG-NEXT:    movl $g1, %eax
+; SDAG-NEXT:    xorl $-2147483648, %eax # imm = 0x80000000
+; SDAG-NEXT:    movl $g2, %esi
+; SDAG-NEXT:    movl $g2, %ecx
+; SDAG-NEXT:    notl %ecx
+; SDAG-NEXT:    orl %eax, %ecx
+; SDAG-NEXT:    sete %al
+; SDAG-NEXT:    testl %esi, %esi
+; SDAG-NEXT:    sete %cl
+; SDAG-NEXT:    orb %al, %cl
+; SDAG-NEXT:    movl $1, %ecx
+; SDAG-NEXT:    cmovnel %ecx, %esi
+; SDAG-NEXT:    movl $g1, %eax
+; SDAG-NEXT:    cltd
+; SDAG-NEXT:    idivl %esi
+; SDAG-NEXT:    testb $1, %dil
+; SDAG-NEXT:    je .LBB2_2
+; SDAG-NEXT:  # %bb.1:
+; SDAG-NEXT:    movl %edx, %ecx
+; SDAG-NEXT:  .LBB2_2: # %cond.end.i
+; SDAG-NEXT:    movl %ecx, %eax
+; SDAG-NEXT:    retq
+;
+; FAST-LABEL: test3:
+; FAST:       # %bb.0: # %entry
+; FAST-NEXT:    movl $g1, %eax
+; FAST-NEXT:    xorl $-2147483648, %eax # imm = 0x80000000
+; FAST-NEXT:    movl $g2, %esi
+; FAST-NEXT:    movl $g2, %ecx
+; FAST-NEXT:    notl %ecx
+; FAST-NEXT:    orl %eax, %ecx
+; FAST-NEXT:    sete %al
+; FAST-NEXT:    testl %esi, %esi
+; FAST-NEXT:    sete %cl
+; FAST-NEXT:    orb %al, %cl
+; FAST-NEXT:    movl $1, %ecx
+; FAST-NEXT:    cmovnel %ecx, %esi
+; FAST-NEXT:    movl $g1, %eax
+; FAST-NEXT:    cltd
+; FAST-NEXT:    idivl %esi
+; FAST-NEXT:    testb $1, %dil
+; FAST-NEXT:    je .LBB2_2
+; FAST-NEXT:  # %bb.1:
+; FAST-NEXT:    movl %edx, %ecx
+; FAST-NEXT:  .LBB2_2: # %cond.end.i
+; FAST-NEXT:    movl %ecx, %eax
+; FAST-NEXT:    retq
+;
+; GLOBAL-LABEL: test3:
+; GLOBAL:       # %bb.0: # %entry
+; GLOBAL-NEXT:    movl $g1, %eax
+; GLOBAL-NEXT:    xorl $-2147483648, %eax # imm = 0x80000000
+; GLOBAL-NEXT:    movl $g2, %esi
+; GLOBAL-NEXT:    movl $g2, %ecx
+; GLOBAL-NEXT:    notl %ecx
+; GLOBAL-NEXT:    orl %eax, %ecx
+; GLOBAL-NEXT:    sete %al
+; GLOBAL-NEXT:    testl %esi, %esi
+; GLOBAL-NEXT:    sete %cl
+; GLOBAL-NEXT:    orb %al, %cl
+; GLOBAL-NEXT:    movl $1, %ecx
+; GLOBAL-NEXT:    cmovnel %ecx, %esi
+; GLOBAL-NEXT:    movl $g1, %eax
+; GLOBAL-NEXT:    cltd
+; GLOBAL-NEXT:    idivl %esi
+; GLOBAL-NEXT:    testb $1, %dil
+; GLOBAL-NEXT:    je .LBB2_2
+; GLOBAL-NEXT:  # %bb.1:
+; GLOBAL-NEXT:    movl %edx, %ecx
+; GLOBAL-NEXT:  .LBB2_2: # %cond.end.i
+; GLOBAL-NEXT:    movl %ecx, %eax
+; GLOBAL-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:
+  %r = phi i32 [ srem (i32 ptrtoint (i32* @g1 to i32), i32 ptrtoint (i32* @g2 to i32)), %entry ], [ 1, %cond.false.i ]
+  ret i32 %r
+}
+
+define i32 @test4(i1 %c) {
+; SDAG-LABEL: test4:
+; SDAG:       # %bb.0: # %entry
+; SDAG-NEXT:    movl $g2, %esi
+; SDAG-NEXT:    cmpl $1, %esi
+; SDAG-NEXT:    movl $1, %ecx
+; SDAG-NEXT:    cmovbel %ecx, %esi
+; SDAG-NEXT:    movl $g1, %eax
+; SDAG-NEXT:    xorl %edx, %edx
+; SDAG-NEXT:    divl %esi
+; SDAG-NEXT:    testb $1, %dil
+; SDAG-NEXT:    je .LBB3_2
+; SDAG-NEXT:  # %bb.1:
+; SDAG-NEXT:    movl %edx, %ecx
+; SDAG-NEXT:  .LBB3_2: # %cond.end.i
+; SDAG-NEXT:    movl %ecx, %eax
+; SDAG-NEXT:    retq
+;
+; FAST-LABEL: test4:
+; FAST:       # %bb.0: # %entry
+; FAST-NEXT:    movl $g2, %esi
+; FAST-NEXT:    cmpl $1, %esi
+; FAST-NEXT:    movl $1, %ecx
+; FAST-NEXT:    cmovbel %ecx, %esi
+; FAST-NEXT:    movl $g1, %eax
+; FAST-NEXT:    xorl %edx, %edx
+; FAST-NEXT:    divl %esi
+; FAST-NEXT:    testb $1, %dil
+; FAST-NEXT:    je .LBB3_2
+; FAST-NEXT:  # %bb.1:
+; FAST-NEXT:    movl %edx, %ecx
+; FAST-NEXT:  .LBB3_2: # %cond.end.i
+; FAST-NEXT:    movl %ecx, %eax
+; FAST-NEXT:    retq
+;
+; GLOBAL-LABEL: test4:
+; GLOBAL:       # %bb.0: # %entry
+; GLOBAL-NEXT:    movl $g2, %esi
+; GLOBAL-NEXT:    cmpl $1, %esi
+; GLOBAL-NEXT:    movl $1, %ecx
+; GLOBAL-NEXT:    cmovbel %ecx, %esi
+; GLOBAL-NEXT:    movl $g1, %eax
+; GLOBAL-NEXT:    xorl %edx, %edx
+; GLOBAL-NEXT:    divl %esi
+; GLOBAL-NEXT:    testb $1, %dil
+; GLOBAL-NEXT:    je .LBB3_2
+; GLOBAL-NEXT:  # %bb.1:
+; GLOBAL-NEXT:    movl %edx, %ecx
+; GLOBAL-NEXT:  .LBB3_2: # %cond.end.i
+; GLOBAL-NEXT:    movl %ecx, %eax
+; GLOBAL-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:
+  %r = phi i32 [ urem (i32 ptrtoint (i32* @g1 to i32), i32 ptrtoint (i32* @g2 to i32)), %entry ], [ 1, %cond.false.i ]
+  ret i32 %r
+}
+
+define i32 @test5(i32 %c) {
+; SDAG-LABEL: test5:
+; SDAG:       # %bb.0: # %entry
+; SDAG-NEXT:    movl $g1, %eax
+; SDAG-NEXT:    xorl $-2147483648, %eax # imm = 0x80000000
+; SDAG-NEXT:    movl $g2, %ecx
+; SDAG-NEXT:    movl $g2, %edx
+; SDAG-NEXT:    notl %edx
+; SDAG-NEXT:    orl %eax, %edx
+; SDAG-NEXT:    sete %al
+; SDAG-NEXT:    testl %ecx, %ecx
+; SDAG-NEXT:    sete %dl
+; SDAG-NEXT:    orb %al, %dl
+; SDAG-NEXT:    movl $1, %eax
+; SDAG-NEXT:    cmovnel %eax, %ecx
+; SDAG-NEXT:    movl $g1, %eax
+; SDAG-NEXT:    cltd
+; SDAG-NEXT:    idivl %ecx
+; SDAG-NEXT:    #APP
+; SDAG-NEXT:    #NO_APP
+; SDAG-NEXT:  .Ltmp0: # Block address taken
+; SDAG-NEXT:  .LBB4_1: # %cond.false.i
+; SDAG-NEXT:    movl $1, %eax
+; SDAG-NEXT:  .LBB4_2: # %cond.end.i
+; SDAG-NEXT:    retq
+;
+; FAST-LABEL: test5:
+; FAST:       # %bb.0: # %entry
+; FAST-NEXT:    movl $g1, %eax
+; FAST-NEXT:    xorl $-2147483648, %eax # imm = 0x80000000
+; FAST-NEXT:    movl $g2, %ecx
+; FAST-NEXT:    movl $g2, %edx
+; FAST-NEXT:    notl %edx
+; FAST-NEXT:    orl %eax, %edx
+; FAST-NEXT:    sete %al
+; FAST-NEXT:    testl %ecx, %ecx
+; FAST-NEXT:    sete %dl
+; FAST-NEXT:    orb %al, %dl
+; FAST-NEXT:    movl $1, %eax
+; FAST-NEXT:    cmovnel %eax, %ecx
+; FAST-NEXT:    movl $g1, %eax
+; FAST-NEXT:    cltd
+; FAST-NEXT:    idivl %ecx
+; FAST-NEXT:    #APP
+; FAST-NEXT:    #NO_APP
+; FAST-NEXT:  .Ltmp0: # Block address taken
+; FAST-NEXT:  .LBB4_1: # %cond.false.i
+; FAST-NEXT:    movl $1, %eax
+; FAST-NEXT:  .LBB4_2: # %cond.end.i
+; FAST-NEXT:    retq
+;
+; GLOBAL-LABEL: test5:
+; GLOBAL:       # %bb.0: # %entry
+; GLOBAL-NEXT:    movl $g1, %eax
+; GLOBAL-NEXT:    xorl $-2147483648, %eax # imm = 0x80000000
+; GLOBAL-NEXT:    movl $g2, %ecx
+; GLOBAL-NEXT:    movl $g2, %edx
+; GLOBAL-NEXT:    notl %edx
+; GLOBAL-NEXT:    orl %eax, %edx
+; GLOBAL-NEXT:    sete %al
+; GLOBAL-NEXT:    testl %ecx, %ecx
+; GLOBAL-NEXT:    sete %dl
+; GLOBAL-NEXT:    orb %al, %dl
+; GLOBAL-NEXT:    movl $1, %eax
+; GLOBAL-NEXT:    cmovnel %eax, %ecx
+; GLOBAL-NEXT:    movl $g1, %eax
+; GLOBAL-NEXT:    cltd
+; GLOBAL-NEXT:    idivl %ecx
+; GLOBAL-NEXT:    #APP
+; GLOBAL-NEXT:    #NO_APP
+; GLOBAL-NEXT:  .Ltmp0: # Block address taken
+; GLOBAL-NEXT:  .LBB4_1: # %cond.false.i
+; GLOBAL-NEXT:    movl $1, %eax
+; GLOBAL-NEXT:  .LBB4_2: # %cond.end.i
+; GLOBAL-NEXT:    retq
+entry:
+  callbr void asm "", "r,X"(i32 %c, i8 *blockaddress(@test5, %cond.false.i))
+            to label %cond.false.i [label %cond.end.i]
+
+cond.false.i:
+  br label %cond.end.i
+
+cond.end.i:
+  %r = phi i32 [ sdiv (i32 ptrtoint (i32* @g1 to i32), i32 ptrtoint (i32* @g2 to i32)), %entry ], [ 1, %cond.false.i ]
+  ret i32 %r
+}