Remove LLVM_CONSTEXPR.

[jlebar]

Summary

With MSVC 2013 and GCC < 4.8 gone, we can use the "constexpr" keyword.

[bkramer]

lg, nuke it :)

clang/include/clang/Parse/Parser.h

public:
   /// \brief Control flags for SkipUntil functions.
   enum SkipUntilFlags {
     StopAtSemi = 1 << 0,  ///< Stop skipping at semicolon
     /// \brief Stop skipping at specified token, but don't skip the token itself
     StopBeforeMatch = 1 << 1,
     StopAtCodeCompletion = 1 << 2 ///< Stop at code completion
   };
 
-  friend LLVM_CONSTEXPR SkipUntilFlags operator|(SkipUntilFlags L,
-                                                 SkipUntilFlags R) {
+  friend constexpr SkipUntilFlags operator|(SkipUntilFlags L,
     return static_cast<SkipUntilFlags>(static_cast<unsigned>(L) |
                                        static_cast<unsigned>(R));
   }
 
   /// SkipUntil - Read tokens until we get to the specified token, then consume
   /// it (unless StopBeforeMatch is specified).  Because we cannot guarantee
   /// that the token will ever occur, this skips to the next token, or to some
   /// likely good stopping point.  If Flags has StopAtSemi flag, skipping will

llvm/include/llvm/ADT/ArrayRef.h

public:
 
     /// Construct an ArrayRef from a std::vector.
     template<typename A>
     /*implicit*/ ArrayRef(const std::vector<T, A> &Vec)
       : Data(Vec.data()), Length(Vec.size()) {}
 
     /// Construct an ArrayRef from a std::array
     template <size_t N>
-    /*implicit*/ LLVM_CONSTEXPR ArrayRef(const std::array<T, N> &Arr)
+    /*implicit*/ constexpr ArrayRef(const std::array<T, N> &Arr)
         : Data(Arr.data()), Length(N) {}
 
     /// Construct an ArrayRef from a C array.
     template <size_t N>
-    /*implicit*/ LLVM_CONSTEXPR ArrayRef(const T (&Arr)[N])
-      : Data(Arr), Length(N) {}
+    /*implicit*/ constexpr ArrayRef(const T (&Arr)[N]) : Data(Arr), Length(N) {}
 
     /// Construct an ArrayRef from a std::initializer_list.
     /*implicit*/ ArrayRef(const std::initializer_list<T> &Vec)
     : Data(Vec.begin() == Vec.end() ? (T*)nullptr : Vec.begin()),
       Length(Vec.size()) {}
 
     /// Construct an ArrayRef<const T*> from ArrayRef<T*>. This uses SFINAE to
     /// ensure that only ArrayRefs of pointers can be converted.
public:
     : ArrayRef<T>(Vec) {}
 
     /// Construct a MutableArrayRef from a std::vector.
     /*implicit*/ MutableArrayRef(std::vector<T> &Vec)
     : ArrayRef<T>(Vec) {}
 
     /// Construct an ArrayRef from a std::array
     template <size_t N>
-    /*implicit*/ LLVM_CONSTEXPR MutableArrayRef(std::array<T, N> &Arr)
+    /*implicit*/ constexpr MutableArrayRef(std::array<T, N> &Arr)
         : ArrayRef<T>(Arr) {}
 
     /// Construct an MutableArrayRef from a C array.
     template <size_t N>
-    /*implicit*/ LLVM_CONSTEXPR MutableArrayRef(T (&Arr)[N])
-      : ArrayRef<T>(Arr) {}
+    /*implicit*/ constexpr MutableArrayRef(T (&Arr)[N]) : ArrayRef<T>(Arr) {}
 
     T *data() const { return const_cast<T*>(ArrayRef<T>::data()); }
 
     iterator begin() const { return data(); }
     iterator end() const { return data() + this->size(); }
 
     reverse_iterator rbegin() const { return reverse_iterator(end()); }
     reverse_iterator rend() const { return reverse_iterator(begin()); }

llvm/include/llvm/ADT/Optional.h

public:
   explicit operator bool() const { return hasVal; }
   bool hasValue() const { return hasVal; }
   const T* operator->() const { return getPointer(); }
   T* operator->() { return getPointer(); }
   const T& operator*() const LLVM_LVALUE_FUNCTION { assert(hasVal); return *getPointer(); }
   T& operator*() LLVM_LVALUE_FUNCTION { assert(hasVal); return *getPointer(); }
 
   template <typename U>
-  LLVM_CONSTEXPR T getValueOr(U &&value) const LLVM_LVALUE_FUNCTION {
+  constexpr T getValueOr(U &&value) const LLVM_LVALUE_FUNCTION {
     return hasValue() ? getValue() : std::forward<U>(value);
   }
 
 #if LLVM_HAS_RVALUE_REFERENCE_THIS
   T&& getValue() && { assert(hasVal); return std::move(*getPointer()); }
   T&& operator*() && { assert(hasVal); return std::move(*getPointer()); }
 
   template <typename U>

llvm/include/llvm/ADT/STLExtras.h

 };
 
 // A subset of N3658. More stuff can be added as-needed.
 
 /// \brief Represents a compile-time sequence of integers.
 template <class T, T... I> struct integer_sequence {
   typedef T value_type;
 
-  static LLVM_CONSTEXPR size_t size() { return sizeof...(I); }
+  static constexpr size_t size() { return sizeof...(I); }
 };
 
 /// \brief Alias for the common case of a sequence of size_ts.
 template <size_t... I>
 struct index_sequence : integer_sequence<std::size_t, I...> {};
 
 template <std::size_t N, std::size_t... I>
 struct build_index_impl : build_index_impl<N - 1, N - 1, I...> {};

 template <> struct rank<0> {};
 
 //===----------------------------------------------------------------------===//
 //     Extra additions for arrays
 //===----------------------------------------------------------------------===//
 
 /// Find the length of an array.
 template <class T, std::size_t N>
-LLVM_CONSTEXPR inline size_t array_lengthof(T (&)[N]) {
+constexpr inline size_t array_lengthof(T (&)[N]) {
   return N;
 }
 
 /// Adapt std::less<T> for array_pod_sort.
 template<typename T>
 inline int array_pod_sort_comparator(const void *P1, const void *P2) {
   if (std::less<T>()(*reinterpret_cast<const T*>(P1),
                      *reinterpret_cast<const T*>(P2)))

llvm/include/llvm/CodeGen/MachineValueType.h

enum SimpleValueType : int8_t {
 
       // Any - Any type. This is used for intrinsics that have overloadings.
       // This is only for tblgen's consumption!
       Any            = 127
     };
 
     SimpleValueType SimpleTy;
 
-    LLVM_CONSTEXPR MVT() : SimpleTy(INVALID_SIMPLE_VALUE_TYPE) {}
-    LLVM_CONSTEXPR MVT(SimpleValueType SVT) : SimpleTy(SVT) { }
+    constexpr MVT() : SimpleTy(INVALID_SIMPLE_VALUE_TYPE) {}
+    constexpr MVT(SimpleValueType SVT) : SimpleTy(SVT) {}
 
     bool operator>(const MVT& S)  const { return SimpleTy >  S.SimpleTy; }
     bool operator<(const MVT& S)  const { return SimpleTy <  S.SimpleTy; }
     bool operator==(const MVT& S) const { return SimpleTy == S.SimpleTy; }
     bool operator!=(const MVT& S) const { return SimpleTy != S.SimpleTy; }
     bool operator>=(const MVT& S) const { return SimpleTy >= S.SimpleTy; }
     bool operator<=(const MVT& S) const { return SimpleTy <= S.SimpleTy; }
 

llvm/include/llvm/CodeGen/ValueTypes.h

namespace llvm {
   /// native for any processor (such as the i12345 type), as well as the types
   /// a MVT can represent.
   struct EVT {
   private:
     MVT V;
     Type *LLVMTy;
 
   public:
-    LLVM_CONSTEXPR EVT() : V(MVT::INVALID_SIMPLE_VALUE_TYPE), LLVMTy(nullptr) {}
-    LLVM_CONSTEXPR EVT(MVT::SimpleValueType SVT) : V(SVT), LLVMTy(nullptr) {}
-    LLVM_CONSTEXPR EVT(MVT S) : V(S), LLVMTy(nullptr) {}
+    constexpr EVT() : V(MVT::INVALID_SIMPLE_VALUE_TYPE), LLVMTy(nullptr) {}
+    constexpr EVT(MVT::SimpleValueType SVT) : V(SVT), LLVMTy(nullptr) {}
+    constexpr EVT(MVT S) : V(S), LLVMTy(nullptr) {}
 
     bool operator==(EVT VT) const {
       return !(*this != VT);
     }
     bool operator!=(EVT VT) const {
       if (V.SimpleTy != VT.V.SimpleTy)
         return true;
       if (V.SimpleTy < 0)

llvm/include/llvm/Support/Compiler.h

 /// This can be used to provide lvalue/rvalue overrides of member functions.
 /// The rvalue override should be guarded by LLVM_HAS_RVALUE_REFERENCE_THIS
 #if LLVM_HAS_RVALUE_REFERENCE_THIS
 #define LLVM_LVALUE_FUNCTION &
 #else
 #define LLVM_LVALUE_FUNCTION
 #endif
 
-#if __has_feature(cxx_constexpr) || defined(__GXX_EXPERIMENTAL_CXX0X__) || LLVM_MSC_PREREQ(1900)
-# define LLVM_CONSTEXPR constexpr
-#else
-# define LLVM_CONSTEXPR
-#endif
-
 /// LLVM_LIBRARY_VISIBILITY - If a class marked with this attribute is linked
 /// into a shared library, then the class should be private to the library and
 /// not accessible from outside it.  Can also be used to mark variables and
 /// functions, making them private to any shared library they are linked into.
 /// On PE/COFF targets, library visibility is the default, so this isn't needed.
 #if (__has_attribute(visibility) || LLVM_GNUC_PREREQ(4, 0, 0)) &&              \
     !defined(__MINGW32__) && !defined(__CYGWIN__) && !defined(LLVM_ON_WIN32)
 #define LLVM_LIBRARY_VISIBILITY __attribute__ ((visibility("hidden")))

llvm/include/llvm/Support/MathExtras.h

T reverseBits(T Val) {
   return Val;
 }
 
 // NOTE: The following support functions use the _32/_64 extensions instead of
 // type overloading so that signed and unsigned integers can be used without
 // ambiguity.
 
 /// Hi_32 - This function returns the high 32 bits of a 64 bit value.
-LLVM_CONSTEXPR inline uint32_t Hi_32(uint64_t Value) {
+constexpr inline uint32_t Hi_32(uint64_t Value) {
   return static_cast<uint32_t>(Value >> 32);
 }
 
 /// Lo_32 - This function returns the low 32 bits of a 64 bit value.
-LLVM_CONSTEXPR inline uint32_t Lo_32(uint64_t Value) {
+constexpr inline uint32_t Lo_32(uint64_t Value) {
   return static_cast<uint32_t>(Value);
 }
 
 /// Make_64 - This functions makes a 64-bit integer from a high / low pair of
 ///           32-bit integers.
-LLVM_CONSTEXPR inline uint64_t Make_64(uint32_t High, uint32_t Low) {
+constexpr inline uint64_t Make_64(uint32_t High, uint32_t Low) {
   return ((uint64_t)High << 32) | (uint64_t)Low;
 }
 
 /// isInt - Checks if an integer fits into the given bit width.
-template<unsigned N>
-LLVM_CONSTEXPR inline bool isInt(int64_t x) {
+template <unsigned N> constexpr inline bool isInt(int64_t x) {
   return N >= 64 || (-(INT64_C(1)<<(N-1)) <= x && x < (INT64_C(1)<<(N-1)));
 }
 // Template specializations to get better code for common cases.
-template<>
-LLVM_CONSTEXPR inline bool isInt<8>(int64_t x) {
+template <> constexpr inline bool isInt<8>(int64_t x) {
   return static_cast<int8_t>(x) == x;
 }
-template<>
-LLVM_CONSTEXPR inline bool isInt<16>(int64_t x) {
+template <> constexpr inline bool isInt<16>(int64_t x) {
   return static_cast<int16_t>(x) == x;
 }
-template<>
-LLVM_CONSTEXPR inline bool isInt<32>(int64_t x) {
+template <> constexpr inline bool isInt<32>(int64_t x) {
   return static_cast<int32_t>(x) == x;
 }
 
 /// isShiftedInt<N,S> - Checks if a signed integer is an N bit number shifted
 ///                     left by S.
-template<unsigned N, unsigned S>
-LLVM_CONSTEXPR inline bool isShiftedInt(int64_t x) {
+template <unsigned N, unsigned S>
+constexpr inline bool isShiftedInt(int64_t x) {
   static_assert(
       N > 0, "isShiftedInt<0> doesn't make sense (refers to a 0-bit number.");
   static_assert(N + S <= 64, "isShiftedInt<N, S> with N + S > 64 is too wide.");
   return isInt<N + S>(x) && (x % (UINT64_C(1) << S) == 0);
 }
 
 /// isUInt - Checks if an unsigned integer fits into the given bit width.
 ///
 /// This is written as two functions rather than as simply
 ///
 ///   return N >= 64 || X < (UINT64_C(1) << N);
 ///
 /// to keep MSVC from (incorrectly) warning on isUInt<64> that we're shifting
 /// left too many places.
 template <unsigned N>
-LLVM_CONSTEXPR inline typename std::enable_if<(N < 64), bool>::type
+constexpr inline typename std::enable_if<(N < 64), bool>::type
 isUInt(uint64_t X) {
   static_assert(N > 0, "isUInt<0> doesn't make sense");
   return X < (UINT64_C(1) << (N));
 }
 template <unsigned N>
-LLVM_CONSTEXPR inline typename std::enable_if<N >= 64, bool>::type
+constexpr inline typename std::enable_if<N >= 64, bool>::type
 isUInt(uint64_t X) {
   return true;
 }
 
 // Template specializations to get better code for common cases.
-template<>
-LLVM_CONSTEXPR inline bool isUInt<8>(uint64_t x) {
+template <> constexpr inline bool isUInt<8>(uint64_t x) {
   return static_cast<uint8_t>(x) == x;
 }
-template<>
-LLVM_CONSTEXPR inline bool isUInt<16>(uint64_t x) {
+template <> constexpr inline bool isUInt<16>(uint64_t x) {
   return static_cast<uint16_t>(x) == x;
 }
-template<>
-LLVM_CONSTEXPR inline bool isUInt<32>(uint64_t x) {
+template <> constexpr inline bool isUInt<32>(uint64_t x) {
   return static_cast<uint32_t>(x) == x;
 }
 
 /// Checks if a unsigned integer is an N bit number shifted left by S.
-template<unsigned N, unsigned S>
-LLVM_CONSTEXPR inline bool isShiftedUInt(uint64_t x) {
+template <unsigned N, unsigned S>
+constexpr inline bool isShiftedUInt(uint64_t x) {
   static_assert(
       N > 0, "isShiftedUInt<0> doesn't make sense (refers to a 0-bit number)");
   static_assert(N + S <= 64,
                 "isShiftedUInt<N, S> with N + S > 64 is too wide.");
   // Per the two static_asserts above, S must be strictly less than 64.  So
   // 1 << S is not undefined behavior.
   return isUInt<N + S>(x) && (x % (UINT64_C(1) << S) == 0);
 }

 /// bit width.
 inline bool isIntN(unsigned N, int64_t x) {
   return N >= 64 || (minIntN(N) <= x && x <= maxIntN(N));
 }
 
 /// isMask_32 - This function returns true if the argument is a non-empty
 /// sequence of ones starting at the least significant bit with the remainder
 /// zero (32 bit version).  Ex. isMask_32(0x0000FFFFU) == true.
-LLVM_CONSTEXPR inline bool isMask_32(uint32_t Value) {
+constexpr inline bool isMask_32(uint32_t Value) {
   return Value && ((Value + 1) & Value) == 0;
 }
 
 /// isMask_64 - This function returns true if the argument is a non-empty
 /// sequence of ones starting at the least significant bit with the remainder
 /// zero (64 bit version).
-LLVM_CONSTEXPR inline bool isMask_64(uint64_t Value) {
+constexpr inline bool isMask_64(uint64_t Value) {
   return Value && ((Value + 1) & Value) == 0;
 }
 
 /// isShiftedMask_32 - This function returns true if the argument contains a
 /// non-empty sequence of ones with the remainder zero (32 bit version.)
 /// Ex. isShiftedMask_32(0x0000FF00U) == true.
-LLVM_CONSTEXPR inline bool isShiftedMask_32(uint32_t Value) {
+constexpr inline bool isShiftedMask_32(uint32_t Value) {
   return Value && isMask_32((Value - 1) | Value);
 }
 
 /// isShiftedMask_64 - This function returns true if the argument contains a
 /// non-empty sequence of ones with the remainder zero (64 bit version.)
-LLVM_CONSTEXPR inline bool isShiftedMask_64(uint64_t Value) {
+constexpr inline bool isShiftedMask_64(uint64_t Value) {
   return Value && isMask_64((Value - 1) | Value);
 }
 
 /// isPowerOf2_32 - This function returns true if the argument is a power of
 /// two > 0. Ex. isPowerOf2_32(0x00100000U) == true (32 bit edition.)
-LLVM_CONSTEXPR inline bool isPowerOf2_32(uint32_t Value) {
+constexpr inline bool isPowerOf2_32(uint32_t Value) {
   return Value && !(Value & (Value - 1));
 }
 
 /// isPowerOf2_64 - This function returns true if the argument is a power of two
 /// > 0 (64 bit edition.)
-LLVM_CONSTEXPR inline bool isPowerOf2_64(uint64_t Value) {
+constexpr inline bool isPowerOf2_64(uint64_t Value) {
   return Value && !(Value & (Value - int64_t(1L)));
 }
 
 /// ByteSwap_16 - This function returns a byte-swapped representation of the
 /// 16-bit argument, Value.
 inline uint16_t ByteSwap_16(uint16_t Value) {
   return sys::SwapByteOrder_16(Value);
 }
union {
     float F;
   } T;
   T.F = Float;
   return T.I;
 }
 
 /// MinAlign - A and B are either alignments or offsets.  Return the minimum
 /// alignment that may be assumed after adding the two together.
-LLVM_CONSTEXPR inline uint64_t MinAlign(uint64_t A, uint64_t B) {
+constexpr inline uint64_t MinAlign(uint64_t A, uint64_t B) {
   // The largest power of 2 that divides both A and B.
   //
   // Replace "-Value" by "1+~Value" in the following commented code to avoid
   // MSVC warning C4146
   //    return (A | B) & -(A | B);
   return (A | B) & (1 + ~(A | B));
 }
 

 inline uint64_t alignTo(uint64_t Value, uint64_t Align, uint64_t Skew = 0) {
   assert(Align != 0u && "Align can't be 0.");
   Skew %= Align;
   return (Value + Align - 1 - Skew) / Align * Align + Skew;
 }
 
 /// Returns the next integer (mod 2**64) that is greater than or equal to
 /// \p Value and is a multiple of \c Align. \c Align must be non-zero.
-template <uint64_t Align>
-LLVM_CONSTEXPR inline uint64_t alignTo(uint64_t Value) {
+template <uint64_t Align> constexpr inline uint64_t alignTo(uint64_t Value) {
   static_assert(Align != 0u, "Align must be non-zero");
   return (Value + Align - 1) / Align * Align;
 }
 
 /// \c alignTo for contexts where a constant expression is required.
 /// \sa alignTo
 ///
-/// \todo FIXME: remove when \c LLVM_CONSTEXPR becomes really \c constexpr
+/// \todo FIXME: remove when \c constexpr becomes really \c constexpr
 template <uint64_t Align>
 struct AlignTo {
   static_assert(Align != 0u, "Align must be non-zero");
   template <uint64_t Value>
   struct from_value {
     static const uint64_t value = (Value + Align - 1) / Align * Align;
   };
 };

 /// or equal to \p Value and is a multiple of \p Align. \p Align must be
 /// non-zero.
 inline uint64_t OffsetToAlignment(uint64_t Value, uint64_t Align) {
   return alignTo(Value, Align) - Value;
 }
 
 /// Sign-extend the number in the bottom B bits of X to a 32-bit integer.
 /// Requires 0 < B <= 32.
-template <unsigned B> LLVM_CONSTEXPR inline int32_t SignExtend32(uint32_t X) {
+template <unsigned B> constexpr inline int32_t SignExtend32(uint32_t X) {
   static_assert(B > 0, "Bit width can't be 0.");
   static_assert(B <= 32, "Bit width out of range.");
   return int32_t(X << (32 - B)) >> (32 - B);
 }
 
 /// Sign-extend the number in the bottom B bits of X to a 32-bit integer.
 /// Requires 0 < B < 32.
 inline int32_t SignExtend32(uint32_t X, unsigned B) {
   assert(B > 0 && "Bit width can't be 0.");
   assert(B <= 32 && "Bit width out of range.");
   return int32_t(X << (32 - B)) >> (32 - B);
 }
 
 /// Sign-extend the number in the bottom B bits of X to a 64-bit integer.
 /// Requires 0 < B < 64.
-template <unsigned B> LLVM_CONSTEXPR inline int64_t SignExtend64(uint64_t x) {
+template <unsigned B> constexpr inline int64_t SignExtend64(uint64_t x) {
   static_assert(B > 0, "Bit width can't be 0.");
   static_assert(B <= 64, "Bit width out of range.");
   return int64_t(x << (64 - B)) >> (64 - B);
 }
 
 /// Sign-extend the number in the bottom B bits of X to a 64-bit integer.
 /// Requires 0 < B < 64.
 inline int64_t SignExtend64(uint64_t X, unsigned B) {

llvm/include/llvm/Support/RandomNumberGenerator.h

public:
 
   // We can only make min/max constexpr if generator_type::min/max are
   // constexpr.  The MSVC 2013 STL does not make these constexpr, so we have to
   // avoid declaring them as constexpr even if the compiler, like clang-cl,
   // supports it.
 #if defined(_MSC_VER) && _MSC_VER < 1900
 #define STL_CONSTEXPR
 #else
-#define STL_CONSTEXPR LLVM_CONSTEXPR
+#define STL_CONSTEXPR constexpr
 #endif
 
   static STL_CONSTEXPR result_type min() { return generator_type::min(); }
   static STL_CONSTEXPR result_type max() { return generator_type::max(); }
 
 private:
   /// Seeds and salts the underlying RNG engine.
   ///

llvm/include/llvm/Support/TrailingObjects.h

class TrailingObjectsImpl<Align, BaseTy, TopTrailingObj, PrevTy, NextTy,
 
   typedef TrailingObjectsImpl<Align, BaseTy, TopTrailingObj, NextTy, MoreTys...>
       ParentType;
 
   struct RequiresRealignment {
     static const bool value = alignof(PrevTy) < alignof(NextTy);
   };
 
-  static LLVM_CONSTEXPR bool requiresRealignment() {
+  static constexpr bool requiresRealignment() {
     return RequiresRealignment::value;
   }
 
 protected:
   // Ensure the inherited getTrailingObjectsImpl is not hidden.
   using ParentType::getTrailingObjectsImpl;
 
   // These two functions are helper functions for
if (requiresRealignment())
       return reinterpret_cast<NextTy *>(llvm::alignAddr(Ptr, alignof(NextTy)));
     else
       return reinterpret_cast<NextTy *>(Ptr);
   }
 
   // Helper function for TrailingObjects::additionalSizeToAlloc: this
   // function recurses to superclasses, each of which requires one
   // fewer size_t argument, and adds its own size.
-  static LLVM_CONSTEXPR size_t additionalSizeToAllocImpl(
+  static constexpr size_t additionalSizeToAllocImpl(
       size_t SizeSoFar, size_t Count1,
       typename ExtractSecondType<MoreTys, size_t>::type... MoreCounts) {
     return ParentType::additionalSizeToAllocImpl(
         (requiresRealignment() ? llvm::alignTo<alignof(NextTy)>(SizeSoFar)
                                : SizeSoFar) +
             sizeof(NextTy) * Count1,
         MoreCounts...);
   }
-
-  // additionalSizeToAllocImpl for contexts where a constant expression is
-  // required.
-  // FIXME: remove when LLVM_CONSTEXPR becomes really constexpr
-  template <size_t SizeSoFar, size_t Count1, size_t... MoreCounts>
-  struct AdditionalSizeToAllocImpl {
-    static_assert(sizeof...(MoreTys) == sizeof...(MoreCounts),
-                  "Number of counts do not match number of types");
-    static const size_t value = ParentType::template AdditionalSizeToAllocImpl<
-        (RequiresRealignment::value ? llvm::AlignTo<alignof(NextTy)>::
-                                          template from_value<SizeSoFar>::value
-                                    : SizeSoFar) +
-            sizeof(NextTy) * Count1,
-        MoreCounts...>::value;
-  };
 };
 
 // The base case of the TrailingObjectsImpl inheritance recursion,
 // when there's no more trailing types.
 template <int Align, typename BaseTy, typename TopTrailingObj, typename PrevTy>
 class TrailingObjectsImpl<Align, BaseTy, TopTrailingObj, PrevTy>
     : public TrailingObjectsAligner<Align> {
 protected:
   // This is a dummy method, only here so the "using" doesn't fail --
   // it will never be called, because this function recurses backwards
   // up the inheritance chain to subclasses.
   static void getTrailingObjectsImpl();
 
-  static LLVM_CONSTEXPR size_t additionalSizeToAllocImpl(size_t SizeSoFar) {
+  static constexpr size_t additionalSizeToAllocImpl(size_t SizeSoFar) {
     return SizeSoFar;
   }
 
-  // additionalSizeToAllocImpl for contexts where a constant expression is
-  // required.
-  // FIXME: remove when LLVM_CONSTEXPR becomes really constexpr
-  template <size_t SizeSoFar> struct AdditionalSizeToAllocImpl {
-    static const size_t value = SizeSoFar;
-  };
-
   template <bool CheckAlignment> static void verifyTrailingObjectsAlignment() {}
 };
 
 } // end namespace trailing_objects_internal
 
 // Finally, the main type defined in this file, the one intended for users...
 
 /// See the file comment for details on the usage of the
public:
 
   /// Returns the size of the trailing data, if an object were
   /// allocated with the given counts (The counts are in the same order
   /// as the template arguments). This does not include the size of the
   /// base object.  The template arguments must be the same as those
   /// used in the class; they are supplied here redundantly only so
   /// that it's clear what the counts are counting in callers.
   template <typename... Tys>
-  static LLVM_CONSTEXPR typename std::enable_if<
+  static constexpr typename std::enable_if<
       std::is_same<Foo<TrailingTys...>, Foo<Tys...>>::value, size_t>::type
-      additionalSizeToAlloc(
-          typename trailing_objects_internal::ExtractSecondType<
+  additionalSizeToAlloc(typename trailing_objects_internal::ExtractSecondType<
                         TrailingTys, size_t>::type... Counts) {
     return ParentType::additionalSizeToAllocImpl(0, Counts...);
   }
 
   /// Returns the total size of an object if it were allocated with the
   /// given trailing object counts. This is the same as
   /// additionalSizeToAlloc, except it *does* include the size of the base
   /// object.
   template <typename... Tys>
-  static LLVM_CONSTEXPR typename std::enable_if<
+  static constexpr typename std::enable_if<
       std::is_same<Foo<TrailingTys...>, Foo<Tys...>>::value, size_t>::type
-      totalSizeToAlloc(typename trailing_objects_internal::ExtractSecondType<
-                       TrailingTys, size_t>::type... Counts) {
     return sizeof(BaseTy) + ParentType::additionalSizeToAllocImpl(0, Counts...);
   }
 
-  // totalSizeToAlloc for contexts where a constant expression is required.
-  // FIXME: remove when LLVM_CONSTEXPR becomes really constexpr
-  template <typename... Tys> struct TotalSizeToAlloc {
-    static_assert(
-        std::is_same<Foo<TrailingTys...>, Foo<Tys...>>::value,
-        "Arguments to TotalSizeToAlloc do not match with TrailingObjects");
-    template <size_t... Counts> struct with_counts {
-      static_assert(sizeof...(TrailingTys) == sizeof...(Counts),
-                    "Number of counts do not match number of types");
-      static const size_t value =
-          sizeof(BaseTy) +
-          ParentType::template AdditionalSizeToAllocImpl<0, Counts...>::value;
-    };
-  };
-
   /// A type where its ::with_counts template member has a ::type member
   /// suitable for use as uninitialized storage for an object with the given
   /// trailing object counts. The template arguments are similar to those
   /// of additionalSizeToAlloc.
   ///
   /// Use with FixedSizeStorageOwner, e.g.:
   ///
   /// \code{.cpp}
   ///
   /// MyObj::FixedSizeStorage<void *>::with_counts<1u>::type myStackObjStorage;
   /// MyObj::FixedSizeStorageOwner
   ///     myStackObjOwner(new ((void *)&myStackObjStorage) MyObj);
   /// MyObj *const myStackObjPtr = myStackObjOwner.get();
   ///
   /// \endcode
   template <typename... Tys> struct FixedSizeStorage {
     template <size_t... Counts> struct with_counts {
-      enum {
-        Size = TotalSizeToAlloc<Tys...>::template with_counts<Counts...>::value
-      };
+      enum { Size = totalSizeToAlloc<Tys...>(Counts...) };
       typedef llvm::AlignedCharArray<alignof(BaseTy), Size> type;
     };
   };
 
   /// A type that acts as the owner for an object placed into fixed storage.
   class FixedSizeStorageOwner {
   public:
     FixedSizeStorageOwner(BaseTy *p) : p(p) {}

llvm/include/llvm/Support/UnicodeCharRanges.h

public:
   /// the constructor, so it makes sense to create as few UnicodeCharSet
   /// instances per each array of ranges, as possible.
 #ifdef NDEBUG
 
   // FIXME: This could use constexpr + static_assert. This way we
   // may get rid of NDEBUG in this header. Unfortunately there are some
   // problems to get this working with MSVC 2013. Change this when
   // the support for MSVC 2013 is dropped.
-  LLVM_CONSTEXPR UnicodeCharSet(CharRanges Ranges) : Ranges(Ranges) {}
+  constexpr UnicodeCharSet(CharRanges Ranges) : Ranges(Ranges) {}
 #else
   UnicodeCharSet(CharRanges Ranges) : Ranges(Ranges) {
     assert(rangesAreValid());
   }
 #endif
 
   /// \brief Returns true if the character set contains the Unicode code point
   /// \p C.

llvm/lib/CodeGen/AsmPrinter/DwarfAccelTable.h

public:
   // atom_count Atoms
 
   // Make these public so that they can be used as a general interface to
   // the class.
   struct Atom {
     uint16_t type; // enum AtomType
     uint16_t form; // DWARF DW_FORM_ defines
 
-    LLVM_CONSTEXPR Atom(uint16_t type, uint16_t form)
-        : type(type), form(form) {}
+    constexpr Atom(uint16_t type, uint16_t form) : type(type), form(form) {}
 #ifndef NDEBUG
     void print(raw_ostream &O) {
       O << "Type: " << dwarf::AtomTypeString(type) << "\n"
         << "Form: " << dwarf::FormEncodingString(form) << "\n";
     }
     void dump() { print(dbgs()); }
 #endif
   };