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