contrib/llvm/include/llvm/Support/Error.h

   1 //===- llvm/Support/Error.h - Recoverable error handling --------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file defines an API used to report recoverable errors.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_SUPPORT_ERROR_H
  15 #define LLVM_SUPPORT_ERROR_H
  16
  17 #include "llvm-c/Error.h"
  18 #include "llvm/ADT/STLExtras.h"
  19 #include "llvm/ADT/SmallVector.h"
  20 #include "llvm/ADT/StringExtras.h"
  21 #include "llvm/ADT/Twine.h"
  22 #include "llvm/Config/abi-breaking.h"
  23 #include "llvm/Support/AlignOf.h"
  24 #include "llvm/Support/Compiler.h"
  25 #include "llvm/Support/Debug.h"
  26 #include "llvm/Support/ErrorHandling.h"
  27 #include "llvm/Support/ErrorOr.h"
  28 #include "llvm/Support/Format.h"
  29 #include "llvm/Support/raw_ostream.h"
  30 #include <algorithm>
  31 #include <cassert>
  32 #include <cstdint>
  33 #include <cstdlib>
  34 #include <functional>
  35 #include <memory>
  36 #include <new>
  37 #include <string>
  38 #include <system_error>
  39 #include <type_traits>
  40 #include <utility>
  41 #include <vector>
  42
  43 namespace llvm {
  44
  45 class ErrorSuccess;
  46
  47 /// Base class for error info classes. Do not extend this directly: Extend
  48 /// the ErrorInfo template subclass instead.
  49 class ErrorInfoBase {
  50 public:
  51   virtual ~ErrorInfoBase() = default;
  52
  53   /// Print an error message to an output stream.
  54   virtual void log(raw_ostream &OS) const = 0;
  55
  56   /// Return the error message as a string.
  57   virtual std::string message() const {
  58     std::string Msg;
  59     raw_string_ostream OS(Msg);
  60     log(OS);
  61     return OS.str();
  62   }
  63
  64   /// Convert this error to a std::error_code.
  65   ///
  66   /// This is a temporary crutch to enable interaction with code still
  67   /// using std::error_code. It will be removed in the future.
  68   virtual std::error_code convertToErrorCode() const = 0;
  69
  70   // Returns the class ID for this type.
  71   static const void *classID() { return &ID; }
  72
  73   // Returns the class ID for the dynamic type of this ErrorInfoBase instance.
  74   virtual const void *dynamicClassID() const = 0;
  75
  76   // Check whether this instance is a subclass of the class identified by
  77   // ClassID.
  78   virtual bool isA(const void *const ClassID) const {
  79     return ClassID == classID();
  80   }
  81
  82   // Check whether this instance is a subclass of ErrorInfoT.
  83   template <typename ErrorInfoT> bool isA() const {
  84     return isA(ErrorInfoT::classID());
  85   }
  86
  87 private:
  88   virtual void anchor();
  89
  90   static char ID;
  91 };
  92
  93 /// Lightweight error class with error context and mandatory checking.
  94 ///
  95 /// Instances of this class wrap a ErrorInfoBase pointer. Failure states
  96 /// are represented by setting the pointer to a ErrorInfoBase subclass
  97 /// instance containing information describing the failure. Success is
  98 /// represented by a null pointer value.
  99 ///
 100 /// Instances of Error also contains a 'Checked' flag, which must be set
 101 /// before the destructor is called, otherwise the destructor will trigger a
 102 /// runtime error. This enforces at runtime the requirement that all Error
 103 /// instances be checked or returned to the caller.
 104 ///
 105 /// There are two ways to set the checked flag, depending on what state the
 106 /// Error instance is in. For Error instances indicating success, it
 107 /// is sufficient to invoke the boolean conversion operator. E.g.:
 108 ///
 109 ///   @code{.cpp}
 110 ///   Error foo(<...>);
 111 ///
 112 ///   if (auto E = foo(<...>))
 113 ///     return E; // <- Return E if it is in the error state.
 114 ///   // We have verified that E was in the success state. It can now be safely
 115 ///   // destroyed.
 116 ///   @endcode
 117 ///
 118 /// A success value *can not* be dropped. For example, just calling 'foo(<...>)'
 119 /// without testing the return value will raise a runtime error, even if foo
 120 /// returns success.
 121 ///
 122 /// For Error instances representing failure, you must use either the
 123 /// handleErrors or handleAllErrors function with a typed handler. E.g.:
 124 ///
 125 ///   @code{.cpp}
 126 ///   class MyErrorInfo : public ErrorInfo<MyErrorInfo> {
 127 ///     // Custom error info.
 128 ///   };
 129 ///
 130 ///   Error foo(<...>) { return make_error<MyErrorInfo>(...); }
 131 ///
 132 ///   auto E = foo(<...>); // <- foo returns failure with MyErrorInfo.
 133 ///   auto NewE =
 134 ///     handleErrors(E,
 135 ///       [](const MyErrorInfo &M) {
 136 ///         // Deal with the error.
 137 ///       },
 138 ///       [](std::unique_ptr<OtherError> M) -> Error {
 139 ///         if (canHandle(*M)) {
 140 ///           // handle error.
 141 ///           return Error::success();
 142 ///         }
 143 ///         // Couldn't handle this error instance. Pass it up the stack.
 144 ///         return Error(std::move(M));
 145 ///       );
 146 ///   // Note - we must check or return NewE in case any of the handlers
 147 ///   // returned a new error.
 148 ///   @endcode
 149 ///
 150 /// The handleAllErrors function is identical to handleErrors, except
 151 /// that it has a void return type, and requires all errors to be handled and
 152 /// no new errors be returned. It prevents errors (assuming they can all be
 153 /// handled) from having to be bubbled all the way to the top-level.
 154 ///
 155 /// *All* Error instances must be checked before destruction, even if
 156 /// they're moved-assigned or constructed from Success values that have already
 157 /// been checked. This enforces checking through all levels of the call stack.
 158 class LLVM_NODISCARD Error {
 159   // Both ErrorList and FileError need to be able to yank ErrorInfoBase
 160   // pointers out of this class to add to the error list.
 161   friend class ErrorList;
 162   friend class FileError;
 163
 164   // handleErrors needs to be able to set the Checked flag.
 165   template <typename... HandlerTs>
 166   friend Error handleErrors(Error E, HandlerTs &&... Handlers);
 167
 168   // Expected<T> needs to be able to steal the payload when constructed from an
 169   // error.
 170   template <typename T> friend class Expected;
 171
 172   // wrap needs to be able to steal the payload.
 173   friend LLVMErrorRef wrap(Error);
 174
 175 protected:
 176   /// Create a success value. Prefer using 'Error::success()' for readability
 177   Error() {
 178     setPtr(nullptr);
 179     setChecked(false);
 180   }
 181
 182 public:
 183   /// Create a success value.
 184   static ErrorSuccess success();
 185
 186   // Errors are not copy-constructable.
 187   Error(const Error &Other) = delete;
 188
 189   /// Move-construct an error value. The newly constructed error is considered
 190   /// unchecked, even if the source error had been checked. The original error
 191   /// becomes a checked Success value, regardless of its original state.
 192   Error(Error &&Other) {
 193     setChecked(true);
 194     *this = std::move(Other);
 195   }
 196
 197   /// Create an error value. Prefer using the 'make_error' function, but
 198   /// this constructor can be useful when "re-throwing" errors from handlers.
 199   Error(std::unique_ptr<ErrorInfoBase> Payload) {
 200     setPtr(Payload.release());
 201     setChecked(false);
 202   }
 203
 204   // Errors are not copy-assignable.
 205   Error &operator=(const Error &Other) = delete;
 206
 207   /// Move-assign an error value. The current error must represent success, you
 208   /// you cannot overwrite an unhandled error. The current error is then
 209   /// considered unchecked. The source error becomes a checked success value,
 210   /// regardless of its original state.
 211   Error &operator=(Error &&Other) {
 212     // Don't allow overwriting of unchecked values.
 213     assertIsChecked();
 214     setPtr(Other.getPtr());
 215
 216     // This Error is unchecked, even if the source error was checked.
 217     setChecked(false);
 218
 219     // Null out Other's payload and set its checked bit.
 220     Other.setPtr(nullptr);
 221     Other.setChecked(true);
 222
 223     return *this;
 224   }
 225
 226   /// Destroy a Error. Fails with a call to abort() if the error is
 227   /// unchecked.
 228   ~Error() {
 229     assertIsChecked();
 230     delete getPtr();
 231   }
 232
 233   /// Bool conversion. Returns true if this Error is in a failure state,
 234   /// and false if it is in an accept state. If the error is in a Success state
 235   /// it will be considered checked.
 236   explicit operator bool() {
 237     setChecked(getPtr() == nullptr);
 238     return getPtr() != nullptr;
 239   }
 240
 241   /// Check whether one error is a subclass of another.
 242   template <typename ErrT> bool isA() const {
 243     return getPtr() && getPtr()->isA(ErrT::classID());
 244   }
 245
 246   /// Returns the dynamic class id of this error, or null if this is a success
 247   /// value.
 248   const void* dynamicClassID() const {
 249     if (!getPtr())
 250       return nullptr;
 251     return getPtr()->dynamicClassID();
 252   }
 253
 254 private:
 255 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
 256   // assertIsChecked() happens very frequently, but under normal circumstances
 257   // is supposed to be a no-op.  So we want it to be inlined, but having a bunch
 258   // of debug prints can cause the function to be too large for inlining.  So
 259   // it's important that we define this function out of line so that it can't be
 260   // inlined.
 261   LLVM_ATTRIBUTE_NORETURN
 262   void fatalUncheckedError() const;
 263 #endif
 264
 265   void assertIsChecked() {
 266 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
 267     if (LLVM_UNLIKELY(!getChecked() || getPtr()))
 268       fatalUncheckedError();
 269 #endif
 270   }
 271
 272   ErrorInfoBase *getPtr() const {
 273     return reinterpret_cast<ErrorInfoBase*>(
 274              reinterpret_cast<uintptr_t>(Payload) &
 275              ~static_cast<uintptr_t>(0x1));
 276   }
 277
 278   void setPtr(ErrorInfoBase *EI) {
 279 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
 280     Payload = reinterpret_cast<ErrorInfoBase*>(
 281                 (reinterpret_cast<uintptr_t>(EI) &
 282                  ~static_cast<uintptr_t>(0x1)) |
 283                 (reinterpret_cast<uintptr_t>(Payload) & 0x1));
 284 #else
 285     Payload = EI;
 286 #endif
 287   }
 288
 289   bool getChecked() const {
 290 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
 291     return (reinterpret_cast<uintptr_t>(Payload) & 0x1) == 0;
 292 #else
 293     return true;
 294 #endif
 295   }
 296
 297   void setChecked(bool V) {
 298     Payload = reinterpret_cast<ErrorInfoBase*>(
 299                 (reinterpret_cast<uintptr_t>(Payload) &
 300                   ~static_cast<uintptr_t>(0x1)) |
 301                   (V ? 0 : 1));
 302   }
 303
 304   std::unique_ptr<ErrorInfoBase> takePayload() {
 305     std::unique_ptr<ErrorInfoBase> Tmp(getPtr());
 306     setPtr(nullptr);
 307     setChecked(true);
 308     return Tmp;
 309   }
 310
 311   friend raw_ostream &operator<<(raw_ostream &OS, const Error &E) {
 312     if (auto P = E.getPtr())
 313       P->log(OS);
 314     else
 315       OS << "success";
 316     return OS;
 317   }
 318
 319   ErrorInfoBase *Payload = nullptr;
 320 };
 321
 322 /// Subclass of Error for the sole purpose of identifying the success path in
 323 /// the type system. This allows to catch invalid conversion to Expected<T> at
 324 /// compile time.
 325 class ErrorSuccess final : public Error {};
 326
 327 inline ErrorSuccess Error::success() { return ErrorSuccess(); }
 328
 329 /// Make a Error instance representing failure using the given error info
 330 /// type.
 331 template <typename ErrT, typename... ArgTs> Error make_error(ArgTs &&... Args) {
 332   return Error(llvm::make_unique<ErrT>(std::forward<ArgTs>(Args)...));
 333 }
 334
 335 /// Base class for user error types. Users should declare their error types
 336 /// like:
 337 ///
 338 /// class MyError : public ErrorInfo<MyError> {
 339 ///   ....
 340 /// };
 341 ///
 342 /// This class provides an implementation of the ErrorInfoBase::kind
 343 /// method, which is used by the Error RTTI system.
 344 template <typename ThisErrT, typename ParentErrT = ErrorInfoBase>
 345 class ErrorInfo : public ParentErrT {
 346 public:
 347   using ParentErrT::ParentErrT; // inherit constructors
 348
 349   static const void *classID() { return &ThisErrT::ID; }
 350
 351   const void *dynamicClassID() const override { return &ThisErrT::ID; }
 352
 353   bool isA(const void *const ClassID) const override {
 354     return ClassID == classID() || ParentErrT::isA(ClassID);
 355   }
 356 };
 357
 358 /// Special ErrorInfo subclass representing a list of ErrorInfos.
 359 /// Instances of this class are constructed by joinError.
 360 class ErrorList final : public ErrorInfo<ErrorList> {
 361   // handleErrors needs to be able to iterate the payload list of an
 362   // ErrorList.
 363   template <typename... HandlerTs>
 364   friend Error handleErrors(Error E, HandlerTs &&... Handlers);
 365
 366   // joinErrors is implemented in terms of join.
 367   friend Error joinErrors(Error, Error);
 368
 369 public:
 370   void log(raw_ostream &OS) const override {
 371     OS << "Multiple errors:\n";
 372     for (auto &ErrPayload : Payloads) {
 373       ErrPayload->log(OS);
 374       OS << "\n";
 375     }
 376   }
 377
 378   std::error_code convertToErrorCode() const override;
 379
 380   // Used by ErrorInfo::classID.
 381   static char ID;
 382
 383 private:
 384   ErrorList(std::unique_ptr<ErrorInfoBase> Payload1,
 385             std::unique_ptr<ErrorInfoBase> Payload2) {
 386     assert(!Payload1->isA<ErrorList>() && !Payload2->isA<ErrorList>() &&
 387            "ErrorList constructor payloads should be singleton errors");
 388     Payloads.push_back(std::move(Payload1));
 389     Payloads.push_back(std::move(Payload2));
 390   }
 391
 392   static Error join(Error E1, Error E2) {
 393     if (!E1)
 394       return E2;
 395     if (!E2)
 396       return E1;
 397     if (E1.isA<ErrorList>()) {
 398       auto &E1List = static_cast<ErrorList &>(*E1.getPtr());
 399       if (E2.isA<ErrorList>()) {
 400         auto E2Payload = E2.takePayload();
 401         auto &E2List = static_cast<ErrorList &>(*E2Payload);
 402         for (auto &Payload : E2List.Payloads)
 403           E1List.Payloads.push_back(std::move(Payload));
 404       } else
 405         E1List.Payloads.push_back(E2.takePayload());
 406
 407       return E1;
 408     }
 409     if (E2.isA<ErrorList>()) {
 410       auto &E2List = static_cast<ErrorList &>(*E2.getPtr());
 411       E2List.Payloads.insert(E2List.Payloads.begin(), E1.takePayload());
 412       return E2;
 413     }
 414     return Error(std::unique_ptr<ErrorList>(
 415         new ErrorList(E1.takePayload(), E2.takePayload())));
 416   }
 417
 418   std::vector<std::unique_ptr<ErrorInfoBase>> Payloads;
 419 };
 420
 421 /// Concatenate errors. The resulting Error is unchecked, and contains the
 422 /// ErrorInfo(s), if any, contained in E1, followed by the
 423 /// ErrorInfo(s), if any, contained in E2.
 424 inline Error joinErrors(Error E1, Error E2) {
 425   return ErrorList::join(std::move(E1), std::move(E2));
 426 }
 427
 428 /// Tagged union holding either a T or a Error.
 429 ///
 430 /// This class parallels ErrorOr, but replaces error_code with Error. Since
 431 /// Error cannot be copied, this class replaces getError() with
 432 /// takeError(). It also adds an bool errorIsA<ErrT>() method for testing the
 433 /// error class type.
 434 template <class T> class LLVM_NODISCARD Expected {
 435   template <class T1> friend class ExpectedAsOutParameter;
 436   template <class OtherT> friend class Expected;
 437
 438   static const bool isRef = std::is_reference<T>::value;
 439
 440   using wrap = std::reference_wrapper<typename std::remove_reference<T>::type>;
 441
 442   using error_type = std::unique_ptr<ErrorInfoBase>;
 443
 444 public:
 445   using storage_type = typename std::conditional<isRef, wrap, T>::type;
 446   using value_type = T;
 447
 448 private:
 449   using reference = typename std::remove_reference<T>::type &;
 450   using const_reference = const typename std::remove_reference<T>::type &;
 451   using pointer = typename std::remove_reference<T>::type *;
 452   using const_pointer = const typename std::remove_reference<T>::type *;
 453
 454 public:
 455   /// Create an Expected<T> error value from the given Error.
 456   Expected(Error Err)
 457       : HasError(true)
 458 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
 459         // Expected is unchecked upon construction in Debug builds.
 460         , Unchecked(true)
 461 #endif
 462   {
 463     assert(Err && "Cannot create Expected<T> from Error success value.");
 464     new (getErrorStorage()) error_type(Err.takePayload());
 465   }
 466
 467   /// Forbid to convert from Error::success() implicitly, this avoids having
 468   /// Expected<T> foo() { return Error::success(); } which compiles otherwise
 469   /// but triggers the assertion above.
 470   Expected(ErrorSuccess) = delete;
 471
 472   /// Create an Expected<T> success value from the given OtherT value, which
 473   /// must be convertible to T.
 474   template <typename OtherT>
 475   Expected(OtherT &&Val,
 476            typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
 477                * = nullptr)
 478       : HasError(false)
 479 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
 480         // Expected is unchecked upon construction in Debug builds.
 481         , Unchecked(true)
 482 #endif
 483   {
 484     new (getStorage()) storage_type(std::forward<OtherT>(Val));
 485   }
 486
 487   /// Move construct an Expected<T> value.
 488   Expected(Expected &&Other) { moveConstruct(std::move(Other)); }
 489
 490   /// Move construct an Expected<T> value from an Expected<OtherT>, where OtherT
 491   /// must be convertible to T.
 492   template <class OtherT>
 493   Expected(Expected<OtherT> &&Other,
 494            typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
 495                * = nullptr) {
 496     moveConstruct(std::move(Other));
 497   }
 498
 499   /// Move construct an Expected<T> value from an Expected<OtherT>, where OtherT
 500   /// isn't convertible to T.
 501   template <class OtherT>
 502   explicit Expected(
 503       Expected<OtherT> &&Other,
 504       typename std::enable_if<!std::is_convertible<OtherT, T>::value>::type * =
 505           nullptr) {
 506     moveConstruct(std::move(Other));
 507   }
 508
 509   /// Move-assign from another Expected<T>.
 510   Expected &operator=(Expected &&Other) {
 511     moveAssign(std::move(Other));
 512     return *this;
 513   }
 514
 515   /// Destroy an Expected<T>.
 516   ~Expected() {
 517     assertIsChecked();
 518     if (!HasError)
 519       getStorage()->~storage_type();
 520     else
 521       getErrorStorage()->~error_type();
 522   }
 523
 524   /// Return false if there is an error.
 525   explicit operator bool() {
 526 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
 527     Unchecked = HasError;
 528 #endif
 529     return !HasError;
 530   }
 531
 532   /// Returns a reference to the stored T value.
 533   reference get() {
 534     assertIsChecked();
 535     return *getStorage();
 536   }
 537
 538   /// Returns a const reference to the stored T value.
 539   const_reference get() const {
 540     assertIsChecked();
 541     return const_cast<Expected<T> *>(this)->get();
 542   }
 543
 544   /// Check that this Expected<T> is an error of type ErrT.
 545   template <typename ErrT> bool errorIsA() const {
 546     return HasError && (*getErrorStorage())->template isA<ErrT>();
 547   }
 548
 549   /// Take ownership of the stored error.
 550   /// After calling this the Expected<T> is in an indeterminate state that can
 551   /// only be safely destructed. No further calls (beside the destructor) should
 552   /// be made on the Expected<T> vaule.
 553   Error takeError() {
 554 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
 555     Unchecked = false;
 556 #endif
 557     return HasError ? Error(std::move(*getErrorStorage())) : Error::success();
 558   }
 559
 560   /// Returns a pointer to the stored T value.
 561   pointer operator->() {
 562     assertIsChecked();
 563     return toPointer(getStorage());
 564   }
 565
 566   /// Returns a const pointer to the stored T value.
 567   const_pointer operator->() const {
 568     assertIsChecked();
 569     return toPointer(getStorage());
 570   }
 571
 572   /// Returns a reference to the stored T value.
 573   reference operator*() {
 574     assertIsChecked();
 575     return *getStorage();
 576   }
 577
 578   /// Returns a const reference to the stored T value.
 579   const_reference operator*() const {
 580     assertIsChecked();
 581     return *getStorage();
 582   }
 583
 584 private:
 585   template <class T1>
 586   static bool compareThisIfSameType(const T1 &a, const T1 &b) {
 587     return &a == &b;
 588   }
 589
 590   template <class T1, class T2>
 591   static bool compareThisIfSameType(const T1 &a, const T2 &b) {
 592     return false;
 593   }
 594
 595   template <class OtherT> void moveConstruct(Expected<OtherT> &&Other) {
 596     HasError = Other.HasError;
 597 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
 598     Unchecked = true;
 599     Other.Unchecked = false;
 600 #endif
 601
 602     if (!HasError)
 603       new (getStorage()) storage_type(std::move(*Other.getStorage()));
 604     else
 605       new (getErrorStorage()) error_type(std::move(*Other.getErrorStorage()));
 606   }
 607
 608   template <class OtherT> void moveAssign(Expected<OtherT> &&Other) {
 609     assertIsChecked();
 610
 611     if (compareThisIfSameType(*this, Other))
 612       return;
 613
 614     this->~Expected();
 615     new (this) Expected(std::move(Other));
 616   }
 617
 618   pointer toPointer(pointer Val) { return Val; }
 619
 620   const_pointer toPointer(const_pointer Val) const { return Val; }
 621
 622   pointer toPointer(wrap *Val) { return &Val->get(); }
 623
 624   const_pointer toPointer(const wrap *Val) const { return &Val->get(); }
 625
 626   storage_type *getStorage() {
 627     assert(!HasError && "Cannot get value when an error exists!");
 628     return reinterpret_cast<storage_type *>(TStorage.buffer);
 629   }
 630
 631   const storage_type *getStorage() const {
 632     assert(!HasError && "Cannot get value when an error exists!");
 633     return reinterpret_cast<const storage_type *>(TStorage.buffer);
 634   }
 635
 636   error_type *getErrorStorage() {
 637     assert(HasError && "Cannot get error when a value exists!");
 638     return reinterpret_cast<error_type *>(ErrorStorage.buffer);
 639   }
 640
 641   const error_type *getErrorStorage() const {
 642     assert(HasError && "Cannot get error when a value exists!");
 643     return reinterpret_cast<const error_type *>(ErrorStorage.buffer);
 644   }
 645
 646   // Used by ExpectedAsOutParameter to reset the checked flag.
 647   void setUnchecked() {
 648 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
 649     Unchecked = true;
 650 #endif
 651   }
 652
 653 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
 654   LLVM_ATTRIBUTE_NORETURN
 655   LLVM_ATTRIBUTE_NOINLINE
 656   void fatalUncheckedExpected() const {
 657     dbgs() << "Expected<T> must be checked before access or destruction.\n";
 658     if (HasError) {
 659       dbgs() << "Unchecked Expected<T> contained error:\n";
 660       (*getErrorStorage())->log(dbgs());
 661     } else
 662       dbgs() << "Expected<T> value was in success state. (Note: Expected<T> "
 663                 "values in success mode must still be checked prior to being "
 664                 "destroyed).\n";
 665     abort();
 666   }
 667 #endif
 668
 669   void assertIsChecked() {
 670 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
 671     if (LLVM_UNLIKELY(Unchecked))
 672       fatalUncheckedExpected();
 673 #endif
 674   }
 675
 676   union {
 677     AlignedCharArrayUnion<storage_type> TStorage;
 678     AlignedCharArrayUnion<error_type> ErrorStorage;
 679   };
 680   bool HasError : 1;
 681 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
 682   bool Unchecked : 1;
 683 #endif
 684 };
 685
 686 /// Report a serious error, calling any installed error handler. See
 687 /// ErrorHandling.h.
 688 LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err,
 689                                                 bool gen_crash_diag = true);
 690
 691 /// Report a fatal error if Err is a failure value.
 692 ///
 693 /// This function can be used to wrap calls to fallible functions ONLY when it
 694 /// is known that the Error will always be a success value. E.g.
 695 ///
 696 ///   @code{.cpp}
 697 ///   // foo only attempts the fallible operation if DoFallibleOperation is
 698 ///   // true. If DoFallibleOperation is false then foo always returns
 699 ///   // Error::success().
 700 ///   Error foo(bool DoFallibleOperation);
 701 ///
 702 ///   cantFail(foo(false));
 703 ///   @endcode
 704 inline void cantFail(Error Err, const char *Msg = nullptr) {
 705   if (Err) {
 706     if (!Msg)
 707       Msg = "Failure value returned from cantFail wrapped call";
 708     llvm_unreachable(Msg);
 709   }
 710 }
 711
 712 /// Report a fatal error if ValOrErr is a failure value, otherwise unwraps and
 713 /// returns the contained value.
 714 ///
 715 /// This function can be used to wrap calls to fallible functions ONLY when it
 716 /// is known that the Error will always be a success value. E.g.
 717 ///
 718 ///   @code{.cpp}
 719 ///   // foo only attempts the fallible operation if DoFallibleOperation is
 720 ///   // true. If DoFallibleOperation is false then foo always returns an int.
 721 ///   Expected<int> foo(bool DoFallibleOperation);
 722 ///
 723 ///   int X = cantFail(foo(false));
 724 ///   @endcode
 725 template <typename T>
 726 T cantFail(Expected<T> ValOrErr, const char *Msg = nullptr) {
 727   if (ValOrErr)
 728     return std::move(*ValOrErr);
 729   else {
 730     if (!Msg)
 731       Msg = "Failure value returned from cantFail wrapped call";
 732     llvm_unreachable(Msg);
 733   }
 734 }
 735
 736 /// Report a fatal error if ValOrErr is a failure value, otherwise unwraps and
 737 /// returns the contained reference.
 738 ///
 739 /// This function can be used to wrap calls to fallible functions ONLY when it
 740 /// is known that the Error will always be a success value. E.g.
 741 ///
 742 ///   @code{.cpp}
 743 ///   // foo only attempts the fallible operation if DoFallibleOperation is
 744 ///   // true. If DoFallibleOperation is false then foo always returns a Bar&.
 745 ///   Expected<Bar&> foo(bool DoFallibleOperation);
 746 ///
 747 ///   Bar &X = cantFail(foo(false));
 748 ///   @endcode
 749 template <typename T>
 750 T& cantFail(Expected<T&> ValOrErr, const char *Msg = nullptr) {
 751   if (ValOrErr)
 752     return *ValOrErr;
 753   else {
 754     if (!Msg)
 755       Msg = "Failure value returned from cantFail wrapped call";
 756     llvm_unreachable(Msg);
 757   }
 758 }
 759
 760 /// Helper for testing applicability of, and applying, handlers for
 761 /// ErrorInfo types.
 762 template <typename HandlerT>
 763 class ErrorHandlerTraits
 764     : public ErrorHandlerTraits<decltype(
 765           &std::remove_reference<HandlerT>::type::operator())> {};
 766
 767 // Specialization functions of the form 'Error (const ErrT&)'.
 768 template <typename ErrT> class ErrorHandlerTraits<Error (&)(ErrT &)> {
 769 public:
 770   static bool appliesTo(const ErrorInfoBase &E) {
 771     return E.template isA<ErrT>();
 772   }
 773
 774   template <typename HandlerT>
 775   static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
 776     assert(appliesTo(*E) && "Applying incorrect handler");
 777     return H(static_cast<ErrT &>(*E));
 778   }
 779 };
 780
 781 // Specialization functions of the form 'void (const ErrT&)'.
 782 template <typename ErrT> class ErrorHandlerTraits<void (&)(ErrT &)> {
 783 public:
 784   static bool appliesTo(const ErrorInfoBase &E) {
 785     return E.template isA<ErrT>();
 786   }
 787
 788   template <typename HandlerT>
 789   static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
 790     assert(appliesTo(*E) && "Applying incorrect handler");
 791     H(static_cast<ErrT &>(*E));
 792     return Error::success();
 793   }
 794 };
 795
 796 /// Specialization for functions of the form 'Error (std::unique_ptr<ErrT>)'.
 797 template <typename ErrT>
 798 class ErrorHandlerTraits<Error (&)(std::unique_ptr<ErrT>)> {
 799 public:
 800   static bool appliesTo(const ErrorInfoBase &E) {
 801     return E.template isA<ErrT>();
 802   }
 803
 804   template <typename HandlerT>
 805   static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
 806     assert(appliesTo(*E) && "Applying incorrect handler");
 807     std::unique_ptr<ErrT> SubE(static_cast<ErrT *>(E.release()));
 808     return H(std::move(SubE));
 809   }
 810 };
 811
 812 /// Specialization for functions of the form 'void (std::unique_ptr<ErrT>)'.
 813 template <typename ErrT>
 814 class ErrorHandlerTraits<void (&)(std::unique_ptr<ErrT>)> {
 815 public:
 816   static bool appliesTo(const ErrorInfoBase &E) {
 817     return E.template isA<ErrT>();
 818   }
 819
 820   template <typename HandlerT>
 821   static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
 822     assert(appliesTo(*E) && "Applying incorrect handler");
 823     std::unique_ptr<ErrT> SubE(static_cast<ErrT *>(E.release()));
 824     H(std::move(SubE));
 825     return Error::success();
 826   }
 827 };
 828
 829 // Specialization for member functions of the form 'RetT (const ErrT&)'.
 830 template <typename C, typename RetT, typename ErrT>
 831 class ErrorHandlerTraits<RetT (C::*)(ErrT &)>
 832     : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
 833
 834 // Specialization for member functions of the form 'RetT (const ErrT&) const'.
 835 template <typename C, typename RetT, typename ErrT>
 836 class ErrorHandlerTraits<RetT (C::*)(ErrT &) const>
 837     : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
 838
 839 // Specialization for member functions of the form 'RetT (const ErrT&)'.
 840 template <typename C, typename RetT, typename ErrT>
 841 class ErrorHandlerTraits<RetT (C::*)(const ErrT &)>
 842     : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
 843
 844 // Specialization for member functions of the form 'RetT (const ErrT&) const'.
 845 template <typename C, typename RetT, typename ErrT>
 846 class ErrorHandlerTraits<RetT (C::*)(const ErrT &) const>
 847     : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
 848
 849 /// Specialization for member functions of the form
 850 /// 'RetT (std::unique_ptr<ErrT>)'.
 851 template <typename C, typename RetT, typename ErrT>
 852 class ErrorHandlerTraits<RetT (C::*)(std::unique_ptr<ErrT>)>
 853     : public ErrorHandlerTraits<RetT (&)(std::unique_ptr<ErrT>)> {};
 854
 855 /// Specialization for member functions of the form
 856 /// 'RetT (std::unique_ptr<ErrT>) const'.
 857 template <typename C, typename RetT, typename ErrT>
 858 class ErrorHandlerTraits<RetT (C::*)(std::unique_ptr<ErrT>) const>
 859     : public ErrorHandlerTraits<RetT (&)(std::unique_ptr<ErrT>)> {};
 860
 861 inline Error handleErrorImpl(std::unique_ptr<ErrorInfoBase> Payload) {
 862   return Error(std::move(Payload));
 863 }
 864
 865 template <typename HandlerT, typename... HandlerTs>
 866 Error handleErrorImpl(std::unique_ptr<ErrorInfoBase> Payload,
 867                       HandlerT &&Handler, HandlerTs &&... Handlers) {
 868   if (ErrorHandlerTraits<HandlerT>::appliesTo(*Payload))
 869     return ErrorHandlerTraits<HandlerT>::apply(std::forward<HandlerT>(Handler),
 870                                                std::move(Payload));
 871   return handleErrorImpl(std::move(Payload),
 872                          std::forward<HandlerTs>(Handlers)...);
 873 }
 874
 875 /// Pass the ErrorInfo(s) contained in E to their respective handlers. Any
 876 /// unhandled errors (or Errors returned by handlers) are re-concatenated and
 877 /// returned.
 878 /// Because this function returns an error, its result must also be checked
 879 /// or returned. If you intend to handle all errors use handleAllErrors
 880 /// (which returns void, and will abort() on unhandled errors) instead.
 881 template <typename... HandlerTs>
 882 Error handleErrors(Error E, HandlerTs &&... Hs) {
 883   if (!E)
 884     return Error::success();
 885
 886   std::unique_ptr<ErrorInfoBase> Payload = E.takePayload();
 887
 888   if (Payload->isA<ErrorList>()) {
 889     ErrorList &List = static_cast<ErrorList &>(*Payload);
 890     Error R;
 891     for (auto &P : List.Payloads)
 892       R = ErrorList::join(
 893           std::move(R),
 894           handleErrorImpl(std::move(P), std::forward<HandlerTs>(Hs)...));
 895     return R;
 896   }
 897
 898   return handleErrorImpl(std::move(Payload), std::forward<HandlerTs>(Hs)...);
 899 }
 900
 901 /// Behaves the same as handleErrors, except that by contract all errors
 902 /// *must* be handled by the given handlers (i.e. there must be no remaining
 903 /// errors after running the handlers, or llvm_unreachable is called).
 904 template <typename... HandlerTs>
 905 void handleAllErrors(Error E, HandlerTs &&... Handlers) {
 906   cantFail(handleErrors(std::move(E), std::forward<HandlerTs>(Handlers)...));
 907 }
 908
 909 /// Check that E is a non-error, then drop it.
 910 /// If E is an error, llvm_unreachable will be called.
 911 inline void handleAllErrors(Error E) {
 912   cantFail(std::move(E));
 913 }
 914
 915 /// Handle any errors (if present) in an Expected<T>, then try a recovery path.
 916 ///
 917 /// If the incoming value is a success value it is returned unmodified. If it
 918 /// is a failure value then it the contained error is passed to handleErrors.
 919 /// If handleErrors is able to handle the error then the RecoveryPath functor
 920 /// is called to supply the final result. If handleErrors is not able to
 921 /// handle all errors then the unhandled errors are returned.
 922 ///
 923 /// This utility enables the follow pattern:
 924 ///
 925 ///   @code{.cpp}
 926 ///   enum FooStrategy { Aggressive, Conservative };
 927 ///   Expected<Foo> foo(FooStrategy S);
 928 ///
 929 ///   auto ResultOrErr =
 930 ///     handleExpected(
 931 ///       foo(Aggressive),
 932 ///       []() { return foo(Conservative); },
 933 ///       [](AggressiveStrategyError&) {
 934 ///         // Implicitly conusme this - we'll recover by using a conservative
 935 ///         // strategy.
 936 ///       });
 937 ///
 938 ///   @endcode
 939 template <typename T, typename RecoveryFtor, typename... HandlerTs>
 940 Expected<T> handleExpected(Expected<T> ValOrErr, RecoveryFtor &&RecoveryPath,
 941                            HandlerTs &&... Handlers) {
 942   if (ValOrErr)
 943     return ValOrErr;
 944
 945   if (auto Err = handleErrors(ValOrErr.takeError(),
 946                               std::forward<HandlerTs>(Handlers)...))
 947     return std::move(Err);
 948
 949   return RecoveryPath();
 950 }
 951
 952 /// Log all errors (if any) in E to OS. If there are any errors, ErrorBanner
 953 /// will be printed before the first one is logged. A newline will be printed
 954 /// after each error.
 955 ///
 956 /// This function is compatible with the helpers from Support/WithColor.h. You
 957 /// can pass any of them as the OS. Please consider using them instead of
 958 /// including 'error: ' in the ErrorBanner.
 959 ///
 960 /// This is useful in the base level of your program to allow clean termination
 961 /// (allowing clean deallocation of resources, etc.), while reporting error
 962 /// information to the user.
 963 void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner = {});
 964
 965 /// Write all error messages (if any) in E to a string. The newline character
 966 /// is used to separate error messages.
 967 inline std::string toString(Error E) {
 968   SmallVector<std::string, 2> Errors;
 969   handleAllErrors(std::move(E), [&Errors](const ErrorInfoBase &EI) {
 970     Errors.push_back(EI.message());
 971   });
 972   return join(Errors.begin(), Errors.end(), "\n");
 973 }
 974
 975 /// Consume a Error without doing anything. This method should be used
 976 /// only where an error can be considered a reasonable and expected return
 977 /// value.
 978 ///
 979 /// Uses of this method are potentially indicative of design problems: If it's
 980 /// legitimate to do nothing while processing an "error", the error-producer
 981 /// might be more clearly refactored to return an Optional<T>.
 982 inline void consumeError(Error Err) {
 983   handleAllErrors(std::move(Err), [](const ErrorInfoBase &) {});
 984 }
 985
 986 /// Helper for converting an Error to a bool.
 987 ///
 988 /// This method returns true if Err is in an error state, or false if it is
 989 /// in a success state.  Puts Err in a checked state in both cases (unlike
 990 /// Error::operator bool(), which only does this for success states).
 991 inline bool errorToBool(Error Err) {
 992   bool IsError = static_cast<bool>(Err);
 993   if (IsError)
 994     consumeError(std::move(Err));
 995   return IsError;
 996 }
 997
 998 /// Helper for Errors used as out-parameters.
 999 ///
