LLVM  8.0.0svn
Error.h
Go to the documentation of this file.
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"
27 #include "llvm/Support/ErrorOr.h"
28 #include "llvm/Support/Format.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.
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.
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.
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 
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.
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>
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(
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>.
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.
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
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 {
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.
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>
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) {
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) {
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.
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 
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>
1045 public:
1047  : ValOrErr(ValOrErr) {
1048  if (ValOrErr)
1049  (void)!!*ValOrErr;
1050  }
1051 
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 public:
1070  void setErrorCode(std::error_code EC) { this->EC = EC; }
1071  std::error_code convertToErrorCode() const override { return EC; }
1072  void log(raw_ostream &OS) const override { OS << EC.message(); }
1073 
1074  // Used by ErrorInfo::classID.
1075  static char ID;
1076 
1077 protected:
1078  ECError() = default;
1079  ECError(std::error_code EC) : EC(EC) {}
1080 
1081  std::error_code EC;
1082 };
1083 
1084 /// The value returned by this function can be returned from convertToErrorCode
1085 /// for Error values where no sensible translation to std::error_code exists.
1086 /// It should only be used in this situation, and should never be used where a
1087 /// sensible conversion to std::error_code is available, as attempts to convert
1088 /// to/from this error will result in a fatal error. (i.e. it is a programmatic
1089 ///error to try to convert such a value).
1090 std::error_code inconvertibleErrorCode();
1091 
1092 /// Helper for converting an std::error_code to a Error.
1093 Error errorCodeToError(std::error_code EC);
1094 
1095 /// Helper for converting an ECError to a std::error_code.
1096 ///
1097 /// This method requires that Err be Error() or an ECError, otherwise it
1098 /// will trigger a call to abort().
1099 std::error_code errorToErrorCode(Error Err);
1100 
1101 /// Convert an ErrorOr<T> to an Expected<T>.
1102 template <typename T> Expected<T> errorOrToExpected(ErrorOr<T> &&EO) {
1103  if (auto EC = EO.getError())
1104  return errorCodeToError(EC);
1105  return std::move(*EO);
1106 }
1107 
1108 /// Convert an Expected<T> to an ErrorOr<T>.
1109 template <typename T> ErrorOr<T> expectedToErrorOr(Expected<T> &&E) {
1110  if (auto Err = E.takeError())
1111  return errorToErrorCode(std::move(Err));
1112  return std::move(*E);
1113 }
1114 
1115 /// This class wraps a string in an Error.
1116 ///
1117 /// StringError is useful in cases where the client is not expected to be able
1118 /// to consume the specific error message programmatically (for example, if the
1119 /// error message is to be presented to the user).
1120 ///
1121 /// StringError can also be used when additional information is to be printed
1122 /// along with a error_code message. Depending on the constructor called, this
1123 /// class can either display:
1124 /// 1. the error_code message (ECError behavior)
1125 /// 2. a string
1126 /// 3. the error_code message and a string
1127 ///
1128 /// These behaviors are useful when subtyping is required; for example, when a
1129 /// specific library needs an explicit error type. In the example below,
1130 /// PDBError is derived from StringError:
1131 ///
1132 /// @code{.cpp}
1133 /// Expected<int> foo() {
1134 /// return llvm::make_error<PDBError>(pdb_error_code::dia_failed_loading,
1135 /// "Additional information");
1136 /// }
1137 /// @endcode
1138 ///
1139 class StringError : public ErrorInfo<StringError> {
1140 public:
1141  static char ID;
1142 
1143  // Prints EC + S and converts to EC
1144  StringError(std::error_code EC, const Twine &S = Twine());
1145 
1146  // Prints S and converts to EC
1147  StringError(const Twine &S, std::error_code EC);
1148 
1149  void log(raw_ostream &OS) const override;
1150  std::error_code convertToErrorCode() const override;
1151 
1152  const std::string &getMessage() const { return Msg; }
1153 
1154 private:
1155  std::string Msg;
1156  std::error_code EC;
1157  const bool PrintMsgOnly = false;
1158 };
1159 
1160 /// Create formatted StringError object.
1161 template <typename... Ts>
1162 Error createStringError(std::error_code EC, char const *Fmt,
1163  const Ts &... Vals) {
1164  std::string Buffer;
1165  raw_string_ostream Stream(Buffer);
1166  Stream << format(Fmt, Vals...);
1167  return make_error<StringError>(Stream.str(), EC);
1168 }
1169 
1170 Error createStringError(std::error_code EC, char const *Msg);
1171 
1172 /// This class wraps a filename and another Error.
1173 ///
1174 /// In some cases, an error needs to live along a 'source' name, in order to
1175 /// show more detailed information to the user.
1176 class FileError final : public ErrorInfo<FileError> {
1177 
1178  friend Error createFileError(std::string, Error);
1179 
1180 public:
1181  void log(raw_ostream &OS) const override {
1182  assert(Err && !FileName.empty() && "Trying to log after takeError().");
1183  OS << "'" << FileName << "': ";
1184  Err->log(OS);
1185  }
1186 
1187  Error takeError() { return Error(std::move(Err)); }
1188 
1189  std::error_code convertToErrorCode() const override;
1190 
1191  // Used by ErrorInfo::classID.
1192  static char ID;
1193 
1194 private:
1195  FileError(std::string F, std::unique_ptr<ErrorInfoBase> E) {
1196  assert(E && "Cannot create FileError from Error success value.");
1197  assert(!F.empty() &&
1198  "The file name provided to FileError must not be empty.");
1199  FileName = F;
1200  Err = std::move(E);
1201  }
1202 
1203  static Error build(std::string F, Error E) {
1204  return Error(std::unique_ptr<FileError>(new FileError(F, E.takePayload())));
1205  }
1206 
1207  std::string FileName;
1208  std::unique_ptr<ErrorInfoBase> Err;
1209 };
1210 
1211 /// Concatenate a source file path and/or name with an Error. The resulting
1212 /// Error is unchecked.
1213 inline Error createFileError(std::string F, Error E) {
1214  return FileError::build(F, std::move(E));
1215 }
1216 
1217 Error createFileError(std::string F, ErrorSuccess) = delete;
1218 
1219 /// Helper for check-and-exit error handling.
1220 ///
1221 /// For tool use only. NOT FOR USE IN LIBRARY CODE.
1222 ///
1224 public:
1225  /// Create an error on exit helper.
1226  ExitOnError(std::string Banner = "", int DefaultErrorExitCode = 1)
1227  : Banner(std::move(Banner)),
1228  GetExitCode([=](const Error &) { return DefaultErrorExitCode; }) {}
1229 
1230  /// Set the banner string for any errors caught by operator().
1231  void setBanner(std::string Banner) { this->Banner = std::move(Banner); }
1232 
1233  /// Set the exit-code mapper function.
1234  void setExitCodeMapper(std::function<int(const Error &)> GetExitCode) {
1235  this->GetExitCode = std::move(GetExitCode);
1236  }
1237 
1238  /// Check Err. If it's in a failure state log the error(s) and exit.
1239  void operator()(Error Err) const { checkError(std::move(Err)); }
1240 
1241  /// Check E. If it's in a success state then return the contained value. If
1242  /// it's in a failure state log the error(s) and exit.
1243  template <typename T> T operator()(Expected<T> &&E) const {
1244  checkError(E.takeError());
1245  return std::move(*E);
1246  }
1247 
1248  /// Check E. If it's in a success state then return the contained reference. If
1249  /// it's in a failure state log the error(s) and exit.
1250  template <typename T> T& operator()(Expected<T&> &&E) const {
1251  checkError(E.takeError());
1252  return *E;
1253  }
1254 
1255 private:
1256  void checkError(Error Err) const {
1257  if (Err) {
1258  int ExitCode = GetExitCode(Err);
1259  logAllUnhandledErrors(std::move(Err), errs(), Banner);
1260  exit(ExitCode);
1261  }
1262  }
1263 
1264  std::string Banner;
1265  std::function<int(const Error &)> GetExitCode;
1266 };
1267 
1268 /// Conversion from Error to LLVMErrorRef for C error bindings.
1269 inline LLVMErrorRef wrap(Error Err) {
1270  return reinterpret_cast<LLVMErrorRef>(Err.takePayload().release());
1271 }
1272 
1273 /// Conversion from LLVMErrorRef to Error for C error bindings.
1274 inline Error unwrap(LLVMErrorRef ErrRef) {
1275  return Error(std::unique_ptr<ErrorInfoBase>(
1276  reinterpret_cast<ErrorInfoBase *>(ErrRef)));
1277 }
1278 
1279 } // end namespace llvm
1280 
1281 #endif // LLVM_SUPPORT_ERROR_H
reference operator*()
Returns a reference to the stored T value.
Definition: Error.h:573
static const void * classID()
Definition: Error.h:71
void cantFail(Error Err, const char *Msg=nullptr)
Report a fatal error if Err is a failure value.
Definition: Error.h:704
uint64_t CallInst * C
bool errorIsA() const
Check that this Expected<T> is an error of type ErrT.
Definition: Error.h:545
Represents either an error or a value T.
Definition: ErrorOr.h:57
raw_ostream & errs()
This returns a reference to a raw_ostream for standard error.
Error make_error(ArgTs &&... Args)
Make a Error instance representing failure using the given error info type.
Definition: Error.h:331
const void * dynamicClassID() const
Returns the dynamic class id of this error, or null if this is a success value.
Definition: Error.h:248
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:139
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
Subclass of Error for the sole purpose of identifying the success path in the type system...
Definition: Error.h:325
AlignedCharArrayUnion< storage_type > TStorage
Definition: Error.h:677
bool isA() const
Definition: Error.h:83
Helper for check-and-exit error handling.
Definition: Error.h:1223
format_object< Ts... > format(const char *Fmt, const Ts &... Vals)
These are helper functions used to produce formatted output.
Definition: Format.h:124
void log(raw_ostream &OS) const override
Print an error message to an output stream.
Definition: Error.h:1181
static const char * getPtr(const MachOObjectFile &O, size_t Offset)
T & operator()(Expected< T &> &&E) const
Check E.
Definition: Error.h:1250
static bool appliesTo(const ErrorInfoBase &E)
Definition: Error.h:816
Helper for Expected<T>s used as out-parameters.
Definition: Error.h:1044
virtual std::string message() const
Return the error message as a string.
Definition: Error.h:57
void log(raw_ostream &OS) const override
Print an error message to an output stream.
Definition: Error.h:370
ErrorOr< T > expectedToErrorOr(Expected< T > &&E)
Convert an Expected<T> to an ErrorOr<T>.
Definition: Error.h:1109
pointer operator->()
Returns a pointer to the stored T value.
Definition: Error.h:561
F(f)
block Block Frequency true
Error takeError()
Take ownership of the stored error.
Definition: Error.h:553
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:940
Base class for error info classes.
Definition: Error.h:49
std::error_code convertToErrorCode() const override
Convert this error to a std::error_code.
Definition: Error.h:1071
#define LLVM_ATTRIBUTE_NOINLINE
Definition: Compiler.h:70
Expected(Expected< OtherT > &&Other, typename std::enable_if<!std::is_convertible< OtherT, T >::value >::type *=nullptr)
Move construct an Expected<T> value from an Expected<OtherT>, where OtherT isn&#39;t convertible to T...
Definition: Error.h:502
#define LLVM_UNLIKELY(EXPR)
Definition: Compiler.h:192
#define LLVM_NODISCARD
LLVM_NODISCARD - Warn if a type or return value is discarded.
Definition: Compiler.h:129
static Error apply(HandlerT &&H, std::unique_ptr< ErrorInfoBase > E)
Definition: Error.h:805
This class wraps a filename and another Error.
Definition: Error.h:1176
Definition: BitVector.h:938
std::string toString(Error E)
Write all error messages (if any) in E to a string.
Definition: Error.h:967
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
Attribute unwrap(LLVMAttributeRef Attr)
Definition: Attributes.h:195
~Error()
Destroy a Error.
Definition: Error.h:228
Expected(Expected &&Other)
Move construct an Expected<T> value.
Definition: Error.h:488
Expected(Expected< OtherT > &&Other, typename std::enable_if< std::is_convertible< OtherT, T >::value >::type *=nullptr)
Move construct an Expected<T> value from an Expected<OtherT>, where OtherT must be convertible to T...
Definition: Error.h:493
virtual void log(raw_ostream &OS) const =0
Print an error message to an output stream.
static char ID
Definition: Error.h:381
Error takeError()
Definition: Error.h:1187
void apply(Opt *O, const Mod &M, const Mods &... Ms)
Definition: CommandLine.h:1182
std::string join(IteratorT Begin, IteratorT End, StringRef Separator)
Joins the strings in the range [Begin, End), adding Separator between the elements.
Definition: StringExtras.h:371
~Expected()
Destroy an Expected<T>.
Definition: Error.h:516
Tagged union holding either a T or a Error.
Definition: CachePruning.h:23
virtual ~ErrorInfoBase()=default
ELFYAML::ELF_STO Other
Definition: ELFYAML.cpp:775
const_reference operator*() const
Returns a const reference to the stored T value.
Definition: Error.h:579
Error createFileError(std::string F, Error E)
Concatenate a source file path and/or name with an Error.
Definition: Error.h:1213
const void * dynamicClassID() const override
Definition: Error.h:351
#define T
Error & operator=(Error &&Other)
Move-assign an error value.
Definition: Error.h:211
ErrorAsOutParameter(Error *Err)
Definition: Error.h:1024
virtual const void * dynamicClassID() const =0
struct LLVMOpaqueError * LLVMErrorRef
Opaque reference to an error instance.
Definition: Error.h:26
Error build(ArrayRef< Module *> Mods, SmallVector< char, 0 > &Symtab, StringTableBuilder &StrtabBuilder, BumpPtrAllocator &Alloc)
Fills in Symtab and StrtabBuilder with a valid symbol and string table for Mods.
Definition: IRSymtab.cpp:323
ECError(std::error_code EC)
Definition: Error.h:1079
void setExitCodeMapper(std::function< int(const Error &)> GetExitCode)
Set the exit-code mapper function.
Definition: Error.h:1234
#define P(N)
const_pointer operator->() const
Returns a const pointer to the stored T value.
Definition: Error.h:567
Expected(Error Err)
Create an Expected<T> error value from the given Error.
Definition: Error.h:456
* if(!EatIfPresent(lltok::kw_thread_local)) return false
ParseOptionalThreadLocal := /*empty.
void operator()(Error Err) const
Check Err. If it&#39;s in a failure state log the error(s) and exit.
Definition: Error.h:1239
AlignedCharArrayUnion< error_type > ErrorStorage
Definition: Error.h:678
bool errorToBool(Error Err)
Helper for converting an Error to a bool.
Definition: Error.h:991
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
Error errorCodeToError(std::error_code EC)
Helper for converting an std::error_code to a Error.
Definition: Error.cpp:87
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator begin()
Definition: SmallVector.h:129
#define H(x, y, z)
Definition: MD5.cpp:57
ExitOnError(std::string Banner="", int DefaultErrorExitCode=1)
Create an error on exit helper.
Definition: Error.h:1226
Expected< T > errorOrToExpected(ErrorOr< T > &&EO)
Convert an ErrorOr<T> to an Expected<T>.
Definition: Error.h:1102
void consumeError(Error Err)
Consume a Error without doing anything.
Definition: Error.h:982
void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner={})
Log all errors (if any) in E to OS.
Definition: Error.cpp:61
const std::string & getMessage() const
Definition: Error.h:1152
std::string & str()
Flushes the stream contents to the target string and returns the string&#39;s reference.
Definition: raw_ostream.h:499
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
static Error apply(HandlerT &&H, std::unique_ptr< ErrorInfoBase > E)
Definition: Error.h:775
Special ErrorInfo subclass representing a list of ErrorInfos.
Definition: Error.h:360
static const void * classID()
Definition: Error.h:349
Error(std::unique_ptr< ErrorInfoBase > Payload)
Create an error value.
Definition: Error.h:199
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:905
static ErrorSuccess success()
Create a success value.
Definition: Error.h:327
static bool appliesTo(const ErrorInfoBase &E)
Definition: Error.h:784
friend raw_ostream & operator<<(raw_ostream &OS, const Error &E)
Definition: Error.h:311
Expected(OtherT &&Val, typename std::enable_if< std::is_convertible< OtherT, T >::value >::type *=nullptr)
Create an Expected<T> success value from the given OtherT value, which must be convertible to T...
Definition: Error.h:475
static bool appliesTo(const ErrorInfoBase &E)
Definition: Error.h:800
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:847
static char ID
Definition: Error.h:1075
virtual std::error_code convertToErrorCode() const =0
Convert this error to a std::error_code.
T operator()(Expected< T > &&E) const
Check E.
Definition: Error.h:1243
Expected & operator=(Expected &&Other)
Move-assign from another Expected<T>.
Definition: Error.h:510
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:133
void setBanner(std::string Banner)
Set the banner string for any errors caught by operator().
Definition: Error.h:1231
Base class for user error types.
Definition: Error.h:345
Helper for Errors used as out-parameters.
Definition: Error.h:1022
static Error apply(HandlerT &&H, std::unique_ptr< ErrorInfoBase > E)
Definition: Error.h:821
#define LLVM_ATTRIBUTE_NORETURN
Definition: Compiler.h:222
Error handleErrorImpl(std::unique_ptr< ErrorInfoBase > Payload)
Definition: Error.h:861
Error(Error &&Other)
Move-construct an error value.
Definition: Error.h:192
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator end()
Definition: SmallVector.h:133
LLVMAttributeRef wrap(Attribute Attr)
Definition: Attributes.h:190
This class wraps a string in an Error.
Definition: Error.h:1139
void log(raw_ostream &OS) const override
Print an error message to an output stream.
Definition: Error.h:1072
Error joinErrors(Error E1, Error E2)
Concatenate errors.
Definition: Error.h:424
bool isA(const void *const ClassID) const override
Definition: Error.h:353
const NodeList & List
Definition: RDFGraph.cpp:210
bool isA() const
Check whether one error is a subclass of another.
Definition: Error.h:242
void setErrorCode(std::error_code EC)
Definition: Error.h:1070
typename std::conditional< isRef, wrap, T >::type storage_type
Definition: Error.h:445
ExpectedAsOutParameter(Expected< T > *ValOrErr)
Definition: Error.h:1046
static Error apply(HandlerT &&H, std::unique_ptr< ErrorInfoBase > E)
Definition: Error.h:789
Provides ErrorOr<T> smart pointer.
Error()
Create a success value. Prefer using &#39;Error::success()&#39; for readability.
Definition: Error.h:177
static bool appliesTo(const ErrorInfoBase &E)
Definition: Error.h:770
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:483
aarch64 promote const
Lightweight error class with error context and mandatory checking.
Definition: Error.h:158
Error handleErrors(Error E, HandlerTs &&... Hs)
Pass the ErrorInfo(s) contained in E to their respective handlers.
Definition: Error.h:882
std::error_code EC
Definition: Error.h:1081
This class wraps a std::error_code in a Error.
Definition: Error.h:1066
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:46
Helper for testing applicability of, and applying, handlers for ErrorInfo types.
Definition: Error.h:763
print Print MemDeps of function
static char ID
Definition: Error.h:1141
std::error_code errorToErrorCode(Error Err)
Helper for converting an ECError to a std::error_code.
Definition: Error.cpp:93
virtual bool isA(const void *const ClassID) const
Definition: Error.h:78
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
static char ID
Definition: Error.h:1192
#define T1
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
Definition: Error.h:1162
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
Definition: Error.cpp:77