UnreachableValue

[nicholas]

Summary

Add "unreachable constants". An unreachable constant is used to indicate that the evaluation of a constant expression would trap. An instruction that produces an unreachable constant has no defined semantics.

[sanjoy]

Hi Nick,

As mentioned on the email thread, unreachable looks a lot like
poison, and I suspect it has the same kinds of issues:

• In the context of unreachable, is select strict or lazy in its non-condition arguments? IOW is select false, unreachable, 42 == 42 or == unreachable. If the former, then select s cannot be folded into arithmetic; if the latter then br - phi pairs cannot be folded into selects.
• Since we optimize select C, X, undef to X, with your patch it is possible for LLVM to substitute undef with unreachable. If we want unreachable to be "stronger" than undef (in that, it should allow more aggressive optimizations), then that optimization needs to be removed.

docs/LangRef.rst

``insertvalue (VAL, ELT, IDX0, IDX1, ...)``
     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).
 
+.. _unreachableconstants:
+
+Unreachable Constants
+---------------------
+
+Unreachable constants are used to indicate that the evaluation of a constant
+expression would trap. An instruction that produces an unreachable constant
+has no defined semantics.
+
+Ordinarily an instruction produces unreachable if it has an unreachable
+operand, but there are some exceptions. A select instruction whose condition
+does not select an unreachable does not produce an unreachable, similarly a PHI
+node that does not select an unreachable. A load instruction may have no
+unreachable constant operands, but still produce an unreachable constant either
+by being a provably invalid load, or by loading a global holding an unreachable
+constant itself. An unreachable constant may be a single member in an aggregate
+value without making the whole value unreachable.
+
 Other Values
 ============
 
 .. _inlineasmexprs:
 
 Inline Assembler Expressions
 ----------------------------
 

include/llvm/Bitcode/LLVMBitCodes.h

enum ConstantsCodes {
   CST_CODE_CE_SHUFFLEVEC = 16,   // CE_SHUFFLEVEC: [opval, opval, opval]
   CST_CODE_CE_CMP = 17,          // CE_CMP:        [opty, opval, opval, pred]
   CST_CODE_INLINEASM_OLD = 18,   // INLINEASM:     [sideeffect|alignstack,
                                  //                 asmstr,conststr]
   CST_CODE_CE_SHUFVEC_EX = 19,   // SHUFVEC_EX:    [opty, opval, opval, opval]
   CST_CODE_CE_INBOUNDS_GEP = 20, // INBOUNDS_GEP:  [n x operands]
   CST_CODE_BLOCKADDRESS = 21,    // CST_CODE_BLOCKADDRESS [fnty, fnval, bb#]
   CST_CODE_DATA = 22,            // DATA:          [n x elements]
-  CST_CODE_INLINEASM = 23        // INLINEASM:     [sideeffect|alignstack|
+  CST_CODE_INLINEASM = 23,       // INLINEASM:     [sideeffect|alignstack|
                                  //                 asmdialect,asmstr,conststr]
+  CST_CODE_UNREACHABLE   = 24    // UNREACHABLE
 };
 
 /// CastOpcodes - These are values used in the bitcode files to encode which
 /// cast a CST_CODE_CE_CAST or a XXX refers to.  The values of these enums
 /// have no fixed relation to the LLVM IR enum values.  Changing these will
 /// break compatibility with old files.
 enum CastOpcodes {
   CAST_TRUNC = 0,

include/llvm/IR/Constants.h

 #include "llvm/IR/Constant.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/OperandTraits.h"
 
 namespace llvm {
 
 class ArrayType;
 class IntegerType;
+class SequentialType;
 class StructType;
 class PointerType;
 class VectorType;
-class SequentialType;
 
 struct ConstantExprKeyType;
 template <class ConstantClass> struct ConstantAggrKeyType;
 
 /// Base class for constants with no operands.
 ///
 /// These constants have no operands; they represent their data directly.
 /// Since they can be in use by unrelated modules (and are never based on

 
 protected:
   explicit UndefValue(Type *T) : ConstantData(T, UndefValueVal) {}
 
 public:
   /// Static factory methods - Return an 'undef' object of the specified type.
   static UndefValue *get(Type *T);
 
-  /// If this Undef has array or vector type, return a undef with the right
+  /// If this Undef has array or vector type, return an undef with the right
   /// element type.
   UndefValue *getSequentialElement() const;
 
-  /// If this undef has struct type, return a undef with the right element type
+  /// If this undef has struct type, return an undef with the right element type
   /// for the specified element.
   UndefValue *getStructElement(unsigned Elt) const;
 
   /// Return an undef of the right value for the specified GEP index.
   UndefValue *getElementValue(Constant *C) const;
 
   /// Return an undef of the right value for the specified GEP index.
   UndefValue *getElementValue(unsigned Idx) const;
 
   /// Return the number of elements in the array, vector, or struct.
   unsigned getNumElements() const;
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Value *V) {
     return V->getValueID() == UndefValueVal;
   }
 };
 
+//===----------------------------------------------------------------------===//
+/// 'unreachable' values are placeholders for computations that not only have
+/// no result, but are guaranteed never execute in any run of the program.
+/// These are used for a variety of purposes, including global variable
+/// initializers and operands to instructions.  'unreachable' values can occur
+/// with any first-class type.
+///
+/// Unreachable values aren't exactly constants, they represent a property of
+/// the control flow graph, but can be used in algorithms that operate strictly
+/// as data flow problems. See LangRef.html#unreachablevalues for details.
+///
+class UnreachableValue : public ConstantData {
+  UnreachableValue(const UnreachableValue &) = delete;
+
+  friend class Constant;
+  void destroyConstantImpl();
+
+protected:
+  explicit UnreachableValue(Type *T) : ConstantData(T, UnreachableValueVal) {}
+
+public:
+  /// Static factory methods - Return an 'unreachable' object of the specified
+  /// type.
+  static UnreachableValue *get(Type *T);
+
+  /// If this Unreachable has array or vector type, return an unreachable with
+  /// the right element type.
+  UnreachableValue *getSequentialElement() const;
+
+  /// If this unreachable has struct type, return an unreachable with the right
+  /// element type for the specified element.
+  UnreachableValue *getStructElement(unsigned Elt) const;
+
+  /// Return an unreachable of the right value for the specified GEP index.
+  UnreachableValue *getElementValue(Constant *C) const;
+
+  /// Return an unreachable of the right value for the specified GEP index.
+  UnreachableValue *getElementValue(unsigned Idx) const;
+
+  /// Return the number of elements in the array, vector, or struct.
+  unsigned getNumElements() const;
+
+  /// Methods for support type inquiry through isa, cast, and dyn_cast:
+  static bool classof(const Value *V) {
+    return V->getValueID() == UnreachableValueVal;
+  }
+};
+
 } // End llvm namespace
 
 #endif

include/llvm/IR/PatternMatch.h

 /// \brief Matches any compare instruction and ignore it.
 inline class_match<CmpInst> m_Cmp() { return class_match<CmpInst>(); }
 
 /// \brief Match an arbitrary ConstantInt and ignore it.
 inline class_match<ConstantInt> m_ConstantInt() {
   return class_match<ConstantInt>();
 }
 