1000 /// This helper is for use with the Error-as-out-parameter idiom, where an error
1001 /// is passed to a function or method by reference, rather than being returned.
1002 /// In such cases it is helpful to set the checked bit on entry to the function
1003 /// so that the error can be written to (unchecked Errors abort on assignment)
1004 /// and clear the checked bit on exit so that clients cannot accidentally forget
1005 /// to check the result. This helper performs these actions automatically using
1006 /// RAII:
1007 ///
1008 ///   @code{.cpp}
1009 ///   Result foo(Error &Err) {
1010 ///     ErrorAsOutParameter ErrAsOutParam(&Err); // 'Checked' flag set
1011 ///     // <body of foo>
1012 ///     // <- 'Checked' flag auto-cleared when ErrAsOutParam is destructed.
1013 ///   }
1014 ///   @endcode
1015 ///
1016 /// ErrorAsOutParameter takes an Error* rather than Error& so that it can be
1017 /// used with optional Errors (Error pointers that are allowed to be null). If
1018 /// ErrorAsOutParameter took an Error reference, an instance would have to be
1019 /// created inside every condition that verified that Error was non-null. By
1020 /// taking an Error pointer we can just create one instance at the top of the
1021 /// function.
1022 class ErrorAsOutParameter {
1023 public:
1024   ErrorAsOutParameter(Error *Err) : Err(Err) {
1025     // Raise the checked bit if Err is success.
1026     if (Err)
1027       (void)!!*Err;
1028   }
1029
1030   ~ErrorAsOutParameter() {
1031     // Clear the checked bit.
1032     if (Err && !*Err)
1033       *Err = Error::success();
1034   }
1035
1036 private:
1037   Error *Err;
1038 };
1039
1040 /// Helper for Expected<T>s used as out-parameters.
1041 ///
1042 /// See ErrorAsOutParameter.
1043 template <typename T>
1044 class ExpectedAsOutParameter {
1045 public:
1046   ExpectedAsOutParameter(Expected<T> *ValOrErr)
1047     : ValOrErr(ValOrErr) {
1048     if (ValOrErr)
1049       (void)!!*ValOrErr;
1050   }
1051
1052   ~ExpectedAsOutParameter() {
1053     if (ValOrErr)
1054       ValOrErr->setUnchecked();
1055   }
1056
1057 private:
1058   Expected<T> *ValOrErr;
1059 };
1060
1061 /// This class wraps a std::error_code in a Error.
1062 ///
1063 /// This is useful if you're writing an interface that returns a Error
1064 /// (or Expected) and you want to call code that still returns
1065 /// std::error_codes.
1066 class ECError : public ErrorInfo<ECError> {
1067   friend Error errorCodeToError(std::error_code);
1068
1069   virtual void anchor() override;
1070
1071 public:
1072   void setErrorCode(std::error_code EC) { this->EC = EC; }
1073   std::error_code convertToErrorCode() const override { return EC; }
1074   void log(raw_ostream &OS) const override { OS << EC.message(); }
1075
1076   // Used by ErrorInfo::classID.
1077   static char ID;
1078
1079 protected:
1080   ECError() = default;
1081   ECError(std::error_code EC) : EC(EC) {}
1082
1083   std::error_code EC;
1084 };
1085
1086 /// The value returned by this function can be returned from convertToErrorCode
1087 /// for Error values where no sensible translation to std::error_code exists.
1088 /// It should only be used in this situation, and should never be used where a
1089 /// sensible conversion to std::error_code is available, as attempts to convert
1090 /// to/from this error will result in a fatal error. (i.e. it is a programmatic
1091 ///error to try to convert such a value).
1092 std::error_code inconvertibleErrorCode();
1093
1094 /// Helper for converting an std::error_code to a Error.
1095 Error errorCodeToError(std::error_code EC);
1096
1097 /// Helper for converting an ECError to a std::error_code.
1098 ///
1099 /// This method requires that Err be Error() or an ECError, otherwise it
1100 /// will trigger a call to abort().
1101 std::error_code errorToErrorCode(Error Err);
1102
1103 /// Convert an ErrorOr<T> to an Expected<T>.
1104 template <typename T> Expected<T> errorOrToExpected(ErrorOr<T> &&EO) {
1105   if (auto EC = EO.getError())
1106     return errorCodeToError(EC);
1107   return std::move(*EO);
1108 }
1109
1110 /// Convert an Expected<T> to an ErrorOr<T>.
1111 template <typename T> ErrorOr<T> expectedToErrorOr(Expected<T> &&E) {
1112   if (auto Err = E.takeError())
1113     return errorToErrorCode(std::move(Err));
1114   return std::move(*E);
1115 }
1116
1117 /// This class wraps a string in an Error.
1118 ///
1119 /// StringError is useful in cases where the client is not expected to be able
1120 /// to consume the specific error message programmatically (for example, if the
1121 /// error message is to be presented to the user).
1122 ///
1123 /// StringError can also be used when additional information is to be printed
1124 /// along with a error_code message. Depending on the constructor called, this
1125 /// class can either display:
1126 ///    1. the error_code message (ECError behavior)
1127 ///    2. a string
1128 ///    3. the error_code message and a string
1129 ///
1130 /// These behaviors are useful when subtyping is required; for example, when a
1131 /// specific library needs an explicit error type. In the example below,
1132 /// PDBError is derived from StringError:
1133 ///
1134 ///   @code{.cpp}
1135 ///   Expected<int> foo() {
1136 ///      return llvm::make_error<PDBError>(pdb_error_code::dia_failed_loading,
1137 ///                                        "Additional information");
1138 ///   }
1139 ///   @endcode
1140 ///
1141 class StringError : public ErrorInfo<StringError> {
1142 public:
1143   static char ID;
1144
1145   // Prints EC + S and converts to EC
1146   StringError(std::error_code EC, const Twine &S = Twine());
1147
1148   // Prints S and converts to EC
1149   StringError(const Twine &S, std::error_code EC);
1150
1151   void log(raw_ostream &OS) const override;
1152   std::error_code convertToErrorCode() const override;
1153
1154   const std::string &getMessage() const { return Msg; }
1155
1156 private:
1157   std::string Msg;
1158   std::error_code EC;
1159   const bool PrintMsgOnly = false;
1160 };
1161
1162 /// Create formatted StringError object.
1163 template <typename... Ts>
1164 Error createStringError(std::error_code EC, char const *Fmt,
1165                         const Ts &... Vals) {
1166   std::string Buffer;
1167   raw_string_ostream Stream(Buffer);
1168   Stream << format(Fmt, Vals...);
1169   return make_error<StringError>(Stream.str(), EC);
1170 }
1171
1172 Error createStringError(std::error_code EC, char const *Msg);
1173
1174 /// This class wraps a filename and another Error.
1175 ///
1176 /// In some cases, an error needs to live along a 'source' name, in order to
1177 /// show more detailed information to the user.
1178 class FileError final : public ErrorInfo<FileError> {
1179
1180   friend Error createFileError(std::string, Error);
1181
1182 public:
1183   void log(raw_ostream &OS) const override {
1184     assert(Err && !FileName.empty() && "Trying to log after takeError().");
1185     OS << "'" << FileName << "': ";
1186     Err->log(OS);
1187   }
1188
1189   Error takeError() { return Error(std::move(Err)); }
1190
1191   std::error_code convertToErrorCode() const override;
1192
1193   // Used by ErrorInfo::classID.
1194   static char ID;
1195
1196 private:
1197   FileError(std::string F, std::unique_ptr<ErrorInfoBase> E) {
1198     assert(E && "Cannot create FileError from Error success value.");
1199     assert(!F.empty() &&
1200            "The file name provided to FileError must not be empty.");
1201     FileName = F;
1202     Err = std::move(E);
1203   }
1204
1205   static Error build(std::string F, Error E) {
1206     return Error(std::unique_ptr<FileError>(new FileError(F, E.takePayload())));
1207   }
1208
1209   std::string FileName;
1210   std::unique_ptr<ErrorInfoBase> Err;
1211 };
1212
1213 /// Concatenate a source file path and/or name with an Error. The resulting
1214 /// Error is unchecked.
1215 inline Error createFileError(std::string F, Error E) {
1216   return FileError::build(F, std::move(E));
1217 }
1218
1219 Error createFileError(std::string F, ErrorSuccess) = delete;
1220
1221 /// Helper for check-and-exit error handling.
1222 ///
1223 /// For tool use only. NOT FOR USE IN LIBRARY CODE.
1224 ///
1225 class ExitOnError {
1226 public:
1227   /// Create an error on exit helper.
1228   ExitOnError(std::string Banner = "", int DefaultErrorExitCode = 1)
1229       : Banner(std::move(Banner)),
1230         GetExitCode([=](const Error &) { return DefaultErrorExitCode; }) {}
1231
1232   /// Set the banner string for any errors caught by operator().
1233   void setBanner(std::string Banner) { this->Banner = std::move(Banner); }
1234
1235   /// Set the exit-code mapper function.
1236   void setExitCodeMapper(std::function<int(const Error &)> GetExitCode) {
1237     this->GetExitCode = std::move(GetExitCode);
1238   }
1239
1240   /// Check Err. If it's in a failure state log the error(s) and exit.
1241   void operator()(Error Err) const { checkError(std::move(Err)); }
1242
1243   /// Check E. If it's in a success state then return the contained value. If
1244   /// it's in a failure state log the error(s) and exit.
1245   template <typename T> T operator()(Expected<T> &&E) const {
1246     checkError(E.takeError());
1247     return std::move(*E);
1248   }
1249
1250   /// Check E. If it's in a success state then return the contained reference. If
1251   /// it's in a failure state log the error(s) and exit.
1252   template <typename T> T& operator()(Expected<T&> &&E) const {
1253     checkError(E.takeError());
1254     return *E;
1255   }
1256
1257 private:
1258   void checkError(Error Err) const {
1259     if (Err) {
1260       int ExitCode = GetExitCode(Err);
1261       logAllUnhandledErrors(std::move(Err), errs(), Banner);
1262       exit(ExitCode);
1263     }
1264   }
1265
1266   std::string Banner;
1267   std::function<int(const Error &)> GetExitCode;
1268 };
1269
1270 /// Conversion from Error to LLVMErrorRef for C error bindings.
1271 inline LLVMErrorRef wrap(Error Err) {
1272   return reinterpret_cast<LLVMErrorRef>(Err.takePayload().release());
1273 }
1274
1275 /// Conversion from LLVMErrorRef to Error for C error bindings.
1276 inline Error unwrap(LLVMErrorRef ErrRef) {
1277   return Error(std::unique_ptr<ErrorInfoBase>(
1278       reinterpret_cast<ErrorInfoBase *>(ErrRef)));
1279 }
1280
1281 } // end namespace llvm
1282
1283 #endif // LLVM_SUPPORT_ERROR_H