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  /// Returns \a takeError() after moving the held T (if any) into \p V.
581  template <class OtherT>
583  std::enable_if_t<std::is_assignable<OtherT &, T &&>::value> * =
584  nullptr) && {
585  if (*this)
586  Value = std::move(get());
587  return takeError();
588  }
589 
590  /// Check that this Expected<T> is an error of type ErrT.
591  template <typename ErrT> bool errorIsA() const {
592  return HasError && (*getErrorStorage())->template isA<ErrT>();
593  }
594 
595  /// Take ownership of the stored error.
596  /// After calling this the Expected<T> is in an indeterminate state that can
597  /// only be safely destructed. No further calls (beside the destructor) should
598  /// be made on the Expected<T> value.
600 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
601  Unchecked = false;
602 #endif
603  return HasError ? Error(std::move(*getErrorStorage())) : Error::success();
604  }
605 
606  /// Returns a pointer to the stored T value.
607  pointer operator->() {
608  assertIsChecked();
609  return toPointer(getStorage());
610  }
611 
612  /// Returns a const pointer to the stored T value.
613  const_pointer operator->() const {
614  assertIsChecked();
615  return toPointer(getStorage());
616  }
617 
618  /// Returns a reference to the stored T value.
619  reference operator*() {
620  assertIsChecked();
621  return *getStorage();
622  }
623 
624  /// Returns a const reference to the stored T value.
625  const_reference operator*() const {
626  assertIsChecked();
627  return *getStorage();
628  }
629 
630 private:
631  template <class T1>
632  static bool compareThisIfSameType(const T1 &a, const T1 &b) {
633  return &a == &b;
634  }
635 
636  template <class T1, class T2>
637  static bool compareThisIfSameType(const T1 &, const T2 &) {
638  return false;
639  }
640 
641  template <class OtherT> void moveConstruct(Expected<OtherT> &&Other) {
642  HasError = Other.HasError;
643 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
644  Unchecked = true;
645  Other.Unchecked = false;
646 #endif
647 
648  if (!HasError)
649  new (getStorage()) storage_type(std::move(*Other.getStorage()));
650  else
651  new (getErrorStorage()) error_type(std::move(*Other.getErrorStorage()));
652  }
653 
654  template <class OtherT> void moveAssign(Expected<OtherT> &&Other) {
655  assertIsChecked();
656 
657  if (compareThisIfSameType(*this, Other))
658  return;
659 
660  this->~Expected();
661  new (this) Expected(std::move(Other));
662  }
663 
664  pointer toPointer(pointer Val) { return Val; }
665 
666  const_pointer toPointer(const_pointer Val) const { return Val; }
667 
668  pointer toPointer(wrap *Val) { return &Val->get(); }
669 
670  const_pointer toPointer(const wrap *Val) const { return &Val->get(); }
671 
672  storage_type *getStorage() {
673  assert(!HasError && "Cannot get value when an error exists!");
674  return reinterpret_cast<storage_type *>(&TStorage);
675  }
676 
677  const storage_type *getStorage() const {
678  assert(!HasError && "Cannot get value when an error exists!");
679  return reinterpret_cast<const storage_type *>(&TStorage);
680  }
681 
682  error_type *getErrorStorage() {
683  assert(HasError && "Cannot get error when a value exists!");
684  return reinterpret_cast<error_type *>(&ErrorStorage);
685  }
686 
687  const error_type *getErrorStorage() const {
688  assert(HasError && "Cannot get error when a value exists!");
689  return reinterpret_cast<const error_type *>(&ErrorStorage);
690  }
691 
692  // Used by ExpectedAsOutParameter to reset the checked flag.
693  void setUnchecked() {
694 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
695  Unchecked = true;
696 #endif
697  }
698 
699 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
700  [[noreturn]] LLVM_ATTRIBUTE_NOINLINE void fatalUncheckedExpected() const {
701  dbgs() << "Expected<T> must be checked before access or destruction.\n";
702  if (HasError) {
703  dbgs() << "Unchecked Expected<T> contained error:\n";
704  (*getErrorStorage())->log(dbgs());
705  } else
706  dbgs() << "Expected<T> value was in success state. (Note: Expected<T> "
707  "values in success mode must still be checked prior to being "
708  "destroyed).\n";
709  abort();
710  }
711 #endif
712 
713  void assertIsChecked() const {
714 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
715  if (LLVM_UNLIKELY(Unchecked))
716  fatalUncheckedExpected();
717 #endif
718  }
719 
720  union {
723  };
724  bool HasError : 1;
725 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
726  bool Unchecked : 1;
727 #endif
728 };
729 
730 /// Report a serious error, calling any installed error handler. See
731 /// ErrorHandling.h.
732 [[noreturn]] void report_fatal_error(Error Err, bool gen_crash_diag = true);
733 
734 /// Report a fatal error if Err is a failure value.
735 ///
736 /// This function can be used to wrap calls to fallible functions ONLY when it
737 /// is known that the Error will always be a success value. E.g.
738 ///
739 /// @code{.cpp}
740 /// // foo only attempts the fallible operation if DoFallibleOperation is
741 /// // true. If DoFallibleOperation is false then foo always returns
742 /// // Error::success().
743 /// Error foo(bool DoFallibleOperation);
744 ///
745 /// cantFail(foo(false));
746 /// @endcode
747 inline void cantFail(Error Err, const char *Msg = nullptr) {
748  if (Err) {
749  if (!Msg)
750  Msg = "Failure value returned from cantFail wrapped call";
751 #ifndef NDEBUG
752  std::string Str;
753  raw_string_ostream OS(Str);
754  OS << Msg << "\n" << Err;
755  Msg = OS.str().c_str();
756 #endif
757  llvm_unreachable(Msg);
758  }
759 }
760 
761 /// Report a fatal error if ValOrErr is a failure value, otherwise unwraps and
762 /// returns the contained value.
763 ///
764 /// This function can be used to wrap calls to fallible functions ONLY when it
765 /// is known that the Error will always be a success value. E.g.
766 ///
767 /// @code{.cpp}
768 /// // foo only attempts the fallible operation if DoFallibleOperation is
769 /// // true. If DoFallibleOperation is false then foo always returns an int.
770 /// Expected<int> foo(bool DoFallibleOperation);
771 ///
772 /// int X = cantFail(foo(false));
773 /// @endcode
774 template <typename T>
775 T cantFail(Expected<T> ValOrErr, const char *Msg = nullptr) {
776  if (ValOrErr)
777  return std::move(*ValOrErr);
778  else {
779  if (!Msg)
780  Msg = "Failure value returned from cantFail wrapped call";
781 #ifndef NDEBUG
782  std::string Str;
783  raw_string_ostream OS(Str);
784  auto E = ValOrErr.takeError();
785  OS << Msg << "\n" << E;
786  Msg = OS.str().c_str();
787 #endif
788  llvm_unreachable(Msg);
789  }
790 }
791 
792 /// Report a fatal error if ValOrErr is a failure value, otherwise unwraps and
793 /// returns the contained reference.
794 ///
795 /// This function can be used to wrap calls to fallible functions ONLY when it
796 /// is known that the Error will always be a success value. E.g.
797 ///
798 /// @code{.cpp}
799 /// // foo only attempts the fallible operation if DoFallibleOperation is
800 /// // true. If DoFallibleOperation is false then foo always returns a Bar&.
801 /// Expected<Bar&> foo(bool DoFallibleOperation);
802 ///
803 /// Bar &X = cantFail(foo(false));
804 /// @endcode
805 template <typename T>
806 T& cantFail(Expected<T&> ValOrErr, const char *Msg = nullptr) {
807  if (ValOrErr)
808  return *ValOrErr;
809  else {
810  if (!Msg)
811  Msg = "Failure value returned from cantFail wrapped call";
812 #ifndef NDEBUG
813  std::string Str;
814  raw_string_ostream OS(Str);
815  auto E = ValOrErr.takeError();
816  OS << Msg << "\n" << E;
817  Msg = OS.str().c_str();
818 #endif
819  llvm_unreachable(Msg);
820  }
821 }
822 
823 /// Helper for testing applicability of, and applying, handlers for
824 /// ErrorInfo types.
825 template <typename HandlerT>
827  : public ErrorHandlerTraits<decltype(
828  &std::remove_reference<HandlerT>::type::operator())> {};
829 
830 // Specialization functions of the form 'Error (const ErrT&)'.
831 template <typename ErrT> class ErrorHandlerTraits<Error (&)(ErrT &)> {
832 public:
833  static bool appliesTo(const ErrorInfoBase &E) {
834  return E.template isA<ErrT>();
835  }
836 
837  template <typename HandlerT>
838  static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
839  assert(appliesTo(*E) && "Applying incorrect handler");
840  return H(static_cast<ErrT &>(*E));
841  }
842 };
843 
844 // Specialization functions of the form 'void (const ErrT&)'.
845 template <typename ErrT> class ErrorHandlerTraits<void (&)(ErrT &)> {
846 public:
847  static bool appliesTo(const ErrorInfoBase &E) {
848  return E.template isA<ErrT>();
849  }
850 
851  template <typename HandlerT>
852  static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
853  assert(appliesTo(*E) && "Applying incorrect handler");
854  H(static_cast<ErrT &>(*E));
855  return Error::success();
856  }
857 };
858 
859 /// Specialization for functions of the form 'Error (std::unique_ptr<ErrT>)'.
860 template <typename ErrT>
861 class ErrorHandlerTraits<Error (&)(std::unique_ptr<ErrT>)> {
862 public:
863  static bool appliesTo(const ErrorInfoBase &E) {
864  return E.template isA<ErrT>();
865  }
866 
867  template <typename HandlerT>
868  static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
869  assert(appliesTo(*E) && "Applying incorrect handler");
870  std::unique_ptr<ErrT> SubE(static_cast<ErrT *>(E.release()));
871  return H(std::move(SubE));
872  }
873 };
874 
875 /// Specialization for functions of the form 'void (std::unique_ptr<ErrT>)'.
876 template <typename ErrT>
877 class ErrorHandlerTraits<void (&)(std::unique_ptr<ErrT>)> {
878 public:
879  static bool appliesTo(const ErrorInfoBase &E) {
880  return E.template isA<ErrT>();
881  }
882 
883  template <typename HandlerT>
884  static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
885  assert(appliesTo(*E) && "Applying incorrect handler");
886  std::unique_ptr<ErrT> SubE(static_cast<ErrT *>(E.release()));
887  H(std::move(SubE));
888  return Error::success();
889  }
890 };
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::*)(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::*)(ErrT &) const>
900  : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
901 
902 // Specialization for member functions of the form 'RetT (const ErrT&)'.
903 template <typename C, typename RetT, typename ErrT>
904 class ErrorHandlerTraits<RetT (C::*)(const ErrT &)>
905  : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
906 
907 // Specialization for member functions of the form 'RetT (const ErrT&) const'.
908 template <typename C, typename RetT, typename ErrT>
909 class ErrorHandlerTraits<RetT (C::*)(const ErrT &) const>
910  : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
911 
912 /// Specialization for member functions of the form
913 /// 'RetT (std::unique_ptr<ErrT>)'.
914 template <typename C, typename RetT, typename ErrT>
915 class ErrorHandlerTraits<RetT (C::*)(std::unique_ptr<ErrT>)>
916  : public ErrorHandlerTraits<RetT (&)(std::unique_ptr<ErrT>)> {};
917 
918 /// Specialization for member functions of the form
919 /// 'RetT (std::unique_ptr<ErrT>) const'.
920 template <typename C, typename RetT, typename ErrT>
921 class ErrorHandlerTraits<RetT (C::*)(std::unique_ptr<ErrT>) const>
922  : public ErrorHandlerTraits<RetT (&)(std::unique_ptr<ErrT>)> {};
923 
924 inline Error handleErrorImpl(std::unique_ptr<ErrorInfoBase> Payload) {
925  return Error(std::move(Payload));
926 }
927 
928 template <typename HandlerT, typename... HandlerTs>
929 Error handleErrorImpl(std::unique_ptr<ErrorInfoBase> Payload,
930  HandlerT &&Handler, HandlerTs &&... Handlers) {
932  return ErrorHandlerTraits<HandlerT>::apply(std::forward<HandlerT>(Handler),
933  std::move(Payload));
934  return handleErrorImpl(std::move(Payload),
935  std::forward<HandlerTs>(Handlers)...);
936 }
937 
938 /// Pass the ErrorInfo(s) contained in E to their respective handlers. Any
939 /// unhandled errors (or Errors returned by handlers) are re-concatenated and
940 /// returned.
941 /// Because this function returns an error, its result must also be checked
942 /// or returned. If you intend to handle all errors use handleAllErrors
943 /// (which returns void, and will abort() on unhandled errors) instead.
944 template <typename... HandlerTs>
945 Error handleErrors(Error E, HandlerTs &&... Hs) {
946  if (!E)
947  return Error::success();
948 
949  std::unique_ptr<ErrorInfoBase> Payload = E.takePayload();
950 
951  if (Payload->isA<ErrorList>()) {
952  ErrorList &List = static_cast<ErrorList &>(*Payload);
953  Error R;
954  for (auto &P : List.Payloads)
955  R = ErrorList::join(
956  std::move(R),
957  handleErrorImpl(std::move(P), std::forward<HandlerTs>(Hs)...));
958  return R;
959  }
960 
961  return handleErrorImpl(std::move(Payload), std::forward<HandlerTs>(Hs)...);
962 }
963 
964 /// Behaves the same as handleErrors, except that by contract all errors
965 /// *must* be handled by the given handlers (i.e. there must be no remaining
966 /// errors after running the handlers, or llvm_unreachable is called).
967 template <typename... HandlerTs>
968 void handleAllErrors(Error E, HandlerTs &&... Handlers) {
969  cantFail(handleErrors(std::move(E), std::forward<HandlerTs>(Handlers)...));
970 }
971 
972 /// Check that E is a non-error, then drop it.
973 /// If E is an error, llvm_unreachable will be called.
974 inline void handleAllErrors(Error E) {
975  cantFail(std::move(E));
976 }
977 
978 /// Handle any errors (if present) in an Expected<T>, then try a recovery path.
979 ///
980 /// If the incoming value is a success value it is returned unmodified. If it
981 /// is a failure value then it the contained error is passed to handleErrors.
982 /// If handleErrors is able to handle the error then the RecoveryPath functor
983 /// is called to supply the final result. If handleErrors is not able to
984 /// handle all errors then the unhandled errors are returned.
985 ///
986 /// This utility enables the follow pattern:
987 ///
988 /// @code{.cpp}
989 /// enum FooStrategy { Aggressive, Conservative };
990 /// Expected<Foo> foo(FooStrategy S);
991 ///
992 /// auto ResultOrErr =
993 /// handleExpected(
994 /// foo(Aggressive),
995 /// []() { return foo(Conservative); },
996 /// [](AggressiveStrategyError&) {
997 /// // Implicitly conusme this - we'll recover by using a conservative
998 /// // strategy.
999 /// });
1000 ///
1001 /// @endcode
1002 template <typename T, typename RecoveryFtor, typename... HandlerTs>
1003 Expected<T> handleExpected(Expected<T> ValOrErr, RecoveryFtor &&RecoveryPath,
1004  HandlerTs &&... Handlers) {
1005  if (ValOrErr)
1006  return ValOrErr;
1007 
1008  if (auto Err = handleErrors(ValOrErr.takeError(),
1009  std::forward<HandlerTs>(Handlers)...))
1010  return std::move(Err);
1011 
1012  return RecoveryPath();
1013 }
1014 
1015 /// Log all errors (if any) in E to OS. If there are any errors, ErrorBanner
1016 /// will be printed before the first one is logged. A newline will be printed
1017 /// after each error.
1018 ///
1019 /// This function is compatible with the helpers from Support/WithColor.h. You
1020 /// can pass any of them as the OS. Please consider using them instead of
1021 /// including 'error: ' in the ErrorBanner.
1022 ///
1023 /// This is useful in the base level of your program to allow clean termination
1024 /// (allowing clean deallocation of resources, etc.), while reporting error
1025 /// information to the user.
1026 void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner = {});
1027 
1028 /// Write all error messages (if any) in E to a string. The newline character
1029 /// is used to separate error messages.
1030 inline std::string toString(Error E) {
1032  handleAllErrors(std::move(E), [&Errors](const ErrorInfoBase &EI) {
1033  Errors.push_back(EI.message());
1034  });
1035  return join(Errors.begin(), Errors.end(), "\n");
1036 }
1037 
1038 /// Consume a Error without doing anything. This method should be used
1039 /// only where an error can be considered a reasonable and expected return
1040 /// value.
1041 ///
1042 /// Uses of this method are potentially indicative of design problems: If it's
1043 /// legitimate to do nothing while processing an "error", the error-producer
1044 /// might be more clearly refactored to return an Optional<T>.
1045 inline void consumeError(Error Err) {
1046  handleAllErrors(std::move(Err), [](const ErrorInfoBase &) {});
1047 }
1048 
1049 /// Convert an Expected to an Optional without doing anything. This method
1050 /// should be used only where an error can be considered a reasonable and
1051 /// expected return value.
1052 ///
1053 /// Uses of this method are potentially indicative of problems: perhaps the
1054 /// error should be propagated further, or the error-producer should just
1055 /// return an Optional in the first place.
1056 template <typename T> Optional<T> expectedToOptional(Expected<T> &&E) {
1057  if (E)
1058  return std::move(*E);
1059  consumeError(E.takeError());
1060  return None;
1061 }
1062 
1063 /// Helper for converting an Error to a bool.
1064 ///
1065 /// This method returns true if Err is in an error state, or false if it is
1066 /// in a success state. Puts Err in a checked state in both cases (unlike
1067 /// Error::operator bool(), which only does this for success states).
1068 inline bool errorToBool(Error Err) {
1069  bool IsError = static_cast<bool>(Err);
1070  if (IsError)
1071  consumeError(std::move(Err));
1072  return IsError;
1073 }
1074 
1075 /// Helper for Errors used as out-parameters.
1076 ///
1077 /// This helper is for use with the Error-as-out-parameter idiom, where an error
1078 /// is passed to a function or method by reference, rather than being returned.
1079 /// In such cases it is helpful to set the checked bit on entry to the function
1080 /// so that the error can be written to (unchecked Errors abort on assignment)
1081 /// and clear the checked bit on exit so that clients cannot accidentally forget
1082 /// to check the result. This helper performs these actions automatically using
1083 /// RAII:
1084 ///
1085 /// @code{.cpp}
1086 /// Result foo(Error &Err) {
1087 /// ErrorAsOutParameter ErrAsOutParam(&Err); // 'Checked' flag set
1088 /// // <body of foo>
1089 /// // <- 'Checked' flag auto-cleared when ErrAsOutParam is destructed.
1090 /// }
1091 /// @endcode
1092 ///
1093 /// ErrorAsOutParameter takes an Error* rather than Error& so that it can be
1094 /// used with optional Errors (Error pointers that are allowed to be null). If
1095 /// ErrorAsOutParameter took an Error reference, an instance would have to be
1096 /// created inside every condition that verified that Error was non-null. By
1097 /// taking an Error pointer we can just create one instance at the top of the
1098 /// function.
1100 public:
1101  ErrorAsOutParameter(Error *Err) : Err(Err) {
1102  // Raise the checked bit if Err is success.
1103  if (Err)
1104  (void)!!*Err;
1105  }
1106 
1108  // Clear the checked bit.
1109  if (Err && !*Err)
1110  *Err = Error::success();
1111  }
1112 
1113 private:
1114  Error *Err;
1115 };
1116 
1117 /// Helper for Expected<T>s used as out-parameters.
1118 ///
1119 /// See ErrorAsOutParameter.
1120 template <typename T>
1122 public:
1124  : ValOrErr(ValOrErr) {
1125  if (ValOrErr)
1126  (void)!!*ValOrErr;
1127  }
1128 
1130  if (ValOrErr)
1131  ValOrErr->setUnchecked();
1132  }
1133 
1134 private:
1135  Expected<T> *ValOrErr;
1136 };
1137 
1138 /// This class wraps a std::error_code in a Error.
1139 ///
1140 /// This is useful if you're writing an interface that returns a Error
1141 /// (or Expected) and you want to call code that still returns
1142 /// std::error_codes.
1143 class ECError : public ErrorInfo<ECError> {
1144  friend Error errorCodeToError(std::error_code);
1145 
1146  virtual void anchor() override;
1147 
1148 public:
1149  void setErrorCode(std::error_code EC) { this->EC = EC; }
1150  std::error_code convertToErrorCode() const override { return EC; }
1151  void log(raw_ostream &OS) const override { OS << EC.message(); }
1152 
1153  // Used by ErrorInfo::classID.
1154  static char ID;
1155 
1156 protected:
1157  ECError() = default;
1158  ECError(std::error_code EC) : EC(EC) {}
1159 
1160  std::error_code EC;
1161 };
1162 
1163 /// The value returned by this function can be returned from convertToErrorCode
1164 /// for Error values where no sensible translation to std::error_code exists.
1165 /// It should only be used in this situation, and should never be used where a
1166 /// sensible conversion to std::error_code is available, as attempts to convert
1167 /// to/from this error will result in a fatal error. (i.e. it is a programmatic
1168 /// error to try to convert such a value).
1169 std::error_code inconvertibleErrorCode();
1170 
1171 /// Helper for converting an std::error_code to a Error.
1172 Error errorCodeToError(std::error_code EC);
1173 
1174 /// Helper for converting an ECError to a std::error_code.
1175 ///
1176 /// This method requires that Err be Error() or an ECError, otherwise it
1177 /// will trigger a call to abort().
1178 std::error_code errorToErrorCode(Error Err);
1179 
1180 /// Convert an ErrorOr<T> to an Expected<T>.
1181 template <typename T> Expected<T> errorOrToExpected(ErrorOr<T> &&EO) {
1182  if (auto EC = EO.getError())
1183  return errorCodeToError(EC);
1184  return std::move(*EO);
1185 }
1186 
1187 /// Convert an Expected<T> to an ErrorOr<T>.
1188 template <typename T> ErrorOr<T> expectedToErrorOr(Expected<T> &&E) {
1189  if (auto Err = E.takeError())
1190  return errorToErrorCode(std::move(Err));
1191  return std::move(*E);
1192 }
1193 
1194 /// This class wraps a string in an Error.
1195 ///
1196 /// StringError is useful in cases where the client is not expected to be able
1197 /// to consume the specific error message programmatically (for example, if the
1198 /// error message is to be presented to the user).
1199 ///
1200 /// StringError can also be used when additional information is to be printed
1201 /// along with a error_code message. Depending on the constructor called, this
1202 /// class can either display:
1203 /// 1. the error_code message (ECError behavior)
1204 /// 2. a string
1205 /// 3. the error_code message and a string
1206 ///
1207 /// These behaviors are useful when subtyping is required; for example, when a
1208 /// specific library needs an explicit error type. In the example below,
1209 /// PDBError is derived from StringError:
1210 ///
1211 /// @code{.cpp}
1212 /// Expected<int> foo() {
1213 /// return llvm::make_error<PDBError>(pdb_error_code::dia_failed_loading,
1214 /// "Additional information");
1215 /// }
1216 /// @endcode
1217 ///
1218 class StringError : public ErrorInfo<StringError> {
1219 public:
1220  static char ID;
1221 
1222  // Prints EC + S and converts to EC
1223  StringError(std::error_code EC, const Twine &S = Twine());
1224 
1225  // Prints S and converts to EC
1226  StringError(const Twine &S, std::error_code EC);
1227 
1228  void log(raw_ostream &OS) const override;
1229  std::error_code convertToErrorCode() const override;
1230 
1231  const std::string &getMessage() const { return Msg; }
1232 
1233 private:
1234  std::string Msg;
1235  std::error_code EC;
1236  const bool PrintMsgOnly = false;
1237 };
1238 
1239 /// Create formatted StringError object.
1240 template <typename... Ts>
1241 inline Error createStringError(std::error_code EC, char const *Fmt,
1242  const Ts &... Vals) {
1243  std::string Buffer;
1244  raw_string_ostream Stream(Buffer);
1245  Stream << format(Fmt, Vals...);
1246  return make_error<StringError>(Stream.str(), EC);
1247 }
1248 
1249 Error createStringError(std::error_code EC, char const *Msg);
1250 
1251 inline Error createStringError(std::error_code EC, const Twine &S) {
1252  return createStringError(EC, S.str().c_str());
1253 }
1254 
1255 template <typename... Ts>
1256 inline Error createStringError(std::errc EC, char const *Fmt,
1257  const Ts &... Vals) {
1258  return createStringError(std::make_error_code(EC), Fmt, Vals...);
1259 }
1260 
1261 /// This class wraps a filename and another Error.
1262 ///
1263 /// In some cases, an error needs to live along a 'source' name, in order to
1264 /// show more detailed information to the user.
1265 class FileError final : public ErrorInfo<FileError> {
1266 
1267  friend Error createFileError(const Twine &, Error);
1268  friend Error createFileError(const Twine &, size_t, Error);
1269 
1270 public:
1271  void log(raw_ostream &OS) const override {
1272  assert(Err && "Trying to log after takeError().");
1273  OS << "'" << FileName << "': ";
1274  if (Line.hasValue())
1275  OS << "line " << Line.getValue() << ": ";
1276  Err->log(OS);
1277  }
1278 
1279  std::string messageWithoutFileInfo() const {
1280  std::string Msg;
1281  raw_string_ostream OS(Msg);
1282  Err->log(OS);
1283  return OS.str();
1284  }
1285 
1286  StringRef getFileName() { return FileName; }
1287 
1288  Error takeError() { return Error(std::move(Err)); }
1289 
1290  std::error_code convertToErrorCode() const override;
1291 
1292  // Used by ErrorInfo::classID.
1293  static char ID;
1294 
1295 private:
1296  FileError(const Twine &F, Optional<size_t> LineNum,
1297  std::unique_ptr<ErrorInfoBase> E) {
1298  assert(E && "Cannot create FileError from Error success value.");
1299  FileName = F.str();
1300  Err = std::move(E);
1301  Line = std::move(LineNum);
1302  }
1303 
1304  static Error build(const Twine &F, Optional<size_t> Line, Error E) {
1305  std::unique_ptr<ErrorInfoBase> Payload;
1307  [&](std::unique_ptr<ErrorInfoBase> EIB) -> Error {
1308  Payload = std::move(EIB);
1309  return Error::success();
1310  });
1311  return Error(
1312  std::unique_ptr<FileError>(new FileError(F, Line, std::move(Payload))));
1313  }
1314 
1315  std::string FileName;
1316  Optional<size_t> Line;
1317  std::unique_ptr<ErrorInfoBase> Err;
1318 };
1319 
1320 /// Concatenate a source file path and/or name with an Error. The resulting
1321 /// Error is unchecked.
1322 inline Error createFileError(const Twine &F, Error E) {
1323  return FileError::build(F, Optional<size_t>(), std::move(E));
1324 }
1325 
1326 /// Concatenate a source file path and/or name with line number and an Error.
1327 /// The resulting Error is unchecked.
1328 inline Error createFileError(const Twine &F, size_t Line, Error E) {
1329  return FileError::build(F, Optional<size_t>(Line), std::move(E));
1330 }
1331 
1332 /// Concatenate a source file path and/or name with a std::error_code
1333 /// to form an Error object.
1334 inline Error createFileError(const Twine &F, std::error_code EC) {
1335  return createFileError(F, errorCodeToError(EC));
1336 }
1337 
1338 /// Concatenate a source file path and/or name with line number and
1339 /// std::error_code to form an Error object.
1340 inline Error createFileError(const Twine &F, size_t Line, std::error_code EC) {
1341  return createFileError(F, Line, errorCodeToError(EC));
1342 }
1343 
1344 Error createFileError(const Twine &F, ErrorSuccess) = delete;
1345 
1346 /// Helper for check-and-exit error handling.
1347 ///
1348 /// For tool use only. NOT FOR USE IN LIBRARY CODE.
1349 ///
1351 public:
1352  /// Create an error on exit helper.
1353  ExitOnError(std::string Banner = "", int DefaultErrorExitCode = 1)
1354  : Banner(std::move(Banner)),
1355  GetExitCode([=](const Error &) { return DefaultErrorExitCode; }) {}
1356 
1357  /// Set the banner string for any errors caught by operator().
1358  void setBanner(std::string Banner) { this->Banner = std::move(Banner); }
1359 
1360  /// Set the exit-code mapper function.
1361  void setExitCodeMapper(std::function<int(const Error &)> GetExitCode) {
1362  this->GetExitCode = std::move(GetExitCode);
1363  }
1364 
1365  /// Check Err. If it's in a failure state log the error(s) and exit.
1366  void operator()(Error Err) const { checkError(std::move(Err)); }
1367 
1368  /// Check E. If it's in a success state then return the contained value. If
1369  /// it's in a failure state log the error(s) and exit.
1370  template <typename T> T operator()(Expected<T> &&E) const {
1371  checkError(E.takeError());
1372  return std::move(*E);
1373  }
1374 
1375  /// Check E. If it's in a success state then return the contained reference. If
1376  /// it's in a failure state log the error(s) and exit.
1377  template <typename T> T& operator()(Expected<T&> &&E) const {
1378  checkError(E.takeError());
1379  return *E;
1380  }
1381 
1382 private:
1383  void checkError(Error Err) const {
1384  if (Err) {
1385  int ExitCode = GetExitCode(Err);
1386  logAllUnhandledErrors(std::move(Err), errs(), Banner);
1387  exit(ExitCode);
1388  }
1389  }
1390 
1391  std::string Banner;
1392  std::function<int(const Error &)> GetExitCode;
1393 };
1394 
1395 /// Conversion from Error to LLVMErrorRef for C error bindings.
1396 inline LLVMErrorRef wrap(Error Err) {
1397  return reinterpret_cast<LLVMErrorRef>(Err.takePayload().release());
1398 }
1399 
1400 /// Conversion from LLVMErrorRef to Error for C error bindings.
1401 inline Error unwrap(LLVMErrorRef ErrRef) {
1402  return Error(std::unique_ptr<ErrorInfoBase>(
1403  reinterpret_cast<ErrorInfoBase *>(ErrRef)));
1404 }
1405 
1406 } // end namespace llvm
1407 
1408 #endif // LLVM_SUPPORT_ERROR_H
llvm::ExitOnError::operator()
T operator()(Expected< T > &&E) const
Check E.
Definition: Error.h:1370
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:838
llvm::StringError::ID
static char ID
Definition: Error.h:1220
llvm::ErrorHandlerTraits< void(&)(ErrT &)>::apply
static Error apply(HandlerT &&H, std::unique_ptr< ErrorInfoBase > E)
Definition: Error.h:852
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:863
llvm::handleErrors
Error handleErrors(Error E, HandlerTs &&... Hs)
Pass the ErrorInfo(s) contained in E to their respective handlers.
Definition: Error.h:945
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:1279
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:879
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:1030
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:1353
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:1366
llvm::ErrorList::ID
static char ID
Definition: Error.h:385
llvm::FileError
This class wraps a filename and another Error.
Definition: Error.h:1265
T1
#define T1
Definition: Mips16ISelLowering.cpp:340
llvm::ExitOnError
Helper for check-and-exit error handling.
Definition: Error.h:1350
llvm::ErrorHandlerTraits< void(&)(ErrT &)>::appliesTo
static bool appliesTo(const ErrorInfoBase &E)
Definition: Error.h:847
llvm::FileError::log
void log(raw_ostream &OS) const override
Print an error message to an output stream.
Definition: Error.h:1271
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:884
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:625
llvm::ExpectedAsOutParameter::ExpectedAsOutParameter
ExpectedAsOutParameter(Expected< T > *ValOrErr)
Definition: Error.h:1123
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:1293
Format.h
llvm::ECError
This class wraps a std::error_code in a Error.
Definition: Error.h:1143
llvm::ECError::EC
std::error_code EC
Definition: Error.h:1160
llvm::AlignedCharArrayUnion< storage_type >
llvm::consumeError
void consumeError(Error Err)
Consume a Error without doing anything.
Definition: Error.h:1045
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:607
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:1154
llvm::Expected::operator*
reference operator*()
Returns a reference to the stored T value.
Definition: Error.h:619
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:613
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:1158
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:826
llvm::createFileError
Error createFileError(const Twine &F, Error E)
Concatenate a source file path and/or name with an Error.
Definition: Error.h:1322
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::Expected::moveInto
Error moveInto(OtherT &Value, std::enable_if_t< std::is_assignable< OtherT &, T && >::value > *=nullptr) &&
Returns takeError() after moving the held T (if any) into V.
Definition: Error.h:582
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:1358
llvm::ExpectedAsOutParameter::~ExpectedAsOutParameter
~ExpectedAsOutParameter()
Definition: Error.h:1129
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:945
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:1099
llvm::ExpectedAsOutParameter
Helper for Expected<T>s used as out-parameters.
Definition: Error.h:1121
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:1149
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:1003
llvm::ECError::log
void log(raw_ostream &OS) const override
Print an error message to an output stream.
Definition: Error.h:1151
const
aarch64 promote const
Definition: AArch64PromoteConstant.cpp:232
llvm::handleErrorImpl
Error handleErrorImpl(std::unique_ptr< ErrorInfoBase > Payload)
Definition: Error.h:924
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:833
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:1322
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:1056
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:1218
llvm::errorToBool
bool errorToBool(Error Err)
Helper for converting an Error to a bool.
Definition: Error.h:1068
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:868
llvm::StringError::getMessage
const std::string & getMessage() const
Definition: Error.h:1231
llvm::FileError::takeError
Error takeError()
Definition: Error.h:1288
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:1107
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:747
llvm::ErrorAsOutParameter::ErrorAsOutParameter
ErrorAsOutParameter(Error *Err)
Definition: Error.h:1101
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:1361
Error.h
llvm::Expected::errorIsA
bool errorIsA() const
Check that this Expected<T> is an error of type ErrT.
Definition: Error.h:591
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:1241
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:1150
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:722
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:721
llvm::FileError::getFileName
StringRef getFileName()
Definition: Error.h:1286
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:599
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:1181
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:1377
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:1188
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:1879
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:968
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
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