+/// \brief Match an arbitrary unreachable constant.
+inline class_match<UnreachableValue> m_Unreachable() { return class_match<UnreachableValue>(); }
+
 /// \brief Match an arbitrary undef constant.
 inline class_match<UndefValue> m_Undef() { return class_match<UndefValue>(); }
 
 /// \brief Match an arbitrary Constant and ignore it.
 inline class_match<Constant> m_Constant() { return class_match<Constant>(); }
 
 /// Matching combinators
 template <typename LTy, typename RTy> struct match_combine_or {

include/llvm/IR/Value.def

 HANDLE_CONSTANT(UndefValue)
 HANDLE_CONSTANT(ConstantAggregateZero)
 HANDLE_CONSTANT(ConstantDataArray)
 HANDLE_CONSTANT(ConstantDataVector)
 HANDLE_CONSTANT(ConstantInt)
 HANDLE_CONSTANT(ConstantFP)
 HANDLE_CONSTANT(ConstantPointerNull)
 HANDLE_CONSTANT(ConstantTokenNone)
+HANDLE_CONSTANT(UnreachableValue)
 
 HANDLE_METADATA_VALUE(MetadataAsValue)
 HANDLE_INLINE_ASM_VALUE(InlineAsm)
 
 HANDLE_INSTRUCTION(Instruction)
 // Enum values starting at InstructionVal are used for Instructions;
 // don't add new values here!
 
 HANDLE_CONSTANT_MARKER(ConstantFirstVal, Function)
-HANDLE_CONSTANT_MARKER(ConstantLastVal, ConstantTokenNone)
+HANDLE_CONSTANT_MARKER(ConstantLastVal, UnreachableValue)
 HANDLE_CONSTANT_MARKER(ConstantDataFirstVal, UndefValue)
-HANDLE_CONSTANT_MARKER(ConstantDataLastVal, ConstantTokenNone)
+HANDLE_CONSTANT_MARKER(ConstantDataLastVal, UnreachableValue)
 
 #undef HANDLE_GLOBAL_VALUE
 #undef HANDLE_CONSTANT
 #undef HANDLE_INSTRUCTION
 #undef HANDLE_METADATA_VALUE
 #undef HANDLE_INLINE_ASM_VALUE
 #undef HANDLE_VALUE
 #undef HANDLE_CONSTANT_MARKER

lib/Analysis/InstructionSimplify.cpp

static Value *ThreadBinOpOverSelect(unsigned Opcode, Value *LHS, Value *RHS,
   }
 
   // If they simplified to the same value, then return the common value.
   // If they both failed to simplify then return null.
   if (TV == FV)
     return TV;
 
   // If one branch simplified to undef, return the other one.
-  if (TV && isa<UndefValue>(TV))
+  if (TV && (isa<UndefValue>(TV) || isa<UnreachableValue>(TV)))
     return FV;
-  if (FV && isa<UndefValue>(FV))
+  if (FV && (isa<UndefValue>(FV) || isa<UnreachableValue>(FV)))
     return TV;
 
   // If applying the operation did not change the true and false select values,
   // then the result of the binop is the select itself.
   if (TV == SI->getTrueValue() && FV == SI->getFalseValue())
     return SI;
 
   // If one branch simplified and the other did not, and the simplified
static Value *SimplifyAddInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW,
   if (Constant *CLHS = dyn_cast<Constant>(Op0)) {
     if (Constant *CRHS = dyn_cast<Constant>(Op1))
       return ConstantFoldBinaryOpOperands(Instruction::Add, CLHS, CRHS, Q.DL);
 
     // Canonicalize the constant to the RHS.
     std::swap(Op0, Op1);
   }
 
+  // X + unreachable -> unreachable
+  if (match(Op1, m_Unreachable()))
+    return Op1;
+
   // X + undef -> undef
   if (match(Op1, m_Undef()))
     return Op1;
 
   // X + 0 -> X
   if (match(Op1, m_Zero()))
     return Op0;
 

 /// Given operands for a Sub, see if we can fold the result.
 /// If not, this returns null.
 static Value *SimplifySubInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW,
                               const Query &Q, unsigned MaxRecurse) {
   if (Constant *CLHS = dyn_cast<Constant>(Op0))
     if (Constant *CRHS = dyn_cast<Constant>(Op1))
       return ConstantFoldBinaryOpOperands(Instruction::Sub, CLHS, CRHS, Q.DL);
 
+  // X - unreachable -> unreachable
+  // unreachable - X -> unreachable
+  if (match(Op0, m_Unreachable()) || match(Op1, m_Unreachable()))
+    return UnreachableValue::get(Op0->getType());
+
   // X - undef -> undef
   // undef - X -> undef
   if (match(Op0, m_Undef()) || match(Op1, m_Undef()))
     return UndefValue::get(Op0->getType());
 
   // X - 0 -> X
   if (match(Op1, m_Zero()))
     return Op0;
static Value *SimplifyMulInst(Value *Op0, Value *Op1, const Query &Q,
   if (Constant *CLHS = dyn_cast<Constant>(Op0)) {
     if (Constant *CRHS = dyn_cast<Constant>(Op1))
       return ConstantFoldBinaryOpOperands(Instruction::Mul, CLHS, CRHS, Q.DL);
 
     // Canonicalize the constant to the RHS.
     std::swap(Op0, Op1);
   }
 
+  // X * unreachable -> unreachable
+  if (match(Op1, m_Unreachable()))
+    return UnreachableValue::get(Op0->getType());
+
   // X * undef -> 0
   if (match(Op1, m_Undef()))
     return Constant::getNullValue(Op0->getType());
 
   // X * 0 -> 0
   if (match(Op1, m_Zero()))
     return Op1;
 

 static Value *SimplifyDiv(Instruction::BinaryOps Opcode, Value *Op0, Value *Op1,
                           const Query &Q, unsigned MaxRecurse) {
   if (Constant *C0 = dyn_cast<Constant>(Op0))
     if (Constant *C1 = dyn_cast<Constant>(Op1))
       return ConstantFoldBinaryOpOperands(Opcode, C0, C1, Q.DL);
 
   bool isSigned = Opcode == Instruction::SDiv;
 
-  // X / undef -> undef
-  if (match(Op1, m_Undef()))
-    return Op1;
-
-  // X / 0 -> undef, we don't need to preserve faults!
-  if (match(Op1, m_Zero()))
-    return UndefValue::get(Op1->getType());
+  // X / unreachable -> unreachable
+  // X / undef -> unreachable
+  // X / 0 -> unreachable
+  if (match(Op1, m_Unreachable()) || match(Op1, m_Undef()) ||
+      match(Op1, m_Zero()))
+    return UnreachableValue::get(Op1->getType());
+
+  // unreachable / X -> unreachable
+  if (match(Op0, m_Unreachable()))
+    return UnreachableValue::get(Op1->getType());
 
   // undef / X -> 0
   if (match(Op0, m_Undef()))
     return Constant::getNullValue(Op0->getType());
 
   // 0 / X -> 0, we don't need to preserve faults!
   if (match(Op0, m_Zero()))
     return Op0;
Value *llvm::SimplifyUDivInst(Value *Op0, Value *Op1, const DataLayout &DL,
                               const DominatorTree *DT, AssumptionCache *AC,
                               const Instruction *CxtI) {
   return ::SimplifyUDivInst(Op0, Op1, Query(DL, TLI, DT, AC, CxtI),
                             RecursionLimit);
 }
 
 static Value *SimplifyFDivInst(Value *Op0, Value *Op1, FastMathFlags FMF,
                                const Query &Q, unsigned) {
+  // unreachable / X -> unreachable
+  // X / unreachable -> unreachable
+  if (match(Op0, m_Unreachable()) || match(Op1, m_Unreachable()))
+    return UnreachableValue::get(Op0->getType());
+
   // undef / X -> undef    (the undef could be a snan).
   if (match(Op0, m_Undef()))
     return Op0;
 
   // X / undef -> undef
   if (match(Op1, m_Undef()))
     return Op1;
 

 /// Given operands for an SRem or URem, see if we can fold the result.
 /// If not, this returns null.
 static Value *SimplifyRem(Instruction::BinaryOps Opcode, Value *Op0, Value *Op1,
                           const Query &Q, unsigned MaxRecurse) {
   if (Constant *C0 = dyn_cast<Constant>(Op0))
     if (Constant *C1 = dyn_cast<Constant>(Op1))
       return ConstantFoldBinaryOpOperands(Opcode, C0, C1, Q.DL);
 
-  // X % undef -> undef
-  if (match(Op1, m_Undef()))
-    return Op1;
+  // X % unreachable -> unreachable
+  // X % undef -> unreachable
+  if (match(Op1, m_Undef()) || match(Op1, m_Unreachable()))
+    return UnreachableValue::get(Op0->getType());
+
+  // unreachable % X -> unreachable
+  if (match(Op0, m_Undef()))
+    return UnreachableValue::get(Op0->getType());
 
   // undef % X -> 0
   if (match(Op0, m_Undef()))
     return Constant::getNullValue(Op0->getType());
 
   // 0 % X -> 0, we don't need to preserve faults!
   if (match(Op0, m_Zero()))
     return Op0;
 
-  // X % 0 -> undef, we don't need to preserve faults!
+  // X % 0 -> unreachable
   if (match(Op1, m_Zero()))
-    return UndefValue::get(Op0->getType());
+    return UnreachableValue::get(Op0->getType());
 
   // X % 1 -> 0
   if (match(Op1, m_One()))
     return Constant::getNullValue(Op0->getType());
 
   if (Op0->getType()->isIntegerTy(1))
     // It can't be remainder by zero, hence it must be remainder by one.
     return Constant::getNullValue(Op0->getType());
static Value *SimplifyAndInst(Value *Op0, Value *Op1, const Query &Q,
   if (Constant *CLHS = dyn_cast<Constant>(Op0)) {
     if (Constant *CRHS = dyn_cast<Constant>(Op1))
       return ConstantFoldBinaryOpOperands(Instruction::And, CLHS, CRHS, Q.DL);
 
     // Canonicalize the constant to the RHS.
     std::swap(Op0, Op1);
   }
 
+  // unreachable & X -> unreachable
+  // X & unreachable -> unreachable
+  if (match(Op0, m_Unreachable()) || match(Op1, m_Unreachable()))
+    return UnreachableValue::get(Op0->getType());
+
   // X & undef -> 0
   if (match(Op1, m_Undef()))
     return Constant::getNullValue(Op0->getType());
 
   // X & X = X
   if (Op0 == Op1)
     return Op0;
 
static Value *SimplifyOrInst(Value *Op0, Value *Op1, const Query &Q,
   if (Constant *CLHS = dyn_cast<Constant>(Op0)) {
     if (Constant *CRHS = dyn_cast<Constant>(Op1))
       return ConstantFoldBinaryOpOperands(Instruction::Or, CLHS, CRHS, Q.DL);
 
     // Canonicalize the constant to the RHS.
     std::swap(Op0, Op1);
   }
 
+  // X | unreachable -> unreachable
+  // unreachable | X -> unreachable
+  if (match(Op0, m_Unreachable()) || match(Op1, m_Unreachable()))
+    return UnreachableValue::get(Op0->getType());
+
   // X | undef -> -1
   if (match(Op1, m_Undef()))
     return Constant::getAllOnesValue(Op0->getType());
 
   // X | X = X
   if (Op0 == Op1)
     return Op0;
 
static Value *SimplifyXorInst(Value *Op0, Value *Op1, const Query &Q,
   if (Constant *CLHS = dyn_cast<Constant>(Op0)) {
     if (Constant *CRHS = dyn_cast<Constant>(Op1))
       return ConstantFoldBinaryOpOperands(Instruction::Xor, CLHS, CRHS, Q.DL);
 
     // Canonicalize the constant to the RHS.
     std::swap(Op0, Op1);
   }
 
+  // A ^ unreachable -> unreachable
+  // unreachable ^ A -> unreachable
+  if (match(Op0, m_Unreachable()) || match(Op1, m_Unreachable()))
+    return UnreachableValue::get(Op0->getType());
+
   // A ^ undef -> undef
   if (match(Op1, m_Undef()))
     return Op1;
 
   // A ^ 0 = A
   if (match(Op1, m_Zero()))
     return Op0;
 
if (Constant *CLHS = dyn_cast<Constant>(LHS)) {
     // If we have a constant, make sure it is on the RHS.
     std::swap(LHS, RHS);
     Pred = CmpInst::getSwappedPredicate(Pred);
   }
 
   Type *ITy = GetCompareTy(LHS); // The return type.
   Type *OpTy = LHS->getType();   // The operand type.
 
+  // icmp X, unreachable -> unreachable
+  if (isa<UnreachableValue>(RHS))
+    return UnreachableValue::get(ITy);
+
   // icmp X, X -> true/false
   // X icmp undef -> true/false.  For example, icmp ugt %X, undef -> false
   // because X could be 0.
   if (LHS == RHS || isa<UndefValue>(RHS))
     return ConstantInt::get(ITy, CmpInst::isTrueWhenEqual(Pred));
 
   // Special case logic when the operands have i1 type.
   if (OpTy->getScalarType()->isIntegerTy(1)) {
static Value *SimplifySelectInst(Value *CondVal, Value *TrueVal,
   // select false, X, Y -> Y
   if (Constant *CB = dyn_cast<Constant>(CondVal)) {
     if (CB->isAllOnesValue())
       return TrueVal;
     if (CB->isNullValue())
       return FalseVal;
   }
 
+  // select unreachable, X, Y, -> unreachable
+  if (isa<UnreachableValue>(CondVal))
+    return UnreachableValue::get(TrueVal->getType());
+
   // select C, X, X -> X
   if (TrueVal == FalseVal)
     return TrueVal;
 
   if (isa<UndefValue>(CondVal)) {  // select undef, X, Y -> X or Y
     if (isa<Constant>(TrueVal))
       return TrueVal;
     return FalseVal;
   }
-  if (isa<UndefValue>(TrueVal))   // select C, undef, X -> X
+  // select C, undef, X -> X
+  // select C, unreachable, X -> X
+  if (isa<UndefValue>(TrueVal) || isa<UnreachableValue>(TrueVal))
     return FalseVal;
-  if (isa<UndefValue>(FalseVal))   // select C, X, undef -> X
+  // select C, X, undef -> X
+  // select C, X, unreachable -> X
+  if (isa<UndefValue>(FalseVal) || isa<UnreachableValue>(TrueVal))
     return TrueVal;
 
   if (const auto *ICI = dyn_cast<ICmpInst>(CondVal)) {
     unsigned BitWidth = Q.DL.getTypeSizeInBits(TrueVal->getType());
     ICmpInst::Predicate Pred = ICI->getPredicate();
     Value *CmpLHS = ICI->getOperand(0);
     Value *CmpRHS = ICI->getOperand(1);
     APInt MinSignedValue = APInt::getSignBit(BitWidth);
if (Ops.size() == 1)
     return Ops[0];
 
   // Compute the (pointer) type returned by the GEP instruction.
   Type *LastType = GetElementPtrInst::getIndexedType(SrcTy, Ops.slice(1));
   Type *GEPTy = PointerType::get(LastType, AS);
   if (VectorType *VT = dyn_cast<VectorType>(Ops[0]->getType()))
     GEPTy = VectorType::get(GEPTy, VT->getNumElements());
 
+  if (isa<UnreachableValue>(Ops[0]))
+    return UnreachableValue::get(GEPTy);
+
   if (isa<UndefValue>(Ops[0]))
     return UndefValue::get(GEPTy);
 
   if (Ops.size() == 2) {
     // getelementptr P, 0 -> P.
     if (match(Ops[1], m_Zero()))
       return Ops[0];
 

 /// If not, this returns null.
 static Value *SimplifyInsertValueInst(Value *Agg, Value *Val,
                                       ArrayRef<unsigned> Idxs, const Query &Q,
                                       unsigned) {
   if (Constant *CAgg = dyn_cast<Constant>(Agg))
     if (Constant *CVal = dyn_cast<Constant>(Val))
       return ConstantFoldInsertValueInstruction(CAgg, CVal, Idxs);
 
+  // insertvalue unreachable, x, n -> unreachable
+  if (match(Agg, m_Unreachable()))
+    return Agg;
+
   // insertvalue x, undef, n -> x
   if (match(Val, m_Undef()))
     return Agg;
 
   // insertvalue x, (extractvalue y, n), n
   if (ExtractValueInst *EV = dyn_cast<ExtractValueInst>(Val))
     if (EV->getAggregateOperand()->getType() == Agg->getType() &&
         EV->getIndices() == Idxs) {
if (auto *CIdx = dyn_cast<Constant>(Idx))
       return ConstantFoldExtractElementInstruction(CVec, CIdx);
 
     // The index is not relevant if our vector is a splat.
     if (auto *Splat = CVec->getSplatValue())
       return Splat;
 
     if (isa<UndefValue>(Vec))
       return UndefValue::get(Vec->getType()->getVectorElementType());
+
+    if (isa<UnreachableValue>(Vec))
+      return UnreachableValue::get(Vec->getType()->getVectorElementType());
   }
 
   // If extracting a specified index from the vector, see if we can recursively
   // find a previously computed scalar that was inserted into the vector.
   if (auto *IdxC = dyn_cast<ConstantInt>(Idx))
     if (Value *Elt = findScalarElement(Vec, IdxC->getZExtValue()))
       return Elt;
 

lib/AsmParser/LLLexer.cpp

#define KEYWORD(STR)                                                           \
   KEYWORD(extern_weak);
   KEYWORD(external);
   KEYWORD(thread_local);
   KEYWORD(localdynamic);
   KEYWORD(initialexec);
   KEYWORD(localexec);
   KEYWORD(zeroinitializer);
   KEYWORD(undef);
+  KEYWORD(unreachable);
   KEYWORD(null);
   KEYWORD(none);
   KEYWORD(to);
   KEYWORD(caller);
   KEYWORD(within);
   KEYWORD(from);
   KEYWORD(tail);
   KEYWORD(musttail);

lib/AsmParser/LLParser.h

namespace llvm {
   /// There are several cases where we have to parse the value but where the
   /// type can depend on later context.  This may either be a numeric reference
   /// or a symbolic (%var) reference.  This is just a discriminated union.
   struct ValID {
     enum {
       t_LocalID, t_GlobalID,           // ID in UIntVal.
       t_LocalName, t_GlobalName,       // Name in StrVal.
       t_APSInt, t_APFloat,             // Value in APSIntVal/APFloatVal.
-      t_Null, t_Undef, t_Zero, t_None, // No value.
+      t_Null, t_Unreachable, t_Undef, t_Zero, t_None,  // No value.
       t_EmptyArray,                    // No value:  []
       t_Constant,                      // Value in ConstantVal.
       t_InlineAsm,                     // Value in FTy/StrVal/StrVal2/UIntVal.
       t_ConstantStruct,                // Value in ConstantStructElts.
       t_PackedConstantStruct           // Value in ConstantStructElts.
     } Kind = t_LocalID;
 
     LLLexer::LocTy Loc;

lib/AsmParser/LLParser.cpp

case lltok::kw_true:
     ID.Kind = ValID::t_Constant;
     break;
   case lltok::kw_false:
     ID.ConstantVal = ConstantInt::getFalse(Context);
     ID.Kind = ValID::t_Constant;
     break;
   case lltok::kw_null: ID.Kind = ValID::t_Null; break;
   case lltok::kw_undef: ID.Kind = ValID::t_Undef; break;
+  case lltok::kw_unreachable: ID.Kind = ValID::t_Unreachable; break;
   case lltok::kw_zeroinitializer: ID.Kind = ValID::t_Zero; break;
   case lltok::kw_none: ID.Kind = ValID::t_None; break;
 
   case lltok::lbrace: {
     // ValID ::= '{' ConstVector '}'
     Lex.Lex();
     SmallVector<Constant*, 16> Elts;
     if (ParseGlobalValueVector(Elts) ||
case ValID::t_Null:
     V = ConstantPointerNull::get(cast<PointerType>(Ty));
     return false;
   case ValID::t_Undef:
     // FIXME: LabelTy should not be a first-class type.
     if (!Ty->isFirstClassType() || Ty->isLabelTy())
       return Error(ID.Loc, "invalid type for undef constant");
     V = UndefValue::get(Ty);
     return false;
+  case ValID::t_Unreachable:
+    // FIXME: LabelTy should not be a first-class type.
+    if (!Ty->isFirstClassType() || Ty->isLabelTy())
+      return Error(ID.Loc, "invalid type for unreachable constant");
+    V = UnreachableValue::get(Ty);
+    return false;
   case ValID::t_EmptyArray:
     if (!Ty->isArrayTy() || cast<ArrayType>(Ty)->getNumElements() != 0)
       return Error(ID.Loc, "invalid empty array initializer");
     V = UndefValue::get(Ty);
     return false;
   case ValID::t_Zero:
     // FIXME: LabelTy should not be a first-class type.
     if (!Ty->isFirstClassType() || Ty->isLabelTy())
bool LLParser::parseConstantValue(Type *Ty, Constant *&C) {
   ValID ID;
   auto Loc = Lex.getLoc();
   if (ParseValID(ID, /*PFS=*/nullptr))
     return true;
   switch (ID.Kind) {
   case ValID::t_APSInt:
   case ValID::t_APFloat:
   case ValID::t_Undef:
+  case ValID::t_Unreachable:
   case ValID::t_Constant:
   case ValID::t_ConstantStruct:
   case ValID::t_PackedConstantStruct: {
     Value *V;
     if (ConvertValIDToValue(Ty, ID, V, /*PFS=*/nullptr))
       return true;
     assert(isa<Constant>(V) && "Expected a constant value");
     C = cast<Constant>(V);

lib/Bitcode/Reader/BitcodeReader.cpp

case bitc::CST_CODE_BLOCKADDRESS:{
           FwdBBs.resize(BBID + 1);
         if (!FwdBBs[BBID])
           FwdBBs[BBID] = BasicBlock::Create(Context);
         BB = FwdBBs[BBID];
       }
       V = BlockAddress::get(Fn, BB);
       break;
     }
+    case bitc::CST_CODE_UNREACHABLE:
+      V = UnreachableValue::get(CurTy);
+      break;
     }
 
     ValueList.assignValue(V, NextCstNo);
     ++NextCstNo;
   }
 }
 
 std::error_code BitcodeReader::parseUseLists() {

lib/Bitcode/Writer/BitcodeWriter.cpp

for (unsigned i = FirstVal; i != LastVal; ++i) {
     }
     const Constant *C = cast<Constant>(V);
     unsigned Code = -1U;
     unsigned AbbrevToUse = 0;
     if (C->isNullValue()) {
       Code = bitc::CST_CODE_NULL;
     } else if (isa<UndefValue>(C)) {
       Code = bitc::CST_CODE_UNDEF;
+    } else if (isa<UnreachableValue>(C)) {
+      Code = bitc::CST_CODE_UNREACHABLE;
     } else if (const ConstantInt *IV = dyn_cast<ConstantInt>(C)) {
       if (IV->getBitWidth() <= 64) {
         uint64_t V = IV->getSExtValue();
         emitSignedInt64(Record, V);
         Code = bitc::CST_CODE_INTEGER;
         AbbrevToUse = CONSTANTS_INTEGER_ABBREV;
       } else {                             // Wide integers, > 64 bits in size.
         // We have an arbitrary precision integer value to write whose

lib/IR/AsmWriter.cpp

if (isa<ConstantTokenNone>(CV)) {
     return;
   }
 
   if (isa<UndefValue>(CV)) {
     Out << "undef";
     return;
   }
 
+  if (isa<UnreachableValue>(CV)) {
+    Out << "unreachable";
+    return;
+  }
+
   if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) {
     Out << CE->getOpcodeName();
     WriteOptimizationInfo(Out, CE);
     if (CE->isCompare())
       Out << ' ' << getPredicateText(CE->getPredicate());
     Out << " (";
 
     if (const GEPOperator *GEP = dyn_cast<GEPOperator>(CE)) {

lib/IR/ConstantFold.cpp

static Constant *getFoldedOffsetOf(Type *Ty, Constant *FieldNo,
   C = ConstantExpr::getCast(CastInst::getCastOpcode(C, false,
                                                     DestTy, false),
                             C, DestTy);
   return C;
 }
 
 Constant *llvm::ConstantFoldCastInstruction(unsigned opc, Constant *V,
                                             Type *DestTy) {
+  if (isa<UnreachableValue>(V))
+    return UnreachableValue::get(DestTy);
+
   if (isa<UndefValue>(V)) {
     // zext(undef) = 0, because the top bits will be zero.
     // sext(undef) = 0, because the top bits will all be the same.
     // [us]itofp(undef) = 0, because the result value is bounded.
     if (opc == Instruction::ZExt || opc == Instruction::SExt ||
         opc == Instruction::UIToFP || opc == Instruction::SIToFP)
       return Constant::getNullValue(DestTy);
     return UndefValue::get(DestTy);
for (unsigned i = 0, e = V1->getType()->getVectorNumElements(); i != e;++i){
                                                     ConstantInt::get(Ty, i));
       Constant *V2Element = ConstantExpr::getExtractElement(V2,
                                                     ConstantInt::get(Ty, i));
       Constant *Cond = dyn_cast<Constant>(CondV->getOperand(i));
       if (V1Element == V2Element) {
         V = V1Element;
       } else if (isa<UndefValue>(Cond)) {
         V = isa<UndefValue>(V1Element) ? V1Element : V2Element;
+      } else if (isa<UnreachableValue>(Cond)) {
+        return UnreachableValue::get(V1->getType());
       } else {
         if (!isa<ConstantInt>(Cond)) break;
         V = Cond->isNullValue() ? V2Element : V1Element;
       }
       Result.push_back(V);
     }
 
     // If we were able to build the vector, return it.
     if (Result.size() == V1->getType()->getVectorNumElements())
       return ConstantVector::get(Result);
   }
 
+  if (isa<UnreachableValue>(Cond)) {
+    return UnreachableValue::get(V1->getType());
+  }
   if (isa<UndefValue>(Cond)) {
-    if (isa<UndefValue>(V1)) return V1;
+    if (isa<UnreachableValue>(V2)) return V2;
+    if (isa<UndefValue>(V1) || isa<UnreachableValue>(V1)) return V1;
     return V2;
   }
-  if (isa<UndefValue>(V1)) return V2;
-  if (isa<UndefValue>(V2)) return V1;
+  if (isa<UnreachableValue>(V1) || isa<UndefValue>(V1)) return V2;
+  if (isa<UnreachableValue>(V2) || isa<UndefValue>(V2)) return V1;
   if (V1 == V2) return V1;
 
   if (ConstantExpr *TrueVal = dyn_cast<ConstantExpr>(V1)) {
     if (TrueVal->getOpcode() == Instruction::Select)
       if (TrueVal->getOperand(0) == Cond)
         return ConstantExpr::getSelect(Cond, TrueVal->getOperand(1), V2);
   }
   if (ConstantExpr *FalseVal = dyn_cast<ConstantExpr>(V2)) {
     if (FalseVal->getOpcode() == Instruction::Select)
       if (FalseVal->getOperand(0) == Cond)
         return ConstantExpr::getSelect(Cond, V1, FalseVal->getOperand(2));
   }
 
   return nullptr;
 }
 
 Constant *llvm::ConstantFoldExtractElementInstruction(Constant *Val,
                                                       Constant *Idx) {
+  // ee(unreachable, x) -> unreachable
+  // ee({w,x,y,z}, unreachable) -> unreachable
+  if (isa<UnreachableValue>(Val) || isa<UnreachableValue>(Idx))
+    return UnreachableValue::get(Val->getType()->getVectorElementType());
   if (isa<UndefValue>(Val))  // ee(undef, x) -> undef
     return UndefValue::get(Val->getType()->getVectorElementType());
   if (Val->isNullValue())  // ee(zero, x) -> zero
     return Constant::getNullValue(Val->getType()->getVectorElementType());
   // ee({w,x,y,z}, undef) -> undef
   if (isa<UndefValue>(Idx))
     return UndefValue::get(Val->getType()->getVectorElementType());
 
   if (ConstantInt *CIdx = dyn_cast<ConstantInt>(Idx)) {
     // ee({w,x,y,z}, wrong_value) -> undef
     if (CIdx->uge(Val->getType()->getVectorNumElements()))
       return UndefValue::get(Val->getType()->getVectorElementType());
     return Val->getAggregateElement(CIdx->getZExtValue());
   }
   return nullptr;
 }
 
 Constant *llvm::ConstantFoldInsertElementInstruction(Constant *Val,
                                                      Constant *Elt,
                                                      Constant *Idx) {
+  if (isa<UnreachableValue>(Val) || isa<UnreachableValue>(Elt) ||
+      isa<UnreachableValue>(Idx))
+    return UnreachableValue::get(Val->getType());
+
   if (isa<UndefValue>(Idx))
     return UndefValue::get(Val->getType());
 
   ConstantInt *CIdx = dyn_cast<ConstantInt>(Idx);
   if (!CIdx) return nullptr;
 
   unsigned NumElts = Val->getType()->getVectorNumElements();
   if (CIdx->uge(NumElts))
Constant *llvm::ConstantFoldShuffleVectorInstruction(Constant *V1,
                                                      Constant *Mask) {
   unsigned MaskNumElts = Mask->getType()->getVectorNumElements();
   Type *EltTy = V1->getType()->getVectorElementType();
 
   // Undefined shuffle mask -> undefined value.
   if (isa<UndefValue>(Mask))
     return UndefValue::get(VectorType::get(EltTy, MaskNumElts));
 
+  // Unreachable shuffle mask -> unreachable value.
+  if (isa<UnreachableValue>(Mask))
+    return UnreachableValue::get(VectorType::get(EltTy, MaskNumElts));
+
   // Don't break the bitcode reader hack.
   if (isa<ConstantExpr>(Mask)) return nullptr;
 
   unsigned SrcNumElts = V1->getType()->getVectorNumElements();
 
   // Loop over the shuffle mask, evaluating each element.
   SmallVector<Constant*, 32> Result;
   for (unsigned i = 0; i != MaskNumElts; ++i) {
     int Elt = ShuffleVectorInst::getMaskValue(Mask, i);
     if (Elt == -1) {
       Result.push_back(UndefValue::get(EltTy));
       continue;
     }
     Constant *InElt;
     if (unsigned(Elt) >= SrcNumElts*2)
       InElt = UndefValue::get(EltTy);
     else if (unsigned(Elt) >= SrcNumElts) {
       Type *Ty = IntegerType::get(V2->getContext(), 32);
       InElt =
         ConstantExpr::getExtractElement(V2,
                                         ConstantInt::get(Ty, Elt - SrcNumElts));
+      if (isa<UnreachableValue>(InElt))
+        return UnreachableValue::get(VectorType::get(EltTy, MaskNumElts));
     } else {
       Type *Ty = IntegerType::get(V1->getContext(), 32);
       InElt = ConstantExpr::getExtractElement(V1, ConstantInt::get(Ty, Elt));
+      if (isa<UnreachableValue>(InElt))
+        return UnreachableValue::get(VectorType::get(EltTy, MaskNumElts));
     }
     Result.push_back(InElt);
   }
 
   return ConstantVector::get(Result);
 }
 
 Constant *llvm::ConstantFoldExtractValueInstruction(Constant *Agg,
Constant *llvm::ConstantFoldInsertValueInstruction(Constant *Agg,
   return ConstantVector::get(Result);
 }
 
 
 Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode,
                                               Constant *C1, Constant *C2) {
   assert(Instruction::isBinaryOp(Opcode) && "Non-binary instruction detected");
 
+  // Handle UnreachableValue now to make the rest of the function easier.
+  if (isa<UnreachableValue>(C1))
+    return C1;
+  if (isa<UnreachableValue>(C2))
+    return C2;
+
   // Handle UndefValue up front.
   if (isa<UndefValue>(C1) || isa<UndefValue>(C2)) {
     switch (static_cast<Instruction::BinaryOps>(Opcode)) {
     case Instruction::Xor:
       if (isa<UndefValue>(C1) && isa<UndefValue>(C2))
         // Handle undef ^ undef -> 0 special case. This is a common
         // idiom (misuse).
         return Constant::getNullValue(C1->getType());
case Instruction::Mul: {
         if ((*CV)[0])
           return UndefValue::get(C1->getType());
 
       // X * undef -> 0       otherwise
       return Constant::getNullValue(C1->getType());
     }
     case Instruction::SDiv:
     case Instruction::UDiv:
-      // X / undef -> undef
-      if (isa<UndefValue>(C2))
-        return C2;
-      // undef / 0 -> undef
+      // X / undef -> unreachable
+      // undef / 0 -> unreachable
+      if (isa<UndefValue>(C2) || match(C2, m_Zero()))
+        return UnreachableValue::get(C1->getType());
       // undef / 1 -> undef
-      if (match(C2, m_Zero()) || match(C2, m_One()))
+      if (match(C2, m_One()))
         return C1;
       // undef / X -> 0       otherwise
       return Constant::getNullValue(C1->getType());
     case Instruction::URem:
     case Instruction::SRem:
-      // X % undef -> undef
+      // X % undef -> unreachable
+      // undef % 0 -> unreachable
       if (match(C2, m_Undef()))
-        return C2;
-      // undef % 0 -> undef
-      if (match(C2, m_Zero()))
-        return C1;
+        return UnreachableValue::get(C1->getType());
       // undef % X -> 0       otherwise
       return Constant::getNullValue(C1->getType());
     case Instruction::Or:                          // X | undef -> -1
       if (isa<UndefValue>(C1) && isa<UndefValue>(C2)) // undef | undef -> undef
         return C1;
       return Constant::getAllOnesValue(C1->getType()); // undef | X -> ~0
     case Instruction::LShr:
       // X >>l undef -> undef
if (ConstantInt *CI2 = dyn_cast<ConstantInt>(C2)) {
     case Instruction::Mul:
       if (CI2->equalsInt(0)) return C2;                         // X * 0 == 0
       if (CI2->equalsInt(1))
         return C1;                                              // X * 1 == X
       break;
     case Instruction::UDiv:
     case Instruction::SDiv:
       if (CI2->equalsInt(1))
-        return C1;                                            // X / 1 == X
+        return C1;                                      // X / 1 == X
       if (CI2->equalsInt(0))
-        return UndefValue::get(CI2->getType());               // X / 0 == undef
+        return UnreachableValue::get(CI2->getType());   // X / 0 == unreachable
       break;
     case Instruction::URem:
     case Instruction::SRem:
       if (CI2->equalsInt(1))
-        return Constant::getNullValue(CI2->getType());        // X % 1 == 0
+        return Constant::getNullValue(CI2->getType());  // X % 1 == 0
       if (CI2->equalsInt(0))
-        return UndefValue::get(CI2->getType());               // X % 0 == undef
+        return UnreachableValue::get(CI2->getType());   // X % 0 == unreachable
       break;
     case Instruction::And:
       if (CI2->isZero()) return C2;                           // X & 0 == 0
       if (CI2->isAllOnesValue())
         return C1;                                            // X & -1 == X
 
       if (ConstantExpr *CE1 = dyn_cast<ConstantExpr>(C1)) {
         // (zext i32 to i64) & 4294967295 -> (zext i32 to i64)
case Instruction::AShr:
       break;
     }
   } else if (isa<ConstantInt>(C1)) {
     // If C1 is a ConstantInt and C2 is not, swap the operands.
     if (Instruction::isCommutative(Opcode))
       return ConstantExpr::get(Opcode, C2, C1);
   }
 
+  // At this point we know neither constant is an UndefValue or an
+  // UnreachableValue.
   if (ConstantInt *CI1 = dyn_cast<ConstantInt>(C1)) {
     if (ConstantInt *CI2 = dyn_cast<ConstantInt>(C2)) {
       const APInt &C1V = CI1->getValue();
       const APInt &C2V = CI2->getValue();
       switch (Opcode) {
       default:
         break;
       case Instruction::Add:
         return ConstantInt::get(CI1->getContext(), C1V + C2V);
       case Instruction::Sub:
         return ConstantInt::get(CI1->getContext(), C1V - C2V);
       case Instruction::Mul:
         return ConstantInt::get(CI1->getContext(), C1V * C2V);
       case Instruction::UDiv:
         assert(!CI2->isNullValue() && "Div by zero handled above");
         return ConstantInt::get(CI1->getContext(), C1V.udiv(C2V));
       case Instruction::SDiv:
         assert(!CI2->isNullValue() && "Div by zero handled above");
+        // MIN_INT / -1 -> unreachable
         if (C2V.isAllOnesValue() && C1V.isMinSignedValue())
-          return UndefValue::get(CI1->getType());   // MIN_INT / -1 -> undef
+          return UnreachableValue::get(CI1->getType());
         return ConstantInt::get(CI1->getContext(), C1V.sdiv(C2V));
       case Instruction::URem:
         assert(!CI2->isNullValue() && "Div by zero handled above");
         return ConstantInt::get(CI1->getContext(), C1V.urem(C2V));
       case Instruction::SRem:
         assert(!CI2->isNullValue() && "Div by zero handled above");
+        // MIN_INT % -1 -> undef
         if (C2V.isAllOnesValue() && C1V.isMinSignedValue())
-          return UndefValue::get(CI1->getType());   // MIN_INT % -1 -> undef
+          return UnreachableValue::get(CI1->getType());
         return ConstantInt::get(CI1->getContext(), C1V.srem(C2V));
       case Instruction::And:
         return ConstantInt::get(CI1->getContext(), C1V & C2V);
       case Instruction::Or:
         return ConstantInt::get(CI1->getContext(), C1V | C2V);
       case Instruction::Xor:
         return ConstantInt::get(CI1->getContext(), C1V ^ C2V);
       case Instruction::Shl:
Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred,
   // Fold FCMP_FALSE/FCMP_TRUE unconditionally.
   if (pred == FCmpInst::FCMP_FALSE)
     return Constant::getNullValue(ResultTy);
 
   if (pred == FCmpInst::FCMP_TRUE)
     return Constant::getAllOnesValue(ResultTy);
 
   // Handle some degenerate cases first
+  if (isa<UnreachableValue>(C1) || isa<UnreachableValue>(C2))
+    return UnreachableValue::get(ResultTy);
+
   if (isa<UndefValue>(C1) || isa<UndefValue>(C2)) {
     CmpInst::Predicate Predicate = CmpInst::Predicate(pred);
     bool isIntegerPredicate = ICmpInst::isIntPredicate(Predicate);
     // For EQ and NE, we can always pick a value for the undef to make the
     // predicate pass or fail, so we can return undef.
     // Also, if both operands are undef, we can return undef for int comparison.
     if (ICmpInst::isEquality(Predicate) || (isIntegerPredicate && C1 == C2))
       return UndefValue::get(ResultTy);

 static Constant *ConstantFoldGetElementPtrImpl(Type *PointeeTy, Constant *C,
                                                bool inBounds,
                                                ArrayRef<IndexTy> Idxs) {
   if (Idxs.empty()) return C;
   Constant *Idx0 = cast<Constant>(Idxs[0]);
   if ((Idxs.size() == 1 && Idx0->isNullValue()))
     return C;
 
-  if (isa<UndefValue>(C)) {
+  if (isa<UnreachableValue>(C) || isa<UndefValue>(C)) {
     PointerType *PtrTy = cast<PointerType>(C->getType()->getScalarType());
     Type *Ty = GetElementPtrInst::getIndexedType(PointeeTy, Idxs);
     assert(Ty && "Invalid indices for GEP!");
     Type *GEPTy = PointerType::get(Ty, PtrTy->getAddressSpace());
     if (VectorType *VT = dyn_cast<VectorType>(C->getType()))
       GEPTy = VectorType::get(GEPTy, VT->getNumElements());
+    if (isa<UnreachableValue>(C))
+      return UnreachableValue::get(GEPTy);
     return UndefValue::get(GEPTy);
   }
 
   if (C->isNullValue()) {
     bool isNull = true;
     for (unsigned i = 0, e = Idxs.size(); i != e; ++i)
       if (!cast<Constant>(Idxs[i])->isNullValue()) {
         isNull = false;

lib/IR/Constants.cpp

if (const ConstantVector *CV = dyn_cast<ConstantVector>(this))
     return Elt < CV->getNumOperands() ? CV->getOperand(Elt) : nullptr;
 
   if (const ConstantAggregateZero *CAZ = dyn_cast<ConstantAggregateZero>(this))
     return Elt < CAZ->getNumElements() ? CAZ->getElementValue(Elt) : nullptr;
 
   if (const UndefValue *UV = dyn_cast<UndefValue>(this))
     return Elt < UV->getNumElements() ? UV->getElementValue(Elt) : nullptr;
 
+  if (const UnreachableValue *UV = dyn_cast<UnreachableValue>(this))
+    return Elt < UV->getNumElements() ? UV->getElementValue(Elt) : nullptr;
+
   if (const ConstantDataSequential *CDS =dyn_cast<ConstantDataSequential>(this))
     return Elt < CDS->getNumElements() ? CDS->getElementAsConstant(Elt)
                                        : nullptr;
   return nullptr;
 }
 
 Constant *Constant::getAggregateElement(Constant *Elt) const {
   assert(isa<IntegerType>(Elt->getType()) && "Index must be an integer");
unsigned UndefValue::getNumElements() const {
   if (auto *AT = dyn_cast<ArrayType>(Ty))
     return AT->getNumElements();
   if (auto *VT = dyn_cast<VectorType>(Ty))
     return VT->getNumElements();
   return Ty->getStructNumElements();
 }
 
 //===----------------------------------------------------------------------===//
+//                      UnreachableValue Implementation
+//===----------------------------------------------------------------------===//
+
+/// getSequentialElement - If this unreachable has array or vector type,
+/// return an unreachable with the right element type.
+UnreachableValue *UnreachableValue::getSequentialElement() const {
+  return UnreachableValue::get(getType()->getSequentialElementType());
+}
+
+/// getStructElement - If this unreachable has struct type, return a zero with
+/// the right element type for the specified element.
+UnreachableValue *UnreachableValue::getStructElement(unsigned Elt) const {
+  return UnreachableValue::get(getType()->getStructElementType(Elt));
+}
+
+/// getElementValue - Return an unreachable of the right value for the specified
+/// GEP index if we can, otherwise return null (e.g. if C is a ConstantExpr).
+UnreachableValue *UnreachableValue::getElementValue(Constant *C) const {
+  if (isa<SequentialType>(getType()))
+    return getSequentialElement();
+  return getStructElement(cast<ConstantInt>(C)->getZExtValue());
+}
+
+/// getElementValue - Return an unreachable of the right value for the specified
+/// GEP index.
+UnreachableValue *UnreachableValue::getElementValue(unsigned Idx) const {
+  if (isa<SequentialType>(getType()))
+    return getSequentialElement();
+  return getStructElement(Idx);
+}
+
+unsigned UnreachableValue::getNumElements() const {
+  Type *Ty = getType();
+  if (auto *AT = dyn_cast<ArrayType>(Ty))
+    return AT->getNumElements();
+  if (auto *VT = dyn_cast<VectorType>(Ty))
+    return VT->getNumElements();
+  return Ty->getStructNumElements();
+}
+
+//===----------------------------------------------------------------------===//
 //                            ConstantXXX Classes
 //===----------------------------------------------------------------------===//
 
 template <typename ItTy, typename EltTy>
 static bool rangeOnlyContains(ItTy Start, ItTy End, EltTy Elt) {
   for (; Start != End; ++Start)
     if (*Start != Elt)
       return false;
if (V.empty())
     return ConstantAggregateZero::get(Ty);
 
   for (unsigned i = 0, e = V.size(); i != e; ++i) {
     assert(V[i]->getType() == Ty->getElementType() &&
            "Wrong type in array element initializer");
   }
 
   // If this is an all-zero array, return a ConstantAggregateZero object.  If
-  // all undef, return an UndefValue, if "all simple", then return a
-  // ConstantDataArray.
+  // all unreachable, return an UnreachableValue, if all undef, return an
+  // UndefValue. If "all simple", then return a ConstantDataArray.
   Constant *C = V[0];
+  if (isa<UnreachableValue>(C) && rangeOnlyContains(V.begin(), V.end(), C))
+    return UnreachableValue::get(Ty);
+
   if (isa<UndefValue>(C) && rangeOnlyContains(V.begin(), V.end(), C))
     return UndefValue::get(Ty);
 
   if (C->isNullValue() && rangeOnlyContains(V.begin(), V.end(), C))
     return ConstantAggregateZero::get(Ty);
 
   // Check to see if all of the elements are ConstantFP or ConstantInt and if
   // the element type is compatible with ConstantDataVector.  If so, use it.

 // ConstantStruct accessors.
 Constant *ConstantStruct::get(StructType *ST, ArrayRef<Constant*> V) {
   assert((ST->isOpaque() || ST->getNumElements() == V.size()) &&
          "Incorrect # elements specified to ConstantStruct::get");
 
   // Create a ConstantAggregateZero value if all elements are zeros.
   bool isZero = true;
   bool isUndef = false;
+  bool isUnreachable = false;
   
   if (!V.empty()) {
+    isUnreachable = isa<UnreachableValue>(V[0]);
     isUndef = isa<UndefValue>(V[0]);
     isZero = V[0]->isNullValue();
     if (isUndef || isZero) {
       for (unsigned i = 0, e = V.size(); i != e; ++i) {
         if (!V[i]->isNullValue())
           isZero = false;
         if (!isa<UndefValue>(V[i]))
           isUndef = false;
+        if (!isa<UnreachableValue>(V[i]))
+          isUnreachable = false;
       }
     }
   }
   if (isZero)
     return ConstantAggregateZero::get(ST);
   if (isUndef)
     return UndefValue::get(ST);
+  if (isUnreachable)
+    return UnreachableValue::get(ST);
 
   return ST->getContext().pImpl->StructConstants.getOrCreate(ST, V);
 }
 
 Constant *ConstantStruct::get(StructType *T, ...) {
   va_list ap;
   SmallVector<Constant*, 8> Values;
   va_start(ap, T);
Constant *ConstantVector::get(ArrayRef<Constant*> V) {
   VectorType *Ty = VectorType::get(V.front()->getType(), V.size());
   return Ty->getContext().pImpl->VectorConstants.getOrCreate(Ty, V);
 }
 
 Constant *ConstantVector::getImpl(ArrayRef<Constant*> V) {
   assert(!V.empty() && "Vectors can't be empty");
   VectorType *T = VectorType::get(V.front()->getType(), V.size());
 
-  // If this is an all-undef or all-zero vector, return a
-  // ConstantAggregateZero or UndefValue.
+  // If this is an all-unreachable, all-undef or all-zero vector, return a
+  // UnreachableValue, UndefValue or ConstantAggregateZero.
   Constant *C = V[0];
   bool isZero = C->isNullValue();
   bool isUndef = isa<UndefValue>(C);
+  bool isUnreachable = isa<UnreachableValue>(C);
 
-  if (isZero || isUndef) {
+  if (isZero || isUndef || isUnreachable) {
     for (unsigned i = 1, e = V.size(); i != e; ++i)
       if (V[i] != C) {
-        isZero = isUndef = false;
+        isZero = isUndef = isUnreachable = false;
         break;
       }
   }
 
   if (isZero)
     return ConstantAggregateZero::get(T);
   if (isUndef)
     return UndefValue::get(T);
+  if (isUnreachable)
+    return UnreachableValue::get(T);
 
   // Check to see if all of the elements are ConstantFP or ConstantInt and if
   // the element type is compatible with ConstantDataVector.  If so, use it.
   if (ConstantDataSequential::isElementTypeCompatible(C->getType()))
     return getSequenceIfElementsMatch<ConstantDataVector>(C, V);
 
   // Otherwise, the element type isn't compatible with ConstantDataVector, or
   // the operand list constants a ConstantExpr or something else strange.

 
 // destroyConstant - Remove the constant from the constant table.
 //
 void UndefValue::destroyConstantImpl() {
   // Free the constant and any dangling references to it.
   getContext().pImpl->UVConstants.erase(getType());
 }
 
+//---- UnreachableValue::get() implementation.
+//
+
+UnreachableValue *UnreachableValue::get(Type *Ty) {
+  UnreachableValue *&Entry = Ty->getContext().pImpl->URVConstants[Ty];
+  if (!Entry)
+    Entry = new UnreachableValue(Ty);
+
+  return Entry;
+}
+
+// destroyConstant - Remove the constant from the constant table.
+//
+void UnreachableValue::destroyConstantImpl() {
+  // Free the constant and any dangling references to it.
+  getContext().pImpl->URVConstants.erase(getType());
+}
+
 //---- BlockAddress::get() implementation.
 //
 
 BlockAddress *BlockAddress::get(BasicBlock *BB) {
   assert(BB->getParent() && "Block must have a parent");
   return get(BB->getParent(), BB);
 }
 
Value *ConstantArray::handleOperandChangeImpl(Value *From, Value *To) {
   }
 
   if (AllSame && ToC->isNullValue())
     return ConstantAggregateZero::get(getType());
 
   if (AllSame && isa<UndefValue>(ToC))
     return UndefValue::get(getType());
 
+  if (AllSame && isa<UnreachableValue>(ToC))
+    return UnreachableValue::get(getType());
+
   // Check for any other type of constant-folding.
   if (Constant *C = getImpl(getType(), Values))
     return C;
 
   // Update to the new value.
   return getContext().pImpl->ArrayConstants.replaceOperandsInPlace(
       Values, this, From, ToC, NumUpdated, OperandNo);
 }
Value *ConstantStruct::handleOperandChangeImpl(Value *From, Value *To) {
   }
 
   if (AllSame && ToC->isNullValue())
     return ConstantAggregateZero::get(getType());
 
   if (AllSame && isa<UndefValue>(ToC))
     return UndefValue::get(getType());
 
+  if (AllSame && isa<UnreachableValue>(ToC))
+    return UnreachableValue::get(getType());
+
   // Update to the new value.
   return getContext().pImpl->StructConstants.replaceOperandsInPlace(
       Values, this, From, ToC, NumUpdated, OperandNo);
 }
 
 Value *ConstantVector::handleOperandChangeImpl(Value *From, Value *To) {
   assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
   Constant *ToC = cast<Constant>(To);

lib/IR/LLVMContextImpl.h

#include "llvm/IR/Metadata.def"
   StructConstantsTy StructConstants;
   
   typedef ConstantUniqueMap<ConstantVector> VectorConstantsTy;
   VectorConstantsTy VectorConstants;
   
   DenseMap<PointerType*, ConstantPointerNull*> CPNConstants;
 
   DenseMap<Type*, UndefValue*> UVConstants;
-  
+  DenseMap<Type*, UnreachableValue*> URVConstants;
+  
   StringMap<ConstantDataSequential*> CDSConstants;
 
   DenseMap<std::pair<const Function *, const BasicBlock *>, BlockAddress *>
     BlockAddresses;
   ConstantUniqueMap<ConstantExpr> ExprConstants;
 
   ConstantUniqueMap<InlineAsm> InlineAsms;
 

lib/IR/LLVMContextImpl.cpp

std::for_each(VectorConstants.map_begin(), VectorConstants.map_end(),
                 DropFirst());
   ExprConstants.freeConstants();
   ArrayConstants.freeConstants();
   StructConstants.freeConstants();
   VectorConstants.freeConstants();
   DeleteContainerSeconds(CAZConstants);
   DeleteContainerSeconds(CPNConstants);
   DeleteContainerSeconds(UVConstants);
+  DeleteContainerSeconds(URVConstants);
   InlineAsms.freeConstants();
   DeleteContainerSeconds(IntConstants);
   DeleteContainerSeconds(FPConstants);
   
   for (StringMap<ConstantDataSequential*>::iterator I = CDSConstants.begin(),
        E = CDSConstants.end(); I != E; ++I)
     delete I->second;
   CDSConstants.clear();

lib/Transforms/Scalar/SCCP.cpp

enum LatticeValueTy {
     constant,
 
     /// forcedconstant - This LLVM Value was thought to be undef until
     /// ResolvedUndefsIn.  This is treated just like 'constant', but if merged
     /// with another (different) constant, it goes to overdefined, instead of
     /// asserting.
     forcedconstant,
 
-    /// overdefined - This instruction is not known to be constant, and we know
+    /// overdefined - This LLVM Value is not known to be constant, and we know
     /// it has a value.
     overdefined
   };
 
   /// Val: This stores the current lattice value along with the Constant* for
   /// the constant if this is a 'constant' or 'forcedconstant' value.
   PointerIntPair<Constant *, 2, LatticeValueTy> Val;
 

 }
 
 void SCCPSolver::visitSelectInst(SelectInst &I) {
   // If this select returns a struct, just mark the result overdefined.
   // TODO: We could do a lot better than this if code actually uses this.
   if (I.getType()->isStructTy())
     return markAnythingOverdefined(&I);
 
+  LatticeVal &IV = ValueState[&I];
+  if (IV.isOverdefined()) return;
+
   LatticeVal CondValue = getValueState(I.getCondition());
   if (CondValue.isUndefined())
     return;
 
   if (ConstantInt *CondCB = CondValue.getConstantInt()) {
     Value *OpVal = CondCB->isZero() ? I.getFalseValue() : I.getTrueValue();
     mergeInValue(&I, getValueState(OpVal));
     return;
   }
 
+  if (CondValue.isConstant() && isa<UnreachableValue>(CondValue.getConstant()))
+    return markConstant(&I, UnreachableValue::get(I.getType()));
+
   // Otherwise, the condition is overdefined or a constant we can't evaluate.
   // See if we can produce something better than overdefined based on the T/F
   // value.
   LatticeVal TVal = getValueState(I.getTrueValue());
   LatticeVal FVal = getValueState(I.getFalseValue());
 
   // select ?, C, C -> C.
   if (TVal.isConstant() && FVal.isConstant() &&
for (Instruction &I : *BB) {
         }
         // undef ^ X -> undef
         break;
 
       case Instruction::SDiv:
       case Instruction::UDiv:
       case Instruction::SRem:
       case Instruction::URem:
-        // X / undef -> undef.  No change.
-        // X % undef -> undef.  No change.
-        if (Op1LV.isUndefined()) break;
-
-        // X / 0 -> undef.  No change.
-        // X % 0 -> undef.  No change.
-        if (Op1LV.isConstant() && Op1LV.getConstant()->isZeroValue())
-          break;
+        // X / undef -> unreachable.
+        // X % undef -> unreachable.
+        // X / 0 -> unreachable.
+        // X % 0 -> unreachable.
+        if (Op1LV.isUndefined() || (Op1LV.isConstant() && Op1LV.getConstant()->isZeroValue())) {
+          markForcedConstant(&I, UnreachableValue::get(ITy));
+          return true;
+        }
 
         // undef / X -> 0.   X could be maxint.
         // undef % X -> 0.   X could be 1.
         markForcedConstant(&I, Constant::getNullValue(ITy));
         return true;
 
       case Instruction::AShr:
         // X >>a undef -> undef.

lib/Transforms/Utils/SimplifyCFG.cpp

while(!DFT.empty()) {
       CompValue = nullptr;
       break;
     }
   }
 };
 
 }
 
-static void EraseTerminatorInstAndDCECond(TerminatorInst *TI) {
-  Instruction *Cond = nullptr;
+static void EraseTerminatorInstAndDCE(TerminatorInst *TI) {
+  Instruction *Op = nullptr;
   if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) {
-    Cond = dyn_cast<Instruction>(SI->getCondition());
+    Op = dyn_cast<Instruction>(SI->getCondition());
   } else if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
     if (BI->isConditional())
-      Cond = dyn_cast<Instruction>(BI->getCondition());
+      Op = dyn_cast<Instruction>(BI->getCondition());
   } else if (IndirectBrInst *IBI = dyn_cast<IndirectBrInst>(TI)) {
-    Cond = dyn_cast<Instruction>(IBI->getAddress());
+    Op = dyn_cast<Instruction>(IBI->getAddress());
+  } else if (ReturnInst *RI = dyn_cast<ReturnInst>(TI)) {
+    Op = dyn_cast_or_null<Instruction>(RI->getReturnValue());
   }
 
   TI->eraseFromParent();
-  if (Cond) RecursivelyDeleteTriviallyDeadInstructions(Cond);
+  if (Op) RecursivelyDeleteTriviallyDeadInstructions(Op);
 }
 
 /// Return true if the specified terminator checks
 /// to see if a value is equal to constant integer value.
 Value *SimplifyCFGOpt::isValueEqualityComparison(TerminatorInst *TI) {
   Value *CV = nullptr;
   if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) {
     // Do not permit merging of large switch instructions into their
if (isa<BranchInst>(TI)) {
       (void) NI;
 
       // Remove PHI node entries for the dead edge.
       ThisCases[0].Dest->removePredecessor(TI->getParent());
 
       DEBUG(dbgs() << "Threading pred instr: " << *Pred->getTerminator()
            << "Through successor TI: " << *TI << "Leaving: " << *NI << "\n");
 
-      EraseTerminatorInstAndDCECond(TI);
+      EraseTerminatorInstAndDCE(TI);
       return true;
     }
 
     SwitchInst *SI = cast<SwitchInst>(TI);
     // Okay, TI has cases that are statically dead, prune them away.
     SmallPtrSet<Constant*, 16> DeadCases;
     for (unsigned i = 0, e = PredCases.size(); i != e; ++i)
       DeadCases.insert(PredCases[i].Value);
SimplifyEqualityComparisonWithOnlyPredecessor(TerminatorInst *TI,
 
   // Insert the new branch.
   Instruction *NI = Builder.CreateBr(TheRealDest);
   (void) NI;
 
   DEBUG(dbgs() << "Threading pred instr: " << *Pred->getTerminator()
             << "Through successor TI: " << *TI << "Leaving: " << *NI << "\n");
 
-  EraseTerminatorInstAndDCECond(TI);
+  EraseTerminatorInstAndDCE(TI);
   return true;
 }
 
 namespace {
   /// This class implements a stable ordering of constant
   /// integers that does not depend on their address.  This is important for
   /// applications that sort ConstantInt's to ensure uniqueness.
   struct ConstantIntOrdering {
if (PCV == CV && SafeToMergeTerminators(TI, PTI)) {
 
         SmallVector<uint32_t, 8> MDWeights(Weights.begin(), Weights.end());
 
         NewSI->setMetadata(LLVMContext::MD_prof,
                            MDBuilder(BB->getContext()).
                            createBranchWeights(MDWeights));
       }
 
-      EraseTerminatorInstAndDCECond(PTI);
+      EraseTerminatorInstAndDCE(PTI);
 
       // Okay, last check.  If BB is still a successor of PSI, then we must
       // have an infinite loop case.  If so, add an infinitely looping block
       // to handle the case to preserve the behavior of the code.
       BasicBlock *InfLoopBlock = nullptr;
       for (unsigned i = 0, e = NewSI->getNumSuccessors(); i != e; ++i)
         if (NewSI->getSuccessor(i) == BB) {
           if (!InfLoopBlock) {
for (BasicBlock::iterator BBI = Succ->begin();
           PN->setIncomingValue(i, SI);
     }
   }
 
   // Update any PHI nodes in our new successors.
   for (BasicBlock *Succ : successors(BB1))
     AddPredecessorToBlock(Succ, BIParent, BB1);
 
-  EraseTerminatorInstAndDCECond(BI);
+  EraseTerminatorInstAndDCE(BI);
   return true;
 }
 
 /// Given an unconditional branch that goes to BBEnd,
 /// check whether BBEnd has only two predecessors and the other predecessor
 /// ends with an unconditional branch. If it is true, sink any common code
 /// in the two predecessors to BBEnd.
 static bool SinkThenElseCodeToEnd(BranchInst *BI1) {
static bool SimplifyCondBranchToTwoReturns(BranchInst *BI,
   Builder.SetInsertPoint(BI);
   // Okay, we found a branch that is going to two return nodes.  If
   // there is no return value for this function, just change the
   // branch into a return.
   if (FalseRet->getNumOperands() == 0) {
     TrueSucc->removePredecessor(BI->getParent());
     FalseSucc->removePredecessor(BI->getParent());
     Builder.CreateRetVoid();
-    EraseTerminatorInstAndDCECond(BI);
+    EraseTerminatorInstAndDCE(BI);
     return true;
   }
 
   // Otherwise, figure out what the true and false return values are
   // so we can insert a new select instruction.
   Value *TrueValue = TrueRet->getReturnValue();
   Value *FalseValue = FalseRet->getReturnValue();
 
Value *RI = !TrueValue ?
     Builder.CreateRetVoid() : Builder.CreateRet(TrueValue);
 
   (void) RI;
 
   DEBUG(dbgs() << "\nCHANGING BRANCH TO TWO RETURNS INTO SELECT:"
                << "\n  " << *BI << "NewRet = " << *RI
                << "TRUEBLOCK: " << *TrueSucc << "FALSEBLOCK: "<< *FalseSucc);
 
-  EraseTerminatorInstAndDCECond(BI);
+  EraseTerminatorInstAndDCE(BI);
 
   return true;
 }
 
 /// Given a conditional BranchInstruction, retrieve the probabilities of the
 /// branch taking each edge. Fills in the two APInt parameters and returns true,
 /// or returns false if no or invalid metadata was found.
 static bool ExtractBranchMetadata(BranchInst *BI,
if (BI->isConditional()) {
           }
         }
         // Update PHI Node.
         PHIs[i]->setIncomingValue(PHIs[i]->getBasicBlockIndex(PBI->getParent()),
                                   MergedCond);
       }
       // Change PBI from Conditional to Unconditional.
       BranchInst *New_PBI = BranchInst::Create(TrueDest, PBI);
-      EraseTerminatorInstAndDCECond(PBI);
+      EraseTerminatorInstAndDCE(PBI);
       PBI = New_PBI;
     }
 
     // TODO: If BB is reachable from all paths through PredBlock, then we
     // could replace PBI's branch probabilities with BI's.
 
     // Copy any debug value intrinsics into the end of PredBlock.
     for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I)
if (!KeepEdge1 && !KeepEdge2) {
     if (!KeepEdge1)
       // Only TrueBB was found.
       Builder.CreateBr(TrueBB);
     else
       // Only FalseBB was found.
       Builder.CreateBr(FalseBB);
   }
 
-  EraseTerminatorInstAndDCECond(OldTerm);
+  EraseTerminatorInstAndDCE(OldTerm);
   return true;
 }
 
 // Replaces
 //   (switch (select cond, X, Y)) on constant X, Y
 // with a branch - conditional if X and Y lead to distinct BBs,
 // unconditional otherwise.
 static bool SimplifySwitchOnSelect(SwitchInst *SI, SelectInst *Select) {
for (BasicBlock::iterator BBI = EdgeBB->begin();
        isa<PHINode>(BBI); ++BBI) {
     PHINode *PN = cast<PHINode>(BBI);
     Value *InVal = PN->getIncomingValueForBlock(BB);
     for (unsigned i = 0, e = Values.size()-1; i != e; ++i)
       PN->addIncoming(InVal, BB);
   }
 
   // Erase the old branch instruction.
-  EraseTerminatorInstAndDCECond(BI);
+  EraseTerminatorInstAndDCE(BI);
 
   DEBUG(dbgs() << "  ** 'icmp' chain result is:\n" << *BB << '\n');
   return true;
 }
 
 bool SimplifyCFGOpt::SimplifyResume(ResumeInst *RI, IRBuilder<> &Builder) {
   if (isa<PHINode>(RI->getValue()))
     return SimplifyCommonResume(RI);
bool SimplifyCFGOpt::SimplifyCleanupReturn(CleanupReturnInst *RI) {
   if (mergeCleanupPad(RI))
     return true;
 
   return false;
 }
 
 bool SimplifyCFGOpt::SimplifyReturn(ReturnInst *RI, IRBuilder<> &Builder) {
   BasicBlock *BB = RI->getParent();
+
+  if (RI->getReturnValue() && isa<UnreachableValue>(RI->getReturnValue())) {
+    new UnreachableInst(RI->getContext(), BB);
+    EraseTerminatorInstAndDCE(RI);
+    return true;
+  }
+
   if (!BB->getFirstNonPHIOrDbg()->isTerminator()) return false;
 
   // Find predecessors that end with branches.
   SmallVector<BasicBlock*, 8> UncondBranchPreds;
   SmallVector<BranchInst*, 8> CondBranchPreds;
   for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) {
     BasicBlock *P = *PI;
     TerminatorInst *PTI = P->getTerminator();
if (auto *BI = dyn_cast<BranchInst>(TI)) {
         if (BI->getSuccessor(0) == BB) {
           new UnreachableInst(TI->getContext(), TI);
           TI->eraseFromParent();
           Changed = true;
         }
       } else {
         if (BI->getSuccessor(0) == BB) {
           Builder.CreateBr(BI->getSuccessor(1));
-          EraseTerminatorInstAndDCECond(BI);
+          EraseTerminatorInstAndDCE(BI);
         } else if (BI->getSuccessor(1) == BB) {
           Builder.CreateBr(BI->getSuccessor(0));
-          EraseTerminatorInstAndDCECond(BI);
+          EraseTerminatorInstAndDCE(BI);
           Changed = true;
         }
       }
     } else if (auto *SI = dyn_cast<SwitchInst>(TI)) {
       for (SwitchInst::CaseIt i = SI->case_begin(), e = SI->case_end();
            i != e; ++i)
         if (i.getCaseSuccessor() == BB) {
           BB->removePredecessor(SI->getParent());
if (HasDefault && DeadCases.empty() &&
       SI->getNumCases() == (1ULL << NumUnknownBits)) {
     DEBUG(dbgs() << "SimplifyCFG: switch default is dead.\n");
     BasicBlock *NewDefault = SplitBlockPredecessors(SI->getDefaultDest(),
                                                     SI->getParent(), "");
     SI->setDefaultDest(&*NewDefault);
     SplitBlock(&*NewDefault, &NewDefault->front());
     auto *OldTI = NewDefault->getTerminator();
     new UnreachableInst(SI->getContext(), OldTI);
-    EraseTerminatorInstAndDCECond(OldTI);
+    EraseTerminatorInstAndDCE(OldTI);
     return true;
   }
 
   SmallVector<uint64_t, 8> Weights;
   bool HasWeight = HasBranchWeights(SI);
   if (HasWeight) {
     GetBranchWeights(SI, Weights);
     HasWeight = (Weights.size() == 1 + SI->getNumCases());
if (!Dest->hasAddressTaken() || !Succs.insert(Dest).second) {
       --i; --e;
       Changed = true;
     }
   }
 
   if (IBI->getNumDestinations() == 0) {
     // If the indirectbr has no successors, change it to unreachable.
     new UnreachableInst(IBI->getContext(), IBI);
-    EraseTerminatorInstAndDCECond(IBI);
+    EraseTerminatorInstAndDCE(IBI);
     return true;
   }
 
   if (IBI->getNumDestinations() == 1) {
     // If the indirectbr has one successor, change it to a direct branch.
     BranchInst::Create(IBI->getDestination(0), IBI);
-    EraseTerminatorInstAndDCECond(IBI);
+    EraseTerminatorInstAndDCE(IBI);
     return true;
   }
 
   if (SelectInst *SI = dyn_cast<SelectInst>(IBI->getAddress())) {
     if (SimplifyIndirectBrOnSelect(IBI, SI))
       return SimplifyCFG(BB, TTI, BonusInstThreshold, AC) | true;
   }
   return Changed;

 static bool passingValueIsAlwaysUndefined(Value *V, Instruction *I) {
   Constant *C = dyn_cast<Constant>(V);
   if (!C)
     return false;
 
   if (I->use_empty())
     return false;
 
-  if (C->isNullValue()) {
-    // Only look at the first use, avoid hurting compile time with long uselists
-    User *Use = *I->user_begin();
 
+  if (C->isNullValue()) {
     // Now make sure that there are no instructions in between that can alter
     // control flow (eg. calls)
     for (BasicBlock::iterator i = ++BasicBlock::iterator(I); &*i != Use; ++i)
       if (i == I->getParent()->end() || i->mayHaveSideEffects())
         return false;
 
     // Look through GEPs. A load from a GEP derived from NULL is still undefined
     if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(Use))
if (LoadInst *LI = dyn_cast<LoadInst>(Use))
       if (!LI->isVolatile())
         return LI->getPointerAddressSpace() == 0;
 
     // Store to null is undefined.
     if (StoreInst *SI = dyn_cast<StoreInst>(Use))
       if (!SI->isVolatile())
         return SI->getPointerAddressSpace() == 0 && SI->getPointerOperand() == I;
   }
+
+  if (isa<UnreachableValue>(C)) {
+    return isa<BinaryOperator>(Use) || isa<CmpInst>(Use) ||
+      isa<CastInst>(Use) || isa<CallInst>(Use) || isa<InvokeInst>(Use);
+  }
+
   return false;
 }
 
 /// If BB has an incoming value that will always trigger undefined behavior
 /// (eg. null pointer dereference), remove the branch leading here.
 static bool removeUndefIntroducingPredecessor(BasicBlock *BB) {
   for (BasicBlock::iterator i = BB->begin();
        PHINode *PHI = dyn_cast<PHINode>(i); ++i)

test/Feature/unreachable-cst.ll

+; RUN: llvm-as < %s | llvm-dis > %t1.ll
+; RUN: llvm-as %t1.ll -o - | llvm-dis > %t2.ll
+; RUN: diff %t1.ll %t2.ll
+
+@X = global i32 unreachable           ; <i32*> [#uses=0]
+
+define i32 @test() {
+        ret i32 unreachable
+}
+
+define i32 @test2() {
+        %X = add i32 unreachable, 1           ; <i32> [#uses=1]
+        ret i32 %X
+}
+

test/Transforms/IPConstantProp/PR16052.ll

 ; RUN: opt < %s -S -ipsccp | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define i64 @fn2() {
 entry:
   %conv = sext i32 undef to i64
   %div = sdiv i64 8, %conv
   %call2 = call i64 @fn1(i64 %div)
   ret i64 %call2
 }
 
 ; CHECK-DAG: define i64 @fn2(
-; CHECK: %[[CALL:.*]] = call i64 @fn1(i64 undef)
+; CHECK: %[[CALL:.*]] = call i64 @fn1(i64 unreachable)
 
 define internal i64 @fn1(i64 %p1) {
 entry:
   %tobool = icmp ne i64 %p1, 0
   %cond = select i1 %tobool, i64 %p1, i64 %p1
   ret i64 %cond
 }
 
 ; CHECK-DAG: define internal i64 @fn1(
-; CHECK: %[[SEL:.*]] = select i1 undef, i64 undef, i64 undef
+; CHECK: %[[SEL:.*]] = select i1 unreachable, i64 unreachable, i64 unreachable
 ; CHECK: ret i64 %[[SEL]]

test/Transforms/InstCombine/rem.ll

; CHECK-NEXT: ret i32 [[AND]]
   %shift.upgrd.1 = zext i8 %B to i32
   %Amt = shl i32 32, %shift.upgrd.1
   %V = urem i32 %X, %Amt
   ret i32 %V
 }
 
 define i32 @test6(i32 %A) {
 ; CHECK-LABEL: @test6(
-; CHECK-NEXT: ret i32 undef
-  %B = srem i32 %A, 0  ;; undef
+; CHECK-NEXT: ret i32 unreachable
+  %B = srem i32 %A, 0
   ret i32 %B
 }
 
 define i32 @test7(i32 %A) {
 ; CHECK-LABEL: @test7(
 ; CHECK-NEXT: ret i32 0
   %B = mul i32 %A, 8
   %C = srem i32 %B, 4

test/Transforms/InstSimplify/undef.ll

 ; CHECK:         ret <4 x i8> undef
 ;
   %b = shl <4 x i8> %a, <i8 8, i8 9, i8 undef, i8 -1>
   ret <4 x i8> %b
 }
 
 define i32 @test20(i32 %a) {
 ; CHECK-LABEL: @test20(
-; CHECK:         ret i32 undef
+; CHECK:         ret i32 unreachable
 ;
   %b = udiv i32 %a, 0
   ret i32 %b
 }
 
 define i32 @test21(i32 %a) {
 ; CHECK-LABEL: @test21(
-; CHECK:         ret i32 undef
+; CHECK:         ret i32 unreachable
 ;
   %b = sdiv i32 %a, 0
   ret i32 %b
 }
 
 define i32 @test22(i32 %a) {
 ; CHECK-LABEL: @test22(
 ; CHECK:         ret i32 undef
 ;
   %b = ashr exact i32 undef, %a
   ret i32 %b
 }
 
 define i32 @test23(i32 %a) {
 ; CHECK-LABEL: @test23(
 ; CHECK:         ret i32 undef
 ;
   %b = lshr exact i32 undef, %a
   ret i32 %b
 }
 
 define i32 @test24() {
 ; CHECK-LABEL: @test24(
-; CHECK:         ret i32 undef
+; CHECK:         ret i32 unreachable
 ;
   %b = udiv i32 undef, 0
   ret i32 %b
 }
 
 define i32 @test25() {
 ; CHECK-LABEL: @test25(
 ; CHECK:         ret i32 undef

 ; CHECK:         ret i32 undef
 ;
   %b = extractelement <4 x i32> undef, i32 %V
   ret i32 %b
 }
 
 define i32 @test37() {
 ; CHECK-LABEL: @test37(
-; CHECK:         ret i32 undef
+; CHECK:         ret i32 unreachable
 ;
   %b = udiv i32 undef, undef
   ret i32 %b
 }
 
 define i32 @test38(i32 %a) {
 ; CHECK-LABEL: @test38(
-; CHECK:         ret i32 undef
+; CHECK:         ret i32 unreachable
 ;
   %b = udiv i32 %a, undef
   ret i32 %b
 }
 
 define i32 @test39() {
 ; CHECK-LABEL: @test39(
-; CHECK:         ret i32 undef
+; CHECK:         ret i32 unreachable
 ;
   %b = udiv i32 0, undef
   ret i32 %b
 }