Put ABI breaking test in Error checking behind LLVM_ENABLE_ABI_BREAKING_CHECKS

[mehdi_amini]

Summary

This macro is supposed to be the one controlling the compatibility
of ABI breaks induced when enabling or disabling assertions in LLVM.

The macro is enabled by default in assertions build, so this commit
won't disable the tests.

[mehdi_amini]

Ping!

[lhames]

LGTM. Thanks Mehdi!

llvm/trunk/include/llvm/Support/Error.h

public:
 
   /// Check whether one error is a subclass of another.
   template <typename ErrT> bool isA() const {
     return getPtr() && getPtr()->isA(ErrT::classID());
   }
 
 private:
   void assertIsChecked() {
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
     if (!getChecked() || getPtr()) {
       dbgs() << "Program aborted due to an unhandled Error:\n";
       if (getPtr())
         getPtr()->log(dbgs());
       else
         dbgs()
             << "Error value was Success. (Note: Success values must still be "
                "checked prior to being destroyed).\n";
       abort();
     }
 #endif
   }
 
   ErrorInfoBase *getPtr() const {
     return reinterpret_cast<ErrorInfoBase*>(
              reinterpret_cast<uintptr_t>(Payload) &
              ~static_cast<uintptr_t>(0x1));
   }
 
   void setPtr(ErrorInfoBase *EI) {
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
     Payload = reinterpret_cast<ErrorInfoBase*>(
                 (reinterpret_cast<uintptr_t>(EI) &
                  ~static_cast<uintptr_t>(0x1)) |
                 (reinterpret_cast<uintptr_t>(Payload) & 0x1));
 #else
     Payload = EI;
 #endif
   }
 
   bool getChecked() const {
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
     return (reinterpret_cast<uintptr_t>(Payload) & 0x1) == 0;
 #else
     return true;
 #endif
   }
 
   void setChecked(bool V) {
     Payload = reinterpret_cast<ErrorInfoBase*>(
private:
   typedef typename std::remove_reference<T>::type &reference;
   typedef const typename std::remove_reference<T>::type &const_reference;
   typedef typename std::remove_reference<T>::type *pointer;
   typedef const typename std::remove_reference<T>::type *const_pointer;
 
 public:
   /// Create an Expected<T> error value from the given Error.
   Expected(Error Err)
-      : HasError(true),
-#ifndef NDEBUG
+      : HasError(true)
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
         // Expected is unchecked upon construction in Debug builds.
-        Unchecked(true)
-#else
-        // Expected's unchecked flag is set to false in Release builds. This
-        // allows Expected values constructed in a Release build library to be
-        // consumed by a Debug build application.
-        Unchecked(false)
+        , Unchecked(true)
 #endif
-
   {
     assert(Err && "Cannot create Expected<T> from Error success value.");
     new (getErrorStorage()) error_type(Err.takePayload());
   }
 
   /// Forbid to convert from Error::success() implicitly, this avoids having
   /// Expected<T> foo() { return Error::success(); } which compiles otherwise
   /// but triggers the assertion above.
   Expected(ErrorSuccess) = delete;
 
   /// Create an Expected<T> success value from the given OtherT value, which
   /// must be convertible to T.
   template <typename OtherT>
   Expected(OtherT &&Val,
            typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
                * = nullptr)
-      : HasError(false),
-#ifndef NDEBUG
+      : HasError(false)
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
         // Expected is unchecked upon construction in Debug builds.
-        Unchecked(true)
-#else
-        // Expected's 'unchecked' flag is set to false in Release builds. This
-        // allows Expected values constructed in a Release build library to be
-        // consumed by a Debug build application.
-        Unchecked(false)
+        , Unchecked(true)
 #endif
   {
     new (getStorage()) storage_type(std::forward<OtherT>(Val));
   }
 
   /// Move construct an Expected<T> value.
   Expected(Expected &&Other) { moveConstruct(std::move(Other)); }
 
~Expected() {
     if (!HasError)
       getStorage()->~storage_type();
     else
       getErrorStorage()->~error_type();
   }
 
   /// \brief Return false if there is an error.
   explicit operator bool() {
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
     Unchecked = HasError;
 #endif
     return !HasError;
   }
 
   /// \brief Returns a reference to the stored T value.
   reference get() {
     assertIsChecked();
template <typename ErrT> bool errorIsA() const {
     return HasError && getErrorStorage()->template isA<ErrT>();
   }
 
   /// \brief Take ownership of the stored error.
   /// After calling this the Expected<T> is in an indeterminate state that can
   /// only be safely destructed. No further calls (beside the destructor) should
   /// be made on the Expected<T> vaule.
   Error takeError() {
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
     Unchecked = false;
 #endif
     return HasError ? Error(std::move(*getErrorStorage())) : Error::success();
   }
 
   /// \brief Returns a pointer to the stored T value.
   pointer operator->() {
     assertIsChecked();
private:
 
   template <class T1, class T2>
   static bool compareThisIfSameType(const T1 &a, const T2 &b) {
     return false;
   }
 
   template <class OtherT> void moveConstruct(Expected<OtherT> &&Other) {
     HasError = Other.HasError;
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
     Unchecked = true;
     Other.Unchecked = false;
+#endif
 
     if (!HasError)
       new (getStorage()) storage_type(std::move(*Other.getStorage()));
     else
       new (getErrorStorage()) error_type(std::move(*Other.getErrorStorage()));
   }
 
   template <class OtherT> void moveAssign(Expected<OtherT> &&Other) {
#endif
   }
 
   error_type *getErrorStorage() {
     assert(HasError && "Cannot get error when a value exists!");
     return reinterpret_cast<error_type *>(ErrorStorage.buffer);
   }
 
   void assertIsChecked() {
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
     if (Unchecked) {
       dbgs() << "Expected<T> must be checked before access or destruction.\n";
       if (HasError) {
         dbgs() << "Unchecked Expected<T> contained error:\n";
         (*getErrorStorage())->log(dbgs());
       } else
         dbgs() << "Expected<T> value was in success state. (Note: Expected<T> "
                   "values in success mode must still be checked prior to being "
                   "destroyed).\n";
       abort();
     }
 #endif
   }
 
   union {
     AlignedCharArrayUnion<storage_type> TStorage;
     AlignedCharArrayUnion<error_type> ErrorStorage;
   };
   bool HasError : 1;
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
   bool Unchecked : 1;
+#endif
 };
 
 /// This class wraps a std::error_code in a Error.
 ///
 /// This is useful if you're writing an interface that returns a Error
 /// (or Expected) and you want to call code that still returns
 /// std::error_codes.
 class ECError : public ErrorInfo<ECError> {