[Debuginfo][NFC] Unify error reporting routines inside DebugInfoDWARF.

[avl]

Summary

Error reporting in DebugInfoDWARF library currently done in three ways :

1. Direct calls to WithColor::error()/WithColor::warning()
2. ErrorPolicy defaultErrorHandler(Error E);
3. void dumpWarning(Error Warning);

additionally, other locations could have more variations:

lld/ELF/SyntheticSection.cpp

if (Error e = cu->tryExtractDIEsIfNeeded(false)) {
  error(toString(sec) + ": " + toString(std::move(e)));

DebugInfo/DWARF/DWARFUnit.cpp

if (Error e = tryExtractDIEsIfNeeded(CUDieOnly))
  WithColor::error() << toString(std::move(e));

Thus error reporting could look inconsistent. To have a consistent error
messages it is necessary to have a possibility to redefine error
reporting functions. This patch creates two handlers and allows to
redefine them. It also patches all places inside DebugInfoDWARF
to use these handlers.

The intention is always to use following handlers for error reporting
purposes inside DebugInfoDWARF:

DebugInfo/DWARF/DWARFContext.h

std::function<void(Error E)> RecoverableErrorHandler = WithColor::defaultErrorHandler;
std::function<void(Error E)> WarningHandler = WithColor::defaultWarningHandler;

This is last patch from series of patches: D74481, D74635, D75118.

[avl]

Unit tests pass. 62578 tests passed, 0 failed and 842 were skipped.

clang-tidy fail. clang-tidy found 0 errors and 1 warnings.

clang-format pass.

[jhenderson]

Overall, I like the principle of this change, but you should definitely hear what others have to say too.

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

355

Having a setter and getter for these seems a bit verbose, especially when you've got cases where you use the getter and then immediately call the return. Is there any particular reason to hide the handlers behind the interface?

llvm/lib/DWARFLinker/DWARFLinker.cpp

362

I know it's not related to your change, but since you are touching the line anyway, could you change 8 /* Indent */ to /*Indent=*/8, please, as clang-format plays well with that.

400

Ditto

llvm/lib/DebugInfo/DWARF/DWARFDie.cpp

642

Have you considered using DWARFContext::defaultErrorHandler here?

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

240

Same comment as elsewhere re. "indent"

llvm/tools/dsymutil/DwarfLinkerForBinary.cpp

162

Same comments re. using DWARFContext::defaultErrorHandler and "Indent" comment.

[avl]

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

355

There is no particular reason. Having getter/setter allows to add some code like checking for nullptr, or dumping, or something else... If it looks verbose I would remove it.

llvm/lib/DWARFLinker/DWARFLinker.cpp

362

Ok.

llvm/lib/DebugInfo/DWARF/DWARFDie.cpp

642

Ah, indeed. Would use it.

[dblaikie]

Overall it's a worthwhile direction - but please split this into smaller patches. General renamings separate, adding the functionality and using it in one place (preferably one that doesn't require function signature changes - one that already has the DWARFContext available, etc) & then a separate patch probably for each different error handling location that requires a function signature change. I think it'll be easier to review that way & make it clearer what changes were needed and how the error handling is being layered, etc.

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

94–96

Does this need to be wrapped in a lambda here?

355

@jhenderson : perhaps/did you mean "Is there any particular reason /not/ to hide the handlers behind the interface" - ie: I think you might've been suggesting that, rather than having "getRecoverableErrorHandler" the interface would have "emitRecoverableError(ERror E)" that calls the handler. Not exposing the handler itself to users of DWARFContext? Is that what you were/are suggesting? It sounds like a reasonable suggestion to me - at least worth asking/considering.

As for the setters - they seem to be uncalled right now? (just searching for them in this phab page doesn't show up any other instance of their names) - so probably best to leave them out until they're needed & we can discuss the merits of their use then?

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugLine.h

307

Please separate this sort of renaming into a pre or post patch to make this review easier/more targeted.

[jhenderson]

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

355

I don't think it's what I meant when I wrote that comment, but I think your suggestion manifesting itself as a half-formed thought was what triggered me to write a comment at all! I agree that an "emitRecovarableError(Error E)" signature would make a lot of sense - all it would do would be to call the handler with the passed-in error.

[avl]

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

355

I did not clearly get idea of "emitRecoverableError(ERror E)". My understanting is that it allows to change this usage :

public:  std::function<void(Error E)> RecoverableErrorHandler; // field of DWARFContext
...
DWARFContext.RecoverableErrorHandler(E);  // emit error.

with this usage:

DWARFContext.emitRecoverableError(E);  // emit error, RecoverableErrorHandler is not seen

But what about this usage :

func (std::function<void(Error E)> ErrorHandler)  // some function
      { ErrorHandler(Error); }


func(DWARFContext.RecoverableErrorHandler);  // pass handler to function

How would this case be resolved with emitRecoverableError() ?

Something like this:

func([&](Error E ) { DWARFContext.emitRecoverableError(std::move(E)); }   // pass handler to function

?

[jhenderson]

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

355

I'm not sure I follow your comments I'm afraid. The suggestion is to replace getRecoverableErrorHandler() with the following function:

void emitRecoverableError(Error Err) {
  RecoverableErrorHandler(std::move(Err));
}

Usage would be either:

Context.emitRecoverableError(createStringError("some text"));

or

doSomething(/*Callback=*/Context.emitRecoverableError);
...
void doSomething(function_ref<void(Error E)> Handler) {
...
  Handler(createStringError("some error"));
}

depending on whether the handler needs to be passed into the function, or the Context can be accessed directly. Effectively, in the second case, the real error handler is wrapped in another function that calls it.

[avl]

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

355

Ah, OK, Thanks. I misinterpreted second usage ...

[avl]

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

355

But... it looks like it does not work that way :

doSomething(/*Callback=*/Context.emitRecoverableError);

error: reference to non-static member function must be called

It needs to be

doSomething(/*Callback=*/[&](Error Err){Context.emitRecoverableError(std::move(Err))});

[avl]

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

355

@dblaikie David, How emitRecoverableError() should be used for this scenario ? :

doSomething(/*Callback=*/Context.emitRecoverableError);
...
void doSomething(function_ref<void(Error E)> Handler) {
...
  Handler(createStringError("some error"));
}

Exactly this variant seems not working, since std::function/function_ref could not be assigned to member function. it is necessary to use proxy lambda function or use std::bind to make it working.

But that probably is not very convenient solution.

[dblaikie]

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

355

Yeah, fair enough - seems like there are enough places that want to pass the handler along to that don't have a DWARFContext directly accessible (& makes sense to just pass down the handlers, rather than the whole DWARFContext). Seems fine as-is (as an accessor for the handler), then. Maybe @jhenderson has other thoughts since it was his feedback originally.

Still seems like the setters should be removed if (as they appear to be) they are unused.

[avl]

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

355

Ok. I also think it would be fine to use an accessor here :

std::function<void(Error Err)> getRecoverableErrorHandler {
    return RecoverableErrorHandler;
}

Though @jhenderson asked for publicly visible member originally:

std::function<void(Error Err)> RecoverableErrorHandler;

will wait for opinions more...

[jhenderson]

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

355

Public accessor is fine. I don't have a strong opinion on it either way.

[avl]

As it was requested, D74481, D74635 patches already integrate
most of functionality. This final part adds the possibility
to redefine error handlers into constructor of DWARFContext
and DWARFContext::create() functions.

[jhenderson]

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

116

This can just be RecoverablErrorHandler. No need for the The - constructor arguments can be named the same as the thing they're initialising. Same goes throughout most of the other functions too.

366–370

objectFileErrorsHandler -> objectFileErrorHandler

374–375

I don't think you need to pass this in as well as a RecoverableErrorHandler. The two shouldn't need to diverge, I think. Rather, have ObjectFileErrorHandler be defined in terms of RecoverableErrorHandler, as suggested below.

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

1437

Shouldn't this function use the provided error handler rather than the default one?

In fact, maybe this should just be an inline lambda now.

[avl]

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

116

Ok.

366–370

ok.

374–375

There are two problems here:

1. Using RecoverableErrorHandler for implementing ObjectFileErrorHandler.
   
   ObjectFileErrorHandler is a static function member, thus it could not be implemented using non-static function member RecoverableErrorHandler.

2. Passing one Error handler instead of two error Handlers. i.e.:
   
   instead of passing objectFileErrorsHandler and RecoverableErrorHandler into DWARFContext::create() pass only one handler.
   
   As far as I understand original logic for DWARFContext::create(), there should be possible to pass handler which would stop processing if error occurred. i.e. it would return ErrorPolicy::Halt. That behavior is important for the creation function. But for the other DWARFContext errors that policy is not supported. It could probably be incorrect to use handler which returns ErrorPolicy::Halt for other DWARFContext errors.
   
   Since error logic for create() method and for other places differs - it looks correct to use different handlers. What do you think?

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

1437

since objectFileErrorsHandler is a static function - it could not use provided error handler(which is not-static member - RecoverableErrorHandler)

[avl]

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

374–375

@jhenderson James, what about passing two error handlers to "create" function?:

create(const object::ObjectFile &Obj, const LoadedObjectInfo *L = nullptr,
         function_ref<ErrorPolicy(Error)> ObjectFileErrorsHandler =
             objectFileErrorsHandler,
         std::string DWPName = "",
         std::function<void(Error)> RecoverableErrorHandler =
             WithColor::defaultErrorHandler,
         std::function<void(Error)> WarningHandler =
             WithColor::defaultWarningHandler);

Would it be OK ?

As an alternative objectFileErrorsHandler default implementation could be removed at all, with the price that every usage place would need to create it by itself:

create(const object::ObjectFile &Obj, const LoadedObjectInfo *L = nullptr,
         function_ref<ErrorPolicy(Error)> ObjectFileErrorsHandler =
             [](Error E)->ErrorPolicy {
               WithColor::defaultErrorHandler(std::move(E));
               return ErrorPolicy::Continue;
             },
         std::string DWPName = "",
         std::function<void(Error)> RecoverableErrorHandler =
             WithColor::defaultErrorHandler,
         std::function<void(Error)> WarningHandler =
             WithColor::defaultWarningHandler);

Context = DWARFContext::create(*Objects.second, nullptr,
                               [](Error E)->ErrorPolicy {
                                 WithColor::defaultErrorHandler(std::move(E));
                                 return ErrorPolicy::Continue;
                               }, Opts.DWPName);

[avl]

renamed parameters. objectFileErrorHandler is not addressed yet.

[avl]

@jhenderson I did not clearly get what should be done for handlers for create function. How following should be changed?

static ErrorPolicy objectFileErrorHandler(Error E);

ErrorPolicy DWARFContext::objectFileErrorHandler(Error E) {
  WithColor::defaultErrorHandler(std::move(E));
  return ErrorPolicy::Continue;
}
....
create(const object::ObjectFile &Obj, const LoadedObjectInfo *L = nullptr,
         function_ref<ErrorPolicy(Error)> ObjectFileErrorHandler = objectFileErrorHandler,
         std::string DWPName = "",
         std::function<void(Error)> RecoverableErrorHandler = WithColor::defaultErrorHandler,
         std::function<void(Error)> WarningHandler = WithColor::defaultWarningHandler);

.....
    Context = DWARFContext::create(*Objects.second, nullptr,
                                   DWARFContext::objectFileErrorHandler,
                                   Opts.DWPName);

[jhenderson]

Sorry for the delay in responding. It's been a busy few days. I just looked around the LLVM code base and could find no instance of the existing defaultErrorHandler being replaced with a different handler. Is it possible this is now dead code? It looks like @grimar originally added it 3 years ago.

[avl]

Aha, I see. Yes, it looks like it is not used currently. The only place is DWARFDebugInfoTest.cpp which checks for that feature. So it seems like that DWARFContext::defaultErrorHandler could be removed:

create(const object::ObjectFile &Obj, const LoadedObjectInfo *L = nullptr,
         std::string DWPName = "",
         std::function<void(Error)> RecoverableErrorHandler = WithColor::defaultErrorHandler,
         std::function<void(Error)> WarningHandler = WithColor::defaultWarningHandler);

Will wait for @grimar comments.

[grimar]

In D74308#1889316, @avl wrote:

Will wait for @grimar comments.

The error handler was implemented in D34328 and used in LLD: D34814.
It was needed because when an error happened during parsing a debug data, the code in lib/DebugInfo
just printed something to errs() and did not let LLD know about the error (see D34814).
LLD's implementation of .gdb_index (that is for what we are using lib/DebugInfo code) changed significantly since that time,
seems LLD does not use D34328 code anymore.

In D74308#1889097, @jhenderson wrote:

Is it possible this is now dead code? It looks like @grimar originally added it 3 years ago.

It probably might be usefull for people who might want to use DWARFObjInMemory class like we had in LLD before.
This error handler was the only good way to know on a caller side that something went wrong during DWARF parsing.

[jhenderson]

Right, so I think I see a path forward. I agree with @grimar that we need a way to pass the errors encountered during construction of DWARFObjInMemory back to the caller of the constructor (and therefore in turn to the caller of DWARFContext::create). However, I do not see a need for the existing continue/halt distinction. It seems harmless (aside from maybe slightly less performant) to continue in all cases. This means that we can change the signature of the callback to void(Error), like the other error callbacks, which in turn means we can use WithColor::defaultErrorHandler as the default error handling method instead of objectFileErrorHandler, and indeed, allows us therefore to remove the extra argument from the signature of create (because we can just use the RecoverableErrorHandler argument).

Does that make sense?

[grimar]

In D74308#1890911, @jhenderson wrote:

Right, so I think I see a path forward. I agree with @grimar that we need a way to pass the errors encountered during construction of DWARFObjInMemory back to the caller of the constructor (and therefore in turn to the caller of DWARFContext::create). However, I do not see a need for the existing continue/halt distinction. It seems harmless (aside from maybe slightly less performant) to continue in all cases. This means that we can change the signature of the callback to void(Error), like the other error callbacks, which in turn means we can use WithColor::defaultErrorHandler as the default error handling method instead of objectFileErrorHandler, and indeed, allows us therefore to remove the extra argument from the signature of create (because we can just use the RecoverableErrorHandler argument).

Does that make sense?

Sounds probably fine to me.

[avl]

Ok. just to make me sure: we are going to remove "enum class ErrorPolicy { Halt, Continue };" completetly ?

[grimar]

In D74308#1891014, @avl wrote:

Ok. just to make me sure: we are going to remove "enum class ErrorPolicy { Halt, Continue };" completetly ?

I believe this is what @jhenderson's suggestion does. There are no other users of ErrorPolicy I think, so yes.

[avl]

addressed comments: deleted handler with ErrorPolicy.

[jhenderson]

Looks good, but I'd pull the ErrorPolicy related changes into a separate patch.

llvm/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp

2532 ↗

(On Diff #246423)

"both two errors we know about" -> "the two errors we expect"

[avl]

updated after D75118 was extracted.

[jhenderson]

LGTM. Thanks for the work on this!

[avl]

@jhenderson Thanks!

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

class DWARFContext : public DIContext {
   };
   StringMap<std::weak_ptr<DWOFile>> DWOFiles;
   std::weak_ptr<DWOFile> DWP;
   bool CheckedForDWP = false;
   std::string DWPName;
 
   std::unique_ptr<MCRegisterInfo> RegInfo;
 
+  std::function<void(Error E)> RecoverableErrorHandler = [](Error E) {
+    defaultErrorHandler(std::move(E));
+  };
+  std::function<void(Error E)> WarningHandler = defaultWarningHandler;
+
   /// Read compile units from the debug_info section (if necessary)
   /// and type units from the debug_types sections (if necessary)
   /// and store them in NormalUnits.
   void parseNormalUnits();
 
   /// Read compile units from the debug_info.dwo section (if necessary)
   /// and type units from the debug_types.dwo section (if necessary)
   /// and store them in DWOUnits.
   /// If \p Lazy is true, set up to parse but don't actually parse them.
   enum { EagerParse = false, LazyParse = true };
   void parseDWOUnits(bool Lazy = false);
 
   std::unique_ptr<const DWARFObject> DObj;
 
 public:
   DWARFContext(std::unique_ptr<const DWARFObject> DObj,
                std::string DWPName = "");
   ~DWARFContext();
 
   DWARFContext(DWARFContext &) = delete;
   DWARFContext &operator=(DWARFContext &) = delete;
 
   const DWARFObject &getDWARFObj() const { return *DObj; }
 
   static bool classof(const DIContext *DICtx) {
     return DICtx->getKind() == CK_DWARF;
public:
   /// Get a reference to the parsed accelerator table object.
   const AppleAcceleratorTable &getAppleObjC();
 
   /// Get a pointer to a parsed line table corresponding to a compile unit.
   /// Report any parsing issues as warnings on stderr.
   const DWARFDebugLine::LineTable *getLineTableForUnit(DWARFUnit *U);
 
   /// Get a pointer to a parsed line table corresponding to a compile unit.
-  /// Report any recoverable parsing problems using the callback.
+  /// Report any recoverable parsing problems using the error handler.
   Expected<const DWARFDebugLine::LineTable *>
   getLineTableForUnit(DWARFUnit *U,
-                      function_ref<void(Error)> RecoverableErrorCallback);
+                      function_ref<void(Error)> RecoverableErrorHandler);
 
   DataExtractor getStringExtractor() const {
     return DataExtractor(DObj->getStrSection(), false, 0);
   }
   DataExtractor getLineStringExtractor() const {
     return DataExtractor(DObj->getLineStrSection(), false, 0);
   }
 
public:
   static bool isSupportedVersion(unsigned version) {
     return version == 2 || version == 3 || version == 4 || version == 5;
   }
 
   std::shared_ptr<DWARFContext> getDWOContext(StringRef AbsolutePath);
 
   const MCRegisterInfo *getRegisterInfo() const { return RegInfo.get(); }
 
+  void setRecoverableErrorHandler(std::function<void(Error E)> Handler) {
+    assert(Handler);
+    RecoverableErrorHandler = Handler;
+  };
+  std::function<void(Error E)> getRecoverableErrorHandler() {
+    return RecoverableErrorHandler;
+  }
+  void setWarningHandler(std::function<void(Error E)> Handler) {
+    assert(Handler);
+    WarningHandler = Handler;
+  };
+  std::function<void(Error E)> getWarningHandler() { return WarningHandler; }
+
   /// Function used to handle default error reporting policy. Prints a error
   /// message and returns Continue, so DWARF context ignores the error.
   static ErrorPolicy defaultErrorHandler(Error E);
+
+  /// Dump Error as warning message to stderr.
+  static void defaultWarningHandler(Error Warning);
+
   static std::unique_ptr<DWARFContext>
   create(const object::ObjectFile &Obj, const LoadedObjectInfo *L = nullptr,
          function_ref<ErrorPolicy(Error)> HandleError = defaultErrorHandler,
          std::string DWPName = "");
 
   static std::unique_ptr<DWARFContext>
   create(const StringMap<std::unique_ptr<MemoryBuffer>> &Sections,
          uint8_t AddrSize, bool isLittleEndian = sys::IsLittleEndianHost);
 
   /// Loads register info for the architecture of the provided object file.
   /// Improves readability of dumped DWARF expressions. Requires the caller to
   /// have initialized the relevant target descriptions.
   Error loadRegisterInfo(const object::ObjectFile &Obj);
 
   /// Get address size from CUs.
   /// TODO: refactor compile_units() to make this const.
   uint8_t getCUAddrSize();
 
-  /// Dump Error as warning message to stderr.
-  static void dumpWarning(Error Warning);
-
   Triple::ArchType getArch() const {
     return getDWARFObj().getFile()->getArch();
   }
 
 private:
   /// Return the compile unit which contains instruction with provided
   /// address.
   /// TODO: change input parameter from "uint64_t Address"

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugAranges.h

 
 class DWARFDebugAranges {
 public:
   void generate(DWARFContext *CTX);
   uint64_t findAddress(uint64_t Address) const;
 
 private:
   void clear();
-  void extract(DataExtractor DebugArangesData);
+  void extract(DataExtractor DebugArangesData,
+               function_ref<void(Error)> RecoverableErrorHandler);
 
   /// Call appendRange multiple times and then call construct.
   void appendRange(uint64_t CUOffset, uint64_t LowPC, uint64_t HighPC);
   void construct();
 
   struct Range {
     explicit Range(uint64_t LowPC, uint64_t HighPC, uint64_t CUOffset)
       : LowPC(LowPC), Length(HighPC - LowPC), CUOffset(CUOffset) {}

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugLine.h

struct Prologue {
     getFileNameByIndex(uint64_t FileIndex, StringRef CompDir,
                        DILineInfoSpecifier::FileLineInfoKind Kind,
                        std::string &Result,
                        sys::path::Style Style = sys::path::Style::native) const;
 
     void clear();
     void dump(raw_ostream &OS, DIDumpOptions DumpOptions) const;
     Error parse(const DWARFDataExtractor &DebugLineData, uint64_t *OffsetPtr,
-                function_ref<void(Error)> RecoverableErrorCallback,
+                function_ref<void(Error)> RecoverableErrorHandler,
                 const DWARFContext &Ctx, const DWARFUnit *U = nullptr);
   };
 
   /// Standard .debug_line state machine structure.
   struct Row {
     explicit Row(bool DefaultIsStmt = false);
 
     /// Called after a row is appended to the matrix.
bool getFileLineInfoForAddress(object::SectionedAddress Address,
                                    DILineInfo &Result) const;
 
     void dump(raw_ostream &OS, DIDumpOptions DumpOptions) const;
     void clear();
 
     /// Parse prologue and all rows.
     Error parse(DWARFDataExtractor &DebugLineData, uint64_t *OffsetPtr,
                 const DWARFContext &Ctx, const DWARFUnit *U,
-                function_ref<void(Error)> RecoverableErrorCallback,
+                function_ref<void(Error)> RecoverableErrorHandler,
                 raw_ostream *OS = nullptr);
 
     using RowVector = std::vector<Row>;
     using RowIter = RowVector::const_iterator;
     using SequenceVector = std::vector<Sequence>;
     using SequenceIter = SequenceVector::const_iterator;
 
     struct Prologue Prologue;
private:
     bool lookupAddressRangeImpl(object::SectionedAddress Address, uint64_t Size,
                                 std::vector<uint32_t> &Result) const;
   };
 
   const LineTable *getLineTable(uint64_t Offset) const;
   Expected<const LineTable *>
   getOrParseLineTable(DWARFDataExtractor &DebugLineData, uint64_t Offset,
                       const DWARFContext &Ctx, const DWARFUnit *U,
-                      function_ref<void(Error)> RecoverableErrorCallback);
+                      function_ref<void(Error)> RecoverableErrorHandler);
 
   /// Helper to allow for parsing of an entire .debug_line section in sequence.
   class SectionParser {
   public:
     using cu_range = DWARFUnitVector::iterator_range;
     using tu_range = DWARFUnitVector::iterator_range;
     using LineToUnitMap = std::map<uint64_t, DWARFUnit *>;
 
     SectionParser(DWARFDataExtractor &Data, const DWARFContext &C, cu_range CUs,
                   tu_range TUs);
 
     /// Get the next line table from the section. Report any issues via the
-    /// callbacks.
+    /// handlers.
     ///
-    /// \param RecoverableErrorCallback - any issues that don't prevent further
-    /// parsing of the table will be reported through this callback.
-    /// \param UnrecoverableErrorCallback - any issues that prevent further
-    /// parsing of the table will be reported through this callback.
+    /// \param RecoverableErrorHandler - any issues that don't prevent further
+    /// parsing of the table will be reported through this handler.
+    /// \param UnrecoverableErrorHandler - any issues that prevent further
+    /// parsing of the table will be reported through this handler.
     /// \param OS - if not null, the parser will print information about the
     /// table as it parses it.
-    LineTable
-    parseNext(
-        function_ref<void(Error)> RecoverableErrorCallback,
-        function_ref<void(Error)> UnrecoverableErrorCallback,
+    LineTable parseNext(function_ref<void(Error)> RecoverableErrorHandler,
+                        function_ref<void(Error)> UnrecoverableErrorHandler,
                         raw_ostream *OS = nullptr);
 
     /// Skip the current line table and go to the following line table (if
     /// present) immediately.
     ///
-    /// \param RecoverableErrorCallback - report any recoverable prologue
-    /// parsing issues via this callback.
-    /// \param UnrecoverableErrorCallback - report any unrecoverable prologue
-    /// parsing issues via this callback.
-    void skip(function_ref<void(Error)> RecoverableErrorCallback,
-              function_ref<void(Error)> UnrecoverableErrorCallback);
+    /// \param RecoverableErrorHandler - report any recoverable prologue
+    /// parsing issues via this handler.
+    /// \param UnrecoverableErrorHandler - report any unrecoverable prologue
+    /// parsing issues via this handler.
+    void skip(function_ref<void(Error)> RecoverableErrorHandler,
+              function_ref<void(Error)> UnrecoverableErrorHandler);
 
     /// Indicates if the parser has parsed as much as possible.
     ///
     /// \note Certain problems with the line table structure might mean that
     /// parsing stops before the end of the section is reached.
     bool done() const { return Done; }
 
     /// Get the offset the parser has reached.

llvm/include/llvm/DebugInfo/DWARF/DWARFDie.h

public:
   /// \returns a valid null DWARFDie instance if this object has children or an
   /// invalid DWARFDie instance if it doesn't.
   DWARFDie getLastChild() const;
 
   /// Dump the DIE and all of its attributes to the supplied stream.
   ///
   /// \param OS the stream to use for output.
   /// \param indent the number of characters to indent each line that is output.
-  void dump(raw_ostream &OS, unsigned indent = 0,
+  void dump(raw_ostream &OS, function_ref<void(Error E)> ErrorHandler,
+            unsigned indent = 0,
             DIDumpOptions DumpOpts = DIDumpOptions()) const;
 
   /// Convenience zero-argument overload for debugging.
   LLVM_DUMP_METHOD void dump() const;
 
   /// Extract the specified attribute from this DIE.
   ///
   /// Extract an attribute value from this DIE only. This call doesn't look

llvm/lib/DWARFLinker/DWARFLinker.cpp

if (!RelocMgr.hasValidRelocationAt(LocationOffset, LocationEndOffset,
       (Flags & TF_InFunctionScope))
     return Flags;
 
   if (Options.Verbose) {
     outs() << "Keeping variable DIE:";
     DIDumpOptions DumpOpts;
     DumpOpts.ChildRecurseDepth = 0;
     DumpOpts.Verbose = Options.Verbose;
-    DIE.dump(outs(), 8 /* Indent */, DumpOpts);
+    DIE.dump(outs(),
+             Unit.getOrigUnit().getContext().getRecoverableErrorHandler(),
+             8 /* Indent */, DumpOpts);
   }
 
   return Flags | TF_Keep;
 }
 
 /// Check if a function describing DIE should be kept.
 /// \returns updated TraversalFlags.
 unsigned DWARFLinker::shouldKeepSubprogramDIE(
if (!LowPc ||
       !RelocMgr.hasValidRelocationAt(LowPcOffset, LowPcEndOffset, MyInfo))
     return Flags;
 
   if (Options.Verbose) {
     outs() << "Keeping subprogram DIE:";
     DIDumpOptions DumpOpts;
     DumpOpts.ChildRecurseDepth = 0;
     DumpOpts.Verbose = Options.Verbose;
-    DIE.dump(outs(), 8 /* Indent */, DumpOpts);
+    DIE.dump(outs(), OrigUnit.getContext().getRecoverableErrorHandler(),
+             8 /* Indent */, DumpOpts);
   }
 
   if (DIE.getTag() == dwarf::DW_TAG_label) {
     if (Unit.hasLabelAt(*LowPc))
       return Flags;
     // FIXME: dsymutil-classic compat. dsymutil-classic doesn't consider labels
     // that don't fall into the CU's aranges. This is wrong IMO. Debug info
     // generation bugs aside, this is really wrong in the case of labels, where
void DWARFLinker::patchLineTableForUnit(CompileUnit &Unit,
   DWARFDebugLine::LineTable LineTable;
   uint64_t StmtOffset = *StmtList;
   DWARFDataExtractor LineExtractor(
       OrigDwarf.getDWARFObj(), OrigDwarf.getDWARFObj().getLineSection(),
       OrigDwarf.isLittleEndian(), Unit.getOrigUnit().getAddressByteSize());
   if (needToTranslateStrings())
     return TheDwarfEmitter->translateLineTable(LineExtractor, StmtOffset);
 
-  Error Err = LineTable.parse(LineExtractor, &StmtOffset, OrigDwarf,
-                              &Unit.getOrigUnit(), DWARFContext::dumpWarning);
-  DWARFContext::dumpWarning(std::move(Err));
+  Error Err =
+      LineTable.parse(LineExtractor, &StmtOffset, OrigDwarf,
+                      &Unit.getOrigUnit(), DWARFContext::defaultWarningHandler);
+  DWARFContext::defaultWarningHandler(std::move(Err));
 
   // This vector is the output line table.
   std::vector<DWARFDebugLine::Row> NewRows;
   NewRows.reserve(LineTable.Rows.size());
 
   // Current sequence of rows being extracted, before being inserted
   // in NewRows.
   std::vector<DWARFDebugLine::Row> Seq;
for (LinkContext &OptContext : ObjectContexts) {
     for (const auto &CU : OptContext.DwarfContext->compile_units()) {
       updateDwarfVersion(CU->getVersion());
       auto CUDie = CU->getUnitDIE(false);
       if (Options.Verbose) {
         outs() << "Input compilation unit:";
         DIDumpOptions DumpOpts;
         DumpOpts.ChildRecurseDepth = 0;
         DumpOpts.Verbose = Options.Verbose;
-        CUDie.dump(outs(), 0, DumpOpts);
+        CUDie.dump(outs(),
+                   OptContext.DwarfContext->getRecoverableErrorHandler(), 0,
+                   DumpOpts);
       }
       if (CUDie && !LLVM_UNLIKELY(Options.Update))
         registerModuleReference(CUDie, *CU, OptContext.ObjectFile,
                                 OffsetsStringPool, UniquingStringPool,
                                 ODRContexts, 0, UnitID,
                                 OptContext.DwarfContext->isLittleEndian());
     }
   }

llvm/lib/DebugInfo/DWARF/DWARFCompileUnit.cpp

 //===-- DWARFCompileUnit.cpp ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h"
+#include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h"
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
 void DWARFCompileUnit::dump(raw_ostream &OS, DIDumpOptions DumpOpts) {
   OS << format("0x%08" PRIx64, getOffset()) << ": Compile Unit:"
      << " length = " << format("0x%08" PRIx64, getLength())
      << " version = " << format("0x%04x", getVersion());
   if (getVersion() >= 5)
     OS << " unit_type = " << dwarf::UnitTypeString(getUnitType());
   OS << " abbr_offset = "
      << format("0x%04" PRIx64, getAbbreviations()->getOffset())
      << " addr_size = " << format("0x%02x", getAddressByteSize());
   if (getVersion() >= 5 && getUnitType() != dwarf::DW_UT_compile)
     OS << " DWO_id = " << format("0x%016" PRIx64, *getDWOId());
   OS << " (next unit at " << format("0x%08" PRIx64, getNextUnitOffset())
      << ")\n";
 
   if (DWARFDie CUDie = getUnitDIE(false))
-    CUDie.dump(OS, 0, DumpOpts);
+    CUDie.dump(OS, getContext().getRecoverableErrorHandler(), 0, DumpOpts);
   else
     OS << "<compile unit can't be parsed!>\n\n";
 }
 
 // VTable anchor.
 DWARFCompileUnit::~DWARFCompileUnit() = default;

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

Contributions.erase(
                   }),
       Contributions.end());
   return Contributions;
 }
 
 static void dumpDWARFv5StringOffsetsSection(
     raw_ostream &OS, StringRef SectionName, const DWARFObject &Obj,
     const DWARFSection &StringOffsetsSection, StringRef StringSection,
-    DWARFContext::unit_iterator_range Units, bool LittleEndian) {
+    DWARFContext::unit_iterator_range Units, bool LittleEndian,
+    function_ref<void(Error)> RecoverableErrorHandler) {
   auto Contributions = collectContributionData(Units);
   DWARFDataExtractor StrOffsetExt(Obj, StringOffsetsSection, LittleEndian, 0);
   DataExtractor StrData(StringSection, LittleEndian, 0);
   uint64_t SectionSize = StringOffsetsSection.Data.size();
   uint64_t Offset = 0;
   for (auto &Contribution : Contributions) {
     // Report an ill-formed contribution.
     if (!Contribution) {
for (auto &Contribution : Contributions) {
     // the string offsets base (the location we have previously retrieved from
     // the CU DIE's DW_AT_str_offsets attribute). The header is located either
     // 8 or 16 bytes before the base, depending on the contribution's format.
     if (Version >= 5)
       ContributionHeader -= Format == DWARF32 ? 8 : 16;
 
     // Detect overlapping contributions.
     if (Offset > ContributionHeader) {
-      WithColor::error()
-          << "overlapping contributions to string offsets table in section ."
-          << SectionName << ".\n";
+      RecoverableErrorHandler(createStringError(
+          errc::invalid_argument,
+          "overlapping contributions to string offsets table in section .%s.",
+          SectionName.data()));
       return;
     }
     // Report a gap in the table.
     if (Offset < ContributionHeader) {
       OS << format("0x%8.8" PRIx64 ": Gap, length = ", Offset);
       OS << (ContributionHeader - Offset) << "\n";
     }
     OS << format("0x%8.8" PRIx64 ": ", ContributionHeader);

 }
 
 // Dump a DWARF string offsets section. This may be a DWARF v5 formatted
 // string offsets section, where each compile or type unit contributes a
 // number of entries (string offsets), with each contribution preceded by
 // a header containing size and version number. Alternatively, it may be a
 // monolithic series of string offsets, as generated by the pre-DWARF v5
 // implementation of split DWARF.
-static void dumpStringOffsetsSection(raw_ostream &OS, StringRef SectionName,
-                                     const DWARFObject &Obj,
-                                     const DWARFSection &StringOffsetsSection,
-                                     StringRef StringSection,
-                                     DWARFContext::unit_iterator_range Units,
-                                     bool LittleEndian, unsigned MaxVersion) {
+static void dumpStringOffsetsSection(
+    raw_ostream &OS, StringRef SectionName, const DWARFObject &Obj,
+    const DWARFSection &StringOffsetsSection, StringRef StringSection,
+    DWARFContext::unit_iterator_range Units, bool LittleEndian,
+    unsigned MaxVersion, function_ref<void(Error)> RecoverableErrorHandler) {
   // If we have at least one (compile or type) unit with DWARF v5 or greater,
   // we assume that the section is formatted like a DWARF v5 string offsets
   // section.
   if (MaxVersion >= 5)
     dumpDWARFv5StringOffsetsSection(OS, SectionName, Obj, StringOffsetsSection,
-                                    StringSection, Units, LittleEndian);
+                                    StringSection, Units, LittleEndian,
+                                    RecoverableErrorHandler);
   else {
     DataExtractor strOffsetExt(StringOffsetsSection.Data, LittleEndian, 0);
     uint64_t offset = 0;
     uint64_t size = StringOffsetsSection.Data.size();
     // Ensure that size is a multiple of the size of an entry.
     if (size & ((uint64_t)(sizeof(uint32_t) - 1))) {
       OS << "error: size of ." << SectionName << " is not a multiple of "
          << sizeof(uint32_t) << ".\n";
while (offset < size) {
       OS << "\n";
     }
   }
 }
 
 // Dump the .debug_addr section.
 static void dumpAddrSection(raw_ostream &OS, DWARFDataExtractor &AddrData,
                             DIDumpOptions DumpOpts, uint16_t Version,
-                            uint8_t AddrSize) {
+                            uint8_t AddrSize,
+                            function_ref<void(Error)> RecoverableErrorHandler,
+                            function_ref<void(Error)> WarningHandler) {
   uint64_t Offset = 0;
   while (AddrData.isValidOffset(Offset)) {
     DWARFDebugAddrTable AddrTable;
     uint64_t TableOffset = Offset;
     if (Error Err = AddrTable.extract(AddrData, &Offset, Version, AddrSize,
-                                      DWARFContext::dumpWarning)) {
-      WithColor::error() << toString(std::move(Err)) << '\n';
+                                      WarningHandler)) {
+      RecoverableErrorHandler(std::move(Err));
       // Keep going after an error, if we can, assuming that the length field
       // could be read. If it couldn't, stop reading the section.
       if (!AddrTable.hasValidLength())
         break;
       Offset = TableOffset + AddrTable.getLength();
     } else {
       AddrTable.dump(OS, DumpOpts);
     }
   }
 }
 
 // Dump the .debug_rnglists or .debug_rnglists.dwo section (DWARF v5).
 static void dumpRnglistsSection(
     raw_ostream &OS, DWARFDataExtractor &rnglistData,
     llvm::function_ref<Optional<object::SectionedAddress>(uint32_t)>
         LookupPooledAddress,
-    DIDumpOptions DumpOpts) {
+    DIDumpOptions DumpOpts, function_ref<void(Error)> RecoverableErrorHandler) {
   uint64_t Offset = 0;
   while (rnglistData.isValidOffset(Offset)) {
     llvm::DWARFDebugRnglistTable Rnglists;
     uint64_t TableOffset = Offset;
     if (Error Err = Rnglists.extract(rnglistData, &Offset)) {
-      WithColor::error() << toString(std::move(Err)) << '\n';
+      RecoverableErrorHandler(std::move(Err));
       uint64_t Length = Rnglists.length();
       // Keep going after an error, if we can, assuming that the length field
       // could be read. If it couldn't, stop reading the section.
       if (Length == 0)
         break;
       Offset = TableOffset + Length;
     } else {
       Rnglists.dump(OS, LookupPooledAddress, DumpOpts);
     }
   }
 }
 
-static void dumpLoclistsSection(raw_ostream &OS, DIDumpOptions DumpOpts,
-                                DWARFDataExtractor Data,
-                                const MCRegisterInfo *MRI,
-                                const DWARFObject &Obj,
-                                Optional<uint64_t> DumpOffset) {
+static void
+dumpLoclistsSection(raw_ostream &OS, DIDumpOptions DumpOpts,
+                    DWARFDataExtractor Data, const MCRegisterInfo *MRI,
+                    const DWARFObject &Obj, Optional<uint64_t> DumpOffset,
+                    function_ref<void(Error)> RecoverableErrorHandler) {
   uint64_t Offset = 0;
 
   while (Data.isValidOffset(Offset)) {
     DWARFListTableHeader Header(".debug_loclists", "locations");
     if (Error E = Header.extract(Data, &Offset)) {
-      WithColor::error() << toString(std::move(E)) << '\n';
+      RecoverableErrorHandler(std::move(E));
       return;
     }
 
     Header.dump(OS, DumpOpts);
 
     uint64_t EndOffset = Header.length() + Header.getHeaderOffset();
     Data.setAddressSize(Header.getAddrSize());
     DWARFDebugLoclists Loc(Data, Header.getVersion());
if (shouldDump(ExplicitDWO, ".debug_abbrev.dwo", DIDT_ID_DebugAbbrev,
                  DObj->getAbbrevDWOSection()))
     getDebugAbbrevDWO()->dump(OS);
 
   auto dumpDebugInfo = [&](const char *Name, unit_iterator_range Units) {
     OS << '\n' << Name << " contents:\n";
     if (auto DumpOffset = DumpOffsets[DIDT_ID_DebugInfo])
       for (const auto &U : Units)
         U->getDIEForOffset(DumpOffset.getValue())
-            .dump(OS, 0, DumpOpts.noImplicitRecursion());
+            .dump(OS, RecoverableErrorHandler, 0,
+                  DumpOpts.noImplicitRecursion());
     else
       for (const auto &U : Units)
         U->dump(OS, DumpOpts);
   };
   if ((DumpType & DIDT_DebugInfo)) {
     if (Explicit || getNumCompileUnits())
       dumpDebugInfo(".debug_info", info_section_units());
     if (ExplicitDWO || getNumDWOCompileUnits())
       dumpDebugInfo(".debug_info.dwo", dwo_info_section_units());
   }
 
   auto dumpDebugType = [&](const char *Name, unit_iterator_range Units) {
     OS << '\n' << Name << " contents:\n";
     for (const auto &U : Units)
       if (auto DumpOffset = DumpOffsets[DIDT_ID_DebugTypes])
         U->getDIEForOffset(*DumpOffset)
-            .dump(OS, 0, DumpOpts.noImplicitRecursion());
+            .dump(OS, RecoverableErrorHandler, 0,
+                  DumpOpts.noImplicitRecursion());
       else
         U->dump(OS, DumpOpts);
   };
   if ((DumpType & DIDT_DebugTypes)) {
     if (Explicit || getNumTypeUnits())
       dumpDebugType(".debug_types", types_section_units());
     if (ExplicitDWO || getNumDWOTypeUnits())
       dumpDebugType(".debug_types.dwo", dwo_types_section_units());
   }
 
   DIDumpOptions LLDumpOpts = DumpOpts;
   if (LLDumpOpts.Verbose)
     LLDumpOpts.DisplayRawContents = true;
 
   if (const auto *Off = shouldDump(Explicit, ".debug_loc", DIDT_ID_DebugLoc,
                                    DObj->getLocSection().Data)) {
     getDebugLoc()->dump(OS, getRegisterInfo(), *DObj, LLDumpOpts, *Off);
   }
   if (const auto *Off =
           shouldDump(Explicit, ".debug_loclists", DIDT_ID_DebugLoclists,
                      DObj->getLoclistsSection().Data)) {
     DWARFDataExtractor Data(*DObj, DObj->getLoclistsSection(), isLittleEndian(),
                             0);
-    dumpLoclistsSection(OS, LLDumpOpts, Data, getRegisterInfo(), *DObj, *Off);
+    dumpLoclistsSection(OS, LLDumpOpts, Data, getRegisterInfo(), *DObj, *Off,
+                        RecoverableErrorHandler);
   }
   if (const auto *Off =
           shouldDump(ExplicitDWO, ".debug_loclists.dwo", DIDT_ID_DebugLoclists,
                      DObj->getLoclistsDWOSection().Data)) {
     DWARFDataExtractor Data(*DObj, DObj->getLoclistsDWOSection(),
                             isLittleEndian(), 0);
-    dumpLoclistsSection(OS, LLDumpOpts, Data, getRegisterInfo(), *DObj, *Off);
+    dumpLoclistsSection(OS, LLDumpOpts, Data, getRegisterInfo(), *DObj, *Off,
+                        RecoverableErrorHandler);
   }
 
   if (const auto *Off =
           shouldDump(ExplicitDWO, ".debug_loc.dwo", DIDT_ID_DebugLoc,
                      DObj->getLocDWOSection().Data)) {
     DWARFDataExtractor Data(*DObj, DObj->getLocDWOSection(), isLittleEndian(),
                             4);
     DWARFDebugLoclists Loc(Data, /*Version=*/4);
void DWARFContext::dump(
 
   if (shouldDump(Explicit, ".debug_aranges", DIDT_ID_DebugAranges,
                  DObj->getArangesSection())) {
     uint64_t offset = 0;
     DataExtractor arangesData(DObj->getArangesSection(), isLittleEndian(), 0);
     DWARFDebugArangeSet set;
     while (arangesData.isValidOffset(offset)) {
       if (Error E = set.extract(arangesData, &offset)) {
-        WithColor::error() << toString(std::move(E)) << '\n';
+        RecoverableErrorHandler(std::move(E));
         break;
       }
       set.dump(OS);
     }
   }
 
   auto DumpLineSection = [&](DWARFDebugLine::SectionParser Parser,
                              DIDumpOptions DumpOpts,
                              Optional<uint64_t> DumpOffset) {
     while (!Parser.done()) {
       if (DumpOffset && Parser.getOffset() != *DumpOffset) {
-        Parser.skip(dumpWarning, dumpWarning);
+        Parser.skip(WarningHandler, WarningHandler);
         continue;
       }
       OS << "debug_line[" << format("0x%8.8" PRIx64, Parser.getOffset())
          << "]\n";
       if (DumpOpts.Verbose) {
-        Parser.parseNext(dumpWarning, dumpWarning, &OS);
+        Parser.parseNext(WarningHandler, WarningHandler, &OS);
       } else {
         DWARFDebugLine::LineTable LineTable =
-            Parser.parseNext(dumpWarning, dumpWarning);
+            Parser.parseNext(WarningHandler, WarningHandler);
         LineTable.dump(OS, DumpOpts);
       }
     }
   };
 
   if (const auto *Off = shouldDump(Explicit, ".debug_line", DIDT_ID_DebugLine,
                                    DObj->getLineSection().Data)) {
     DWARFDataExtractor LineData(*DObj, DObj->getLineSection(), isLittleEndian(),
while (const char *s = strData.getCStr(&offset)) {
       strOffset = offset;
     }
   }
 
   if (shouldDump(Explicit, ".debug_addr", DIDT_ID_DebugAddr,
                  DObj->getAddrSection().Data)) {
     DWARFDataExtractor AddrData(*DObj, DObj->getAddrSection(),
                                    isLittleEndian(), 0);
-    dumpAddrSection(OS, AddrData, DumpOpts, getMaxVersion(), getCUAddrSize());
+    dumpAddrSection(OS, AddrData, DumpOpts, getMaxVersion(), getCUAddrSize(),
+                    RecoverableErrorHandler, WarningHandler);
   }
 
   if (shouldDump(Explicit, ".debug_ranges", DIDT_ID_DebugRanges,
                  DObj->getRangesSection().Data)) {
     uint8_t savedAddressByteSize = getCUAddrSize();
     DWARFDataExtractor rangesData(*DObj, DObj->getRangesSection(),
                                   isLittleEndian(), savedAddressByteSize);
     uint64_t offset = 0;
     DWARFDebugRangeList rangeList;
     while (rangesData.isValidOffset(offset)) {
       if (Error E = rangeList.extract(rangesData, &offset)) {
-        WithColor::error() << toString(std::move(E)) << '\n';
+        RecoverableErrorHandler(std::move(E));
         break;
       }
       rangeList.dump(OS);
     }
   }
 
   auto LookupPooledAddress = [&](uint32_t Index) -> Optional<SectionedAddress> {
     const auto &CUs = compile_units();
     auto I = CUs.begin();
     if (I == CUs.end())
       return None;
     return (*I)->getAddrOffsetSectionItem(Index);
   };
 
   if (shouldDump(Explicit, ".debug_rnglists", DIDT_ID_DebugRnglists,
                  DObj->getRnglistsSection().Data)) {
     DWARFDataExtractor RnglistData(*DObj, DObj->getRnglistsSection(),
                                    isLittleEndian(), 0);
-    dumpRnglistsSection(OS, RnglistData, LookupPooledAddress, DumpOpts);
+    dumpRnglistsSection(OS, RnglistData, LookupPooledAddress, DumpOpts,
+                        RecoverableErrorHandler);
   }
 
   if (shouldDump(ExplicitDWO, ".debug_rnglists.dwo", DIDT_ID_DebugRnglists,
                  DObj->getRnglistsDWOSection().Data)) {
     DWARFDataExtractor RnglistData(*DObj, DObj->getRnglistsDWOSection(),
                                    isLittleEndian(), 0);
-    dumpRnglistsSection(OS, RnglistData, LookupPooledAddress, DumpOpts);
+    dumpRnglistsSection(OS, RnglistData, LookupPooledAddress, DumpOpts,
+                        RecoverableErrorHandler);
   }
 
   if (shouldDump(Explicit, ".debug_pubnames", DIDT_ID_DebugPubnames,
                  DObj->getPubnamesSection().Data))
     DWARFDebugPubTable(*DObj, DObj->getPubnamesSection(), isLittleEndian(), false)
         .dump(OS);
 
   if (shouldDump(Explicit, ".debug_pubtypes", DIDT_ID_DebugPubtypes,
void DWARFContext::dump(
   if (shouldDump(Explicit, ".debug_gnu_pubtypes", DIDT_ID_DebugGnuPubtypes,
                  DObj->getGnuPubtypesSection().Data))
     DWARFDebugPubTable(*DObj, DObj->getGnuPubtypesSection(), isLittleEndian(),
                        true /* GnuStyle */)
         .dump(OS);
 
   if (shouldDump(Explicit, ".debug_str_offsets", DIDT_ID_DebugStrOffsets,
                  DObj->getStrOffsetsSection().Data))
-    dumpStringOffsetsSection(OS, "debug_str_offsets", *DObj,
-                             DObj->getStrOffsetsSection(),
-                             DObj->getStrSection(), normal_units(),
-                             isLittleEndian(), getMaxVersion());
+    dumpStringOffsetsSection(
+        OS, "debug_str_offsets", *DObj, DObj->getStrOffsetsSection(),
+        DObj->getStrSection(), normal_units(), isLittleEndian(),
+        getMaxVersion(), RecoverableErrorHandler);
   if (shouldDump(ExplicitDWO, ".debug_str_offsets.dwo", DIDT_ID_DebugStrOffsets,
                  DObj->getStrOffsetsDWOSection().Data))
-    dumpStringOffsetsSection(OS, "debug_str_offsets.dwo", *DObj,
-                             DObj->getStrOffsetsDWOSection(),
-                             DObj->getStrDWOSection(), dwo_units(),
-                             isLittleEndian(), getMaxDWOVersion());
+    dumpStringOffsetsSection(
+        OS, "debug_str_offsets.dwo", *DObj, DObj->getStrOffsetsDWOSection(),
+        DObj->getStrDWOSection(), dwo_units(), isLittleEndian(),
+        getMaxDWOVersion(), RecoverableErrorHandler);
 
   if (shouldDump(Explicit, ".gdb_index", DIDT_ID_GdbIndex,
                  DObj->getGdbIndexSection())) {
     getGdbIndex().dump(OS);
   }
 
   if (shouldDump(Explicit, ".apple_names", DIDT_ID_AppleNames,
                  DObj->getAppleNamesSection().Data))

 const AppleAcceleratorTable &DWARFContext::getAppleObjC() {
   return getAccelTable(AppleObjC, *DObj, DObj->getAppleObjCSection(),
                        DObj->getStrSection(), isLittleEndian());
 }
 
 const DWARFDebugLine::LineTable *
 DWARFContext::getLineTableForUnit(DWARFUnit *U) {
   Expected<const DWARFDebugLine::LineTable *> ExpectedLineTable =
-      getLineTableForUnit(U, dumpWarning);
+      getLineTableForUnit(U, WarningHandler);
   if (!ExpectedLineTable) {
-    dumpWarning(ExpectedLineTable.takeError());
+    WarningHandler(ExpectedLineTable.takeError());
     return nullptr;
   }
   return *ExpectedLineTable;
 }
 
 Expected<const DWARFDebugLine::LineTable *> DWARFContext::getLineTableForUnit(
-    DWARFUnit *U, function_ref<void(Error)> RecoverableErrorCallback) {
+    DWARFUnit *U, function_ref<void(Error)> RecoverableErrorHandler) {
   if (!Line)
     Line.reset(new DWARFDebugLine);
 
   auto UnitDIE = U->getUnitDIE();
   if (!UnitDIE)
     return nullptr;
 
   auto Offset = toSectionOffset(UnitDIE.find(DW_AT_stmt_list));
   if (!Offset)
     return nullptr; // No line table for this compile unit.
 
   uint64_t stmtOffset = *Offset + U->getLineTableOffset();
   // See if the line table is cached.
   if (const DWARFLineTable *lt = Line->getLineTable(stmtOffset))
     return lt;
 
   // Make sure the offset is good before we try to parse.
   if (stmtOffset >= U->getLineSection().Data.size())
     return nullptr;
 
   // We have to parse it first.
   DWARFDataExtractor lineData(*DObj, U->getLineSection(), isLittleEndian(),
                               U->getAddressByteSize());
   return Line->getOrParseLineTable(lineData, stmtOffset, *this, U,
-                                   RecoverableErrorCallback);
+                                   RecoverableErrorHandler);
 }
 
 void DWARFContext::parseNormalUnits() {
   if (!NormalUnits.empty())
     return;
   DObj->forEachInfoSections([&](const DWARFSection &S) {
     NormalUnits.addUnitsForSection(*this, S, DW_SECT_INFO);
   });
static bool isRelocScattered(const object::ObjectFile &Obj,
   if (!MachObj)
     return false;
   // MachO also has relocations that point to sections and
   // scattered relocations.
   auto RelocInfo = MachObj->getRelocation(Reloc.getRawDataRefImpl());
   return MachObj->isRelocationScattered(RelocInfo);
 }
 
 ErrorPolicy DWARFContext::defaultErrorHandler(Error E) {
-  WithColor::error() << toString(std::move(E)) << '\n';
+  handleAllErrors(std::move(E), [](ErrorInfoBase &Info) {
+    WithColor::error() << Info.message() << '\n';
+  });
   return ErrorPolicy::Continue;
 }
 
+void DWARFContext::defaultWarningHandler(Error Warning) {
+  handleAllErrors(std::move(Warning), [](ErrorInfoBase &Info) {
+    WithColor::warning() << Info.message() << '\n';
+  });
+}
+
 namespace {
 struct DWARFSectionMap final : public DWARFSection {
   RelocAddrMap Relocs;
 };
 
 class DWARFObjInMemory final : public DWARFObject {
   bool IsLittleEndian;
   uint8_t AddressSize;
uint8_t DWARFContext::getCUAddrSize() {
   uint8_t Addr = 0;
   for (const auto &CU : compile_units()) {
     Addr = CU->getAddressByteSize();
     break;
   }
   return Addr;
 }
 
-void DWARFContext::dumpWarning(Error Warning) {
-  handleAllErrors(std::move(Warning), [](ErrorInfoBase &Info) {
-      WithColor::warning() << Info.message() << '\n';
-  });
-}

llvm/lib/DebugInfo/DWARF/DWARFDebugAranges.cpp

 //===- DWARFDebugAranges.cpp ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/DWARF/DWARFDebugAranges.h"
 #include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugArangeSet.h"
 #include "llvm/Support/DataExtractor.h"
-#include "llvm/Support/WithColor.h"
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <set>
 #include <vector>
 
 using namespace llvm;
 
-void DWARFDebugAranges::extract(DataExtractor DebugArangesData) {
+void DWARFDebugAranges::extract(
+    DataExtractor DebugArangesData,
+    function_ref<void(Error)> RecoverableErrorHandler) {
   if (!DebugArangesData.isValidOffset(0))
     return;
   uint64_t Offset = 0;
   DWARFDebugArangeSet Set;
 
   while (DebugArangesData.isValidOffset(Offset)) {
     if (Error E = Set.extract(DebugArangesData, &Offset)) {
-      WithColor::error() << toString(std::move(E)) << '\n';
+      RecoverableErrorHandler(std::move(E));
       return;
     }
     uint64_t CUOffset = Set.getCompileUnitDIEOffset();
     for (const auto &Desc : Set.descriptors()) {
       uint64_t LowPC = Desc.Address;
       uint64_t HighPC = Desc.getEndAddress();
       appendRange(CUOffset, LowPC, HighPC);
     }
     ParsedCUOffsets.insert(CUOffset);
   }
 }
 
 void DWARFDebugAranges::generate(DWARFContext *CTX) {
   clear();
   if (!CTX)
     return;
 
   // Extract aranges from .debug_aranges section.
   DataExtractor ArangesData(CTX->getDWARFObj().getArangesSection(),
                             CTX->isLittleEndian(), 0);
-  extract(ArangesData);
+  extract(ArangesData, CTX->getRecoverableErrorHandler());
 
   // Generate aranges from DIEs: even if .debug_aranges section is present,
   // it may describe only a small subset of compilation units, so we need to
   // manually build aranges for the rest of them.
   for (const auto &CU : CTX->compile_units()) {
     uint64_t CUOffset = CU->getOffset();
     if (ParsedCUOffsets.insert(CUOffset).second) {
       Expected<DWARFAddressRangesVector> CURanges = CU->collectAddressRanges();
       if (!CURanges)
-        WithColor::error() << toString(CURanges.takeError()) << '\n';
+        CTX->getRecoverableErrorHandler()(CURanges.takeError());
       else
         for (const auto &R : *CURanges)
           appendRange(CUOffset, R.LowPC, R.HighPC);
     }
   }
 
   construct();
 }

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormatVariadic.h"
-#include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <cinttypes>
 #include <cstdint>
 #include <cstdio>
 #include <utility>
 
uint64_t Length = PrologueLength + sizeofTotalLength() +
                     sizeof(getVersion()) + sizeofPrologueLength();
   if (getVersion() >= 5)
     Length += 2; // Address + Segment selector sizes.
   return Length;
 }
 
 Error DWARFDebugLine::Prologue::parse(
     const DWARFDataExtractor &DebugLineData, uint64_t *OffsetPtr,
-    function_ref<void(Error)> RecoverableErrorCallback, const DWARFContext &Ctx,
+    function_ref<void(Error)> RecoverableErrorHandler, const DWARFContext &Ctx,
     const DWARFUnit *U) {
   const uint64_t PrologueOffset = *OffsetPtr;
 
   clear();
   TotalLength = DebugLineData.getRelocatedValue(4, OffsetPtr);
   if (TotalLength == dwarf::DW_LENGTH_DWARF64) {
     FormParams.Format = dwarf::DWARF64;
     TotalLength = DebugLineData.getU64(OffsetPtr);
for (uint32_t I = 1; I < OpcodeBase; ++I) {
     uint8_t OpLen = DebugLineData.getU8(OffsetPtr);
     StandardOpcodeLengths.push_back(OpLen);
   }
 
   if (getVersion() >= 5) {
     if (Error E =
             parseV5DirFileTables(DebugLineData, OffsetPtr, FormParams, Ctx, U,
                                  ContentTypes, IncludeDirectories, FileNames)) {
-      RecoverableErrorCallback(joinErrors(
+      RecoverableErrorHandler(joinErrors(
           createStringError(
               errc::invalid_argument,
               "parsing line table prologue at 0x%8.8" PRIx64
               " found an invalid directory or file table description at"
               " 0x%8.8" PRIx64,
               PrologueOffset, *OffsetPtr),
           std::move(E)));
       // Skip to the end of the prologue, since the chances are that the parser
       // did not read the whole table. This prevents the length check below from
       // executing.
       if (*OffsetPtr < EndPrologueOffset)
         *OffsetPtr = EndPrologueOffset;
     }
   } else
     parseV2DirFileTables(DebugLineData, OffsetPtr, EndPrologueOffset,
                          ContentTypes, IncludeDirectories, FileNames);
 
   if (*OffsetPtr != EndPrologueOffset) {
-    RecoverableErrorCallback(createStringError(
+    RecoverableErrorHandler(createStringError(
         errc::invalid_argument,
         "parsing line table prologue at 0x%8.8" PRIx64
         " should have ended at 0x%8.8" PRIx64 " but it ended at 0x%8.8" PRIx64,
         PrologueOffset, EndPrologueOffset, *OffsetPtr));
     *OffsetPtr = EndPrologueOffset;
   }
   return Error::success();
 }
DWARFDebugLine::getLineTable(uint64_t Offset) const {
   LineTableConstIter Pos = LineTableMap.find(Offset);
   if (Pos != LineTableMap.end())
     return &Pos->second;
   return nullptr;
 }
 
 Expected<const DWARFDebugLine::LineTable *> DWARFDebugLine::getOrParseLineTable(
     DWARFDataExtractor &DebugLineData, uint64_t Offset, const DWARFContext &Ctx,
-    const DWARFUnit *U, function_ref<void(Error)> RecoverableErrorCallback) {
+    const DWARFUnit *U, function_ref<void(Error)> RecoverableErrorHandler) {
   if (!DebugLineData.isValidOffset(Offset))
     return createStringError(errc::invalid_argument, "offset 0x%8.8" PRIx64
                        " is not a valid debug line section offset",
                        Offset);
 
   std::pair<LineTableIter, bool> Pos =
       LineTableMap.insert(LineTableMapTy::value_type(Offset, LineTable()));
   LineTable *LT = &Pos.first->second;
   if (Pos.second) {
     if (Error Err =
-            LT->parse(DebugLineData, &Offset, Ctx, U, RecoverableErrorCallback))
+            LT->parse(DebugLineData, &Offset, Ctx, U, RecoverableErrorHandler))
       return std::move(Err);
     return LT;
   }
   return LT;
 }
 
 Error DWARFDebugLine::LineTable::parse(
     DWARFDataExtractor &DebugLineData, uint64_t *OffsetPtr,
     const DWARFContext &Ctx, const DWARFUnit *U,
-    function_ref<void(Error)> RecoverableErrorCallback, raw_ostream *OS) {
+    function_ref<void(Error)> RecoverableErrorHandler, raw_ostream *OS) {
   const uint64_t DebugLineOffset = *OffsetPtr;
 
   clear();
 
-  Error PrologueErr = Prologue.parse(DebugLineData, OffsetPtr,
-                                     RecoverableErrorCallback, Ctx, U);
+  Error PrologueErr =
+      Prologue.parse(DebugLineData, OffsetPtr, RecoverableErrorHandler, Ctx, U);
 
   if (OS) {
     // The presence of OS signals verbose dumping.
     DIDumpOptions DumpOptions;
     DumpOptions.Verbose = true;
     Prologue.dump(*OS, DumpOptions);
   }
 
   if (PrologueErr)
     return PrologueErr;
 
   uint64_t ProgramLength = Prologue.TotalLength + Prologue.sizeofTotalLength();
   if (!DebugLineData.isValidOffsetForDataOfSize(DebugLineOffset,
                                                 ProgramLength)) {
     assert(DebugLineData.size() > DebugLineOffset &&
            "prologue parsing should handle invalid offset");
     uint64_t BytesRemaining = DebugLineData.size() - DebugLineOffset;
-    RecoverableErrorCallback(
+    RecoverableErrorHandler(
         createStringError(errc::invalid_argument,
                           "line table program with offset 0x%8.8" PRIx64
                           " has length 0x%8.8" PRIx64 " but only 0x%8.8" PRIx64
                           " bytes are available",
                           DebugLineOffset, ProgramLength, BytesRemaining));
     // Continue by capping the length at the number of remaining bytes.
     ProgramLength = BytesRemaining;
   }
if (Opcode == 0) {
         // that affect the address register add a delta to it. This instruction
         // stores a relocatable value into it instead.
         //
         // Make sure the extractor knows the address size.  If not, infer it
         // from the size of the operand.
         {
           uint8_t ExtractorAddressSize = DebugLineData.getAddressSize();
           if (ExtractorAddressSize != Len - 1 && ExtractorAddressSize != 0)
-            RecoverableErrorCallback(createStringError(
+            RecoverableErrorHandler(createStringError(
                 errc::invalid_argument,
                 "mismatching address size at offset 0x%8.8" PRIx64
                 " expected 0x%2.2" PRIx8 " found 0x%2.2" PRIx64,
                 ExtOffset, ExtractorAddressSize, Len - 1));
 
           // Assume that the line table is correct and temporarily override the
           // address size.
           DebugLineData.setAddressSize(Len - 1);
if (Opcode == 0) {
         (*OffsetPtr) += Len - 1;
         break;
       }
       // Make sure the length as recorded in the table and the standard length
       // for the opcode match. If they don't, continue from the end as claimed
       // by the table.
       uint64_t End = ExtOffset + Len;
       if (*OffsetPtr != End) {
-        RecoverableErrorCallback(createStringError(
+        RecoverableErrorHandler(createStringError(
             errc::illegal_byte_sequence,
             "unexpected line op length at offset 0x%8.8" PRIx64
             " expected 0x%2.2" PRIx64 " found 0x%2.2" PRIx64,
             ExtOffset, Len, *OffsetPtr - ExtOffset));
         *OffsetPtr = End;
       }
     } else if (Opcode < Prologue.OpcodeBase) {
       if (OS)
if (Opcode == 0) {
 
       State.appendRowToMatrix();
     }
     if(OS)
       *OS << "\n";
   }
 
   if (!State.Sequence.Empty)
-    RecoverableErrorCallback(createStringError(
+    RecoverableErrorHandler(createStringError(
         errc::illegal_byte_sequence,
         "last sequence in debug line table at offset 0x%8.8" PRIx64
         " is not terminated",
         DebugLineOffset));
 
   // Sort all sequences so that address lookup will work faster.
   if (!Sequences.empty()) {
     llvm::sort(Sequences, Sequence::orderByHighPC);

 }
 
 bool DWARFDebugLine::Prologue::totalLengthIsValid() const {
   return TotalLength == dwarf::DW_LENGTH_DWARF64 ||
          TotalLength < dwarf::DW_LENGTH_lo_reserved;
 }
 
 DWARFDebugLine::LineTable DWARFDebugLine::SectionParser::parseNext(
-    function_ref<void(Error)> RecoverableErrorCallback,
-    function_ref<void(Error)> UnrecoverableErrorCallback, raw_ostream *OS) {
+    function_ref<void(Error)> RecoverableErrorHandler,
+    function_ref<void(Error)> UnrecoverableErrorHandler, raw_ostream *OS) {
   assert(DebugLineData.isValidOffset(Offset) &&
          "parsing should have terminated");
   DWARFUnit *U = prepareToParse(Offset);
   uint64_t OldOffset = Offset;
   LineTable LT;
   if (Error Err = LT.parse(DebugLineData, &Offset, Context, U,
-                           RecoverableErrorCallback, OS))
-    UnrecoverableErrorCallback(std::move(Err));
+                           RecoverableErrorHandler, OS))
+    UnrecoverableErrorHandler(std::move(Err));
   moveToNextTable(OldOffset, LT.Prologue);
   return LT;
 }
 
 void DWARFDebugLine::SectionParser::skip(
-    function_ref<void(Error)> RecoverableErrorCallback,
-    function_ref<void(Error)> UnrecoverableErrorCallback) {
+    function_ref<void(Error)> RecoverableErrorHandler,
+    function_ref<void(Error)> UnrecoverableErrorHandler) {
   assert(DebugLineData.isValidOffset(Offset) &&
          "parsing should have terminated");
   DWARFUnit *U = prepareToParse(Offset);
   uint64_t OldOffset = Offset;
   LineTable LT;
   if (Error Err = LT.Prologue.parse(DebugLineData, &Offset,
-                                    RecoverableErrorCallback, Context, U))
-    UnrecoverableErrorCallback(std::move(Err));
+                                    RecoverableErrorHandler, Context, U))
+    UnrecoverableErrorHandler(std::move(Err));
   moveToNextTable(OldOffset, LT.Prologue);
 }
 
 DWARFUnit *DWARFDebugLine::SectionParser::prepareToParse(uint64_t Offset) {
   DWARFUnit *U = nullptr;
   auto It = LineToUnit.find(Offset);
   if (It != LineToUnit.end())
     U = It->second;

llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp

 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFExpression.h"
 #include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Format.h"
-#include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cinttypes>
 #include <cstdint>
 
 using namespace llvm;
 using object::SectionedAddress;
 

llvm/lib/DebugInfo/DWARF/DWARFDie.cpp

static void dumpTypeName(raw_ostream &OS, const DWARFDie &D) {
   default:
     break;
   }
 }
 
 static void dumpAttribute(raw_ostream &OS, const DWARFDie &Die,
                           uint64_t *OffsetPtr, dwarf::Attribute Attr,
                           dwarf::Form Form, unsigned Indent,
-                          DIDumpOptions DumpOpts) {
+                          DIDumpOptions DumpOpts,
+                          function_ref<void(Error)> ErrorHandler) {
   if (!Die.isValid())
     return;
   const char BaseIndent[] = "            ";
   OS << BaseIndent;
   OS.indent(Indent + 2);
   WithColor(OS, HighlightColor::Attribute) << formatv("{0}", Attr);
 
   if (DumpOpts.Verbose || DumpOpts.ShowForm)
if (FormValue.getForm() == DW_FORM_rnglistx)
               U->getRnglistOffset(*FormValue.getAsSectionOffset())) {
         DWARFFormValue FV = DWARFFormValue::createFromUValue(
             dwarf::DW_FORM_sec_offset, *RangeListOffset);
         FV.dump(OS, DumpOpts);
       }
     if (auto RangesOrError = Die.getAddressRanges())
       dumpRanges(Obj, OS, RangesOrError.get(), U->getAddressByteSize(),
                  sizeof(BaseIndent) + Indent + 4, DumpOpts);
-    else
-      WithColor::error() << "decoding address ranges: "
-                         << toString(RangesOrError.takeError()) << '\n';
+    else {
+      ErrorHandler(createStringError(
+          errc::invalid_argument, "decoding address ranges: %s",
+          toString(RangesOrError.takeError()).c_str()));
+    }
   }
 
   OS << ")\n";
 }
 
 bool DWARFDie::isSubprogramDIE() const { return getTag() == DW_TAG_subprogram; }
 
 bool DWARFDie::isSubroutineDIE() const {
void DWARFDie::getCallerFrame(uint32_t &CallFile, uint32_t &CallLine,
                               uint32_t &CallDiscriminator) const {
   CallFile = toUnsigned(find(DW_AT_call_file), 0);
   CallLine = toUnsigned(find(DW_AT_call_line), 0);
   CallColumn = toUnsigned(find(DW_AT_call_column), 0);
   CallDiscriminator = toUnsigned(find(DW_AT_GNU_discriminator), 0);
 }
 
 /// Helper to dump a DIE with all of its parents, but no siblings.
-static unsigned dumpParentChain(DWARFDie Die, raw_ostream &OS, unsigned Indent,
-                                DIDumpOptions DumpOpts, unsigned Depth = 0) {
+static unsigned dumpParentChain(DWARFDie Die, raw_ostream &OS,
+                                function_ref<void(Error E)> ErrorHandler,
+                                unsigned Indent, DIDumpOptions DumpOpts,
+                                unsigned Depth = 0) {
   if (!Die)
     return Indent;
   if (DumpOpts.ParentRecurseDepth > 0 && Depth >= DumpOpts.ParentRecurseDepth)
     return Indent;
-  Indent = dumpParentChain(Die.getParent(), OS, Indent, DumpOpts, Depth + 1);
-  Die.dump(OS, Indent, DumpOpts);
+  Indent = dumpParentChain(Die.getParent(), OS, ErrorHandler, Indent, DumpOpts,
+                           Depth + 1);
+  Die.dump(OS, ErrorHandler, Indent, DumpOpts);
   return Indent + 2;
 }
 
-void DWARFDie::dump(raw_ostream &OS, unsigned Indent,
-                    DIDumpOptions DumpOpts) const {
+void DWARFDie::dump(raw_ostream &OS, function_ref<void(Error E)> ErrorHandler,
+                    unsigned Indent, DIDumpOptions DumpOpts) const {
   if (!isValid())
     return;
   DWARFDataExtractor debug_info_data = U->getDebugInfoExtractor();
   const uint64_t Offset = getOffset();
   uint64_t offset = Offset;
   if (DumpOpts.ShowParents) {
     DIDumpOptions ParentDumpOpts = DumpOpts;
     ParentDumpOpts.ShowParents = false;
     ParentDumpOpts.ShowChildren = false;
-    Indent = dumpParentChain(getParent(), OS, Indent, ParentDumpOpts);
+    Indent =
+        dumpParentChain(getParent(), OS, ErrorHandler, Indent, ParentDumpOpts);
   }
 
   if (debug_info_data.isValidOffset(offset)) {
     uint32_t abbrCode = debug_info_data.getULEB128(&offset);
     if (DumpOpts.ShowAddresses)
       WithColor(OS, HighlightColor::Address).get()
           << format("\n0x%8.8" PRIx64 ": ", Offset);
 
if (abbrCode) {
         for (const auto &AttrSpec : AbbrevDecl->attributes()) {
           if (AttrSpec.Form == DW_FORM_implicit_const) {
             // We are dumping .debug_info section ,
             // implicit_const attribute values are not really stored here,
             // but in .debug_abbrev section. So we just skip such attrs.
             continue;
           }
           dumpAttribute(OS, *this, &offset, AttrSpec.Attr, AttrSpec.Form,
-                        Indent, DumpOpts);
+                        Indent, DumpOpts, ErrorHandler);
         }
 
         DWARFDie child = getFirstChild();
         if (DumpOpts.ShowChildren && DumpOpts.ChildRecurseDepth > 0 && child) {
           DumpOpts.ChildRecurseDepth--;
           DIDumpOptions ChildDumpOpts = DumpOpts;
           ChildDumpOpts.ShowParents = false;
           while (child) {
-            child.dump(OS, Indent + 2, ChildDumpOpts);
+            child.dump(OS, ErrorHandler, Indent + 2, ChildDumpOpts);
             child = child.getSibling();
           }
         }
       } else {
         OS << "Abbreviation code not found in 'debug_abbrev' class for code: "
            << abbrCode << '\n';
       }
     } else {
       OS.indent(Indent) << "NULL\n";
     }
   }
 }
 
-LLVM_DUMP_METHOD void DWARFDie::dump() const { dump(llvm::errs(), 0); }
+static void defaultErrorHandler(Error E) {
+  WithColor::error() << toString(std::move(E)) << '\n';
+}
+
+LLVM_DUMP_METHOD void DWARFDie::dump() const {
+  dump(llvm::errs(), defaultErrorHandler, 0);
+}
 
 DWARFDie DWARFDie::getParent() const {
   if (isValid())
     return U->getParent(Die);
   return DWARFDie();
 }
 
 DWARFDie DWARFDie::getSibling() const {

llvm/lib/DebugInfo/DWARF/DWARFTypeUnit.cpp

 //===- DWARFTypeUnit.cpp --------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/DWARF/DWARFTypeUnit.h"
 #include "llvm/DebugInfo/DIContext.h"
+#include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h"
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cinttypes>
 
 using namespace llvm;
OS << " abbr_offset = "
      << " addr_size = " << format("0x%02x", getAddressByteSize())
      << " name = '" << Name << "'"
      << " type_signature = " << format("0x%016" PRIx64, getTypeHash())
      << " type_offset = " << format("0x%04" PRIx64, getTypeOffset())
      << " (next unit at " << format("0x%08" PRIx64, getNextUnitOffset())
      << ")\n";
 
   if (DWARFDie TU = getUnitDIE(false))
-    TU.dump(OS, 0, DumpOpts);
+    TU.dump(OS, getContext().getRecoverableErrorHandler(), 0, DumpOpts);
   else
     OS << "<type unit can't be parsed!>\n\n";
 }

llvm/lib/DebugInfo/DWARF/DWARFUnit.cpp

 #include "llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugRnglists.h"
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include "llvm/DebugInfo/DWARF/DWARFTypeUnit.h"
 #include "llvm/Support/DataExtractor.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Path.h"
-#include "llvm/Support/WithColor.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <cstdio>
 #include <utility>
 #include <vector>
 
if (const DWARFAbbreviationDeclaration *AbbrDecl =
       if (Depth == 0)
         break;  // We are done with this compile unit!
     }
   }
 
   // Give a little bit of info if we encounter corrupt DWARF (our offset
   // should always terminate at or before the start of the next compilation
   // unit header).
-  if (DIEOffset > NextCUOffset)
-    WithColor::warning() << format("DWARF compile unit extends beyond its "
-                                   "bounds cu 0x%8.8" PRIx64 " "
-                                   "at 0x%8.8" PRIx64 "\n",
-                                   getOffset(), DIEOffset);
+  if (DIEOffset > NextCUOffset) {
+    Context.getWarningHandler()(
+        createStringError(errc::invalid_argument,
+                          "DWARF compile unit extends beyond its "
+                          getOffset(), DIEOffset));
+  }
 }
 
 void DWARFUnit::extractDIEsIfNeeded(bool CUDieOnly) {
   if (Error e = tryExtractDIEsIfNeeded(CUDieOnly))
-    WithColor::error() << toString(std::move(e));
+    Context.getRecoverableErrorHandler()(std::move(e));
 }
 
 Error DWARFUnit::tryExtractDIEsIfNeeded(bool CUDieOnly) {
   if ((CUDieOnly && !DieArray.empty()) ||
       DieArray.size() > 1)
     return Error::success(); // Already parsed.
 
   bool HasCUDie = !DieArray.empty();
Error DWARFUnit::tryExtractDIEsIfNeeded(bool CUDieOnly) {
   // which may differ from the unit's format.
   DWARFDataExtractor DA(Context.getDWARFObj(), StringOffsetSection,
                         isLittleEndian, 0);
   if (IsDWO || getVersion() >= 5) {
     auto StringOffsetOrError =
         IsDWO ? determineStringOffsetsTableContributionDWO(DA)
               : determineStringOffsetsTableContribution(DA);
     if (!StringOffsetOrError)
-      return createStringError(errc::invalid_argument,
-                               "invalid reference to or invalid content in "
-                               ".debug_str_offsets[.dwo]: " +
-                                   toString(StringOffsetOrError.takeError()));
+      return createStringError(
+          errc::invalid_argument,
+          ".debug_str_offsets[.dwo]: %s",
+          toString(StringOffsetOrError.takeError()).c_str());
 
     StringOffsetsTableContribution = *StringOffsetOrError;
   }
 
   // DWARF v5 uses the .debug_rnglists and .debug_rnglists.dwo sections to
   // describe address ranges.
   if (getVersion() >= 5) {
     if (IsDWO)
       setRangesSection(&Context.getDWARFObj().getRnglistsDWOSection(), 0);
     else
       setRangesSection(&Context.getDWARFObj().getRnglistsSection(),
                        toSectionOffset(UnitDie.find(DW_AT_rnglists_base), 0));
     if (RangeSection->Data.size()) {
       // Parse the range list table header. Individual range lists are
       // extracted lazily.
       DWARFDataExtractor RangesDA(Context.getDWARFObj(), *RangeSection,
                                   isLittleEndian, 0);
       auto TableOrError = parseListTableHeader<DWARFDebugRnglistTable>(
           RangesDA, RangeSectionBase, Header.getFormat());
       if (!TableOrError)
         return createStringError(errc::invalid_argument,
-                                 "parsing a range list table: " +
-                                     toString(TableOrError.takeError()));
+                                 "parsing a range list table: %s",
+                                 toString(TableOrError.takeError()).c_str());
 
       RngListTable = TableOrError.get();
 
       // In a split dwarf unit, there is no DW_AT_rnglists_base attribute.
       // Adjust RangeSectionBase to point past the table header.
       if (IsDWO && RngListTable)
         RangeSectionBase = RngListTable->getHeaderSize();
     }
if (LocSection->Data.size()) {
       if (Offset < HeaderSize)
         return createStringError(errc::invalid_argument,
                                  "did not detect a valid"
                                  " list table with base = 0x%" PRIx64 "\n",
                                  Offset);
       Offset -= HeaderSize;
       if (Error E = LoclistTableHeader->extract(Data, &Offset))
         return createStringError(errc::invalid_argument,
-                                 "parsing a loclist table: " +
-                                     toString(std::move(E)));
+                                 "parsing a loclist table: %s",
+                                 toString(std::move(E)).c_str());
     }
   }
 
   // Don't fall back to DW_AT_GNU_ranges_base: it should be ignored for
   // skeleton CU DIE, so that DWARF users not aware of it are not broken.
   return Error::success();
 }
 
bool DWARFUnit::parseDWO() {
   if (getVersion() >= 5) {
     DWO->setRangesSection(&Context.getDWARFObj().getRnglistsDWOSection(), 0);
     DWARFDataExtractor RangesDA(Context.getDWARFObj(), *RangeSection,
                                 isLittleEndian, 0);
     if (auto TableOrError = parseListTableHeader<DWARFDebugRnglistTable>(
             RangesDA, RangeSectionBase, Header.getFormat()))
       DWO->RngListTable = TableOrError.get();
     else
-      WithColor::error() << "parsing a range list table: "
-                         << toString(TableOrError.takeError())
-                         << '\n';
+      Context.getRecoverableErrorHandler()(createStringError(
+          errc::invalid_argument, "parsing a range list table: %s",
+          toString(TableOrError.takeError()).c_str()));
     if (DWO->RngListTable)
       DWO->RangeSectionBase = DWO->RngListTable->getHeaderSize();
   } else {
     auto DWORangesBase = UnitDie.getRangesBaseAttribute();
     DWO->setRangesSection(RangeSection, DWORangesBase ? *DWORangesBase : 0);
   }
 
   return true;

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

 unsigned DWARFVerifier::verifyDebugInfoCallSite(const DWARFDie &Die) {
   if (Die.getTag() != DW_TAG_call_site && Die.getTag() != DW_TAG_GNU_call_site)
     return 0;
 
   DWARFDie Curr = Die.getParent();
   for (; Curr.isValid() && !Curr.isSubprogramDIE(); Curr = Die.getParent()) {
     if (Curr.getTag() == DW_TAG_inlined_subroutine) {
       error() << "Call site entry nested within inlined subroutine:";
-      Curr.dump(OS);
+      Curr.dump(OS, DCtx.getRecoverableErrorHandler());
       return 1;
     }
   }
 
   if (!Curr.isValid()) {
     error() << "Call site entry not nested within a valid subprogram:";
-    Die.dump(OS);
+    Die.dump(OS, DCtx.getRecoverableErrorHandler());
     return 1;
   }
 
   Optional<DWARFFormValue> CallAttr =
       Curr.find({DW_AT_call_all_calls, DW_AT_call_all_source_calls,
                  DW_AT_call_all_tail_calls, DW_AT_GNU_all_call_sites,
                  DW_AT_GNU_all_source_call_sites,
                  DW_AT_GNU_all_tail_call_sites});
   if (!CallAttr) {
     error() << "Subprogram with call site entry has no DW_AT_call attribute:";
-    Curr.dump(OS);
-    Die.dump(OS, /*indent*/ 1);
+    Curr.dump(OS, DCtx.getRecoverableErrorHandler());
+    Die.dump(OS, DCtx.getRecoverableErrorHandler(), /*indent*/ 1);
     return 1;
   }
 
   return 0;
 }
 
 unsigned DWARFVerifier::verifyAbbrevSection(const DWARFDebugAbbrev *Abbrev) {
   unsigned NumErrors = 0;
if (RefVal) {
       auto CUSize = DieCU->getNextUnitOffset() - DieCU->getOffset();
       auto CUOffset = AttrValue.Value.getRawUValue();
       if (CUOffset >= CUSize) {
         ++NumErrors;
         error() << FormEncodingString(Form) << " CU offset "
                 << format("0x%08" PRIx64, CUOffset)
                 << " is invalid (must be less than CU size of "
                 << format("0x%08" PRIx64, CUSize) << "):\n";
-        Die.dump(OS, 0, DumpOpts);
+        Die.dump(OS, DCtx.getRecoverableErrorHandler(), 0, DumpOpts);
         dump(Die) << '\n';
       } else {
         // Valid reference, but we will verify it points to an actual
         // DIE later.
         ReferenceToDIEOffsets[*RefVal].insert(Die.getOffset());
       }
     }
     break;

 
 raw_ostream &DWARFVerifier::error() const { return WithColor::error(OS); }
 
 raw_ostream &DWARFVerifier::warn() const { return WithColor::warning(OS); }
 
 raw_ostream &DWARFVerifier::note() const { return WithColor::note(OS); }
 
 raw_ostream &DWARFVerifier::dump(const DWARFDie &Die, unsigned indent) const {
-  Die.dump(OS, indent, DumpOpts);
+  Die.dump(OS, DCtx.getRecoverableErrorHandler(), indent, DumpOpts);
   return OS;
 }

llvm/tools/dsymutil/DwarfLinkerForBinary.cpp

void DwarfLinkerForBinary::reportWarning(const Twine &Warning,
 
   if (!Options.Verbose || !DIE)
     return;
 
   DIDumpOptions DumpOpts;
   DumpOpts.ChildRecurseDepth = 0;
   DumpOpts.Verbose = Options.Verbose;
 
+  std::function<void(Error)> ErrorHandler = [](Error E) {
+    WithColor::error() << toString(std::move(E)) << '\n';
+  };
+
   WithColor::note() << "    in DIE:\n";
-  DIE->dump(errs(), 6 /* Indent */, DumpOpts);
+  DIE->dump(errs(), ErrorHandler, 6 /* Indent */, DumpOpts);
 }
 
 bool DwarfLinkerForBinary::createStreamer(const Triple &TheTriple,
                                           raw_fd_ostream &OutFile) {
   if (Options.NoOutput)
     return true;
 
   Streamer = std::make_unique<DwarfStreamer>(OutFile, Options);

llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp

static bool filterArch(ObjectFile &Obj) {
   return false;
 }
 
 using HandlerFn = std::function<bool(ObjectFile &, DWARFContext &DICtx, Twine,
                                      raw_ostream &)>;
 
 /// Print only DIEs that have a certain name.
 static bool filterByName(const StringSet<> &Names, DWARFDie Die,
-                         StringRef NameRef, raw_ostream &OS) {
+                         StringRef NameRef, raw_ostream &OS,
+                         function_ref<void(Error)> ErrorHandler) {
   std::string Name =
       (IgnoreCase && !UseRegex) ? NameRef.lower() : NameRef.str();
   if (UseRegex) {
     // Match regular expression.
     for (auto Pattern : Names.keys()) {
       Regex RE(Pattern, IgnoreCase ? Regex::IgnoreCase : Regex::NoFlags);
       std::string Error;
       if (!RE.isValid(Error)) {
         errs() << "error in regular expression: " << Error << "\n";
         exit(1);
       }
       if (RE.match(Name)) {
-        Die.dump(OS, 0, getDumpOpts());
+        Die.dump(OS, ErrorHandler, 0, getDumpOpts());
         return true;
       }
     }
   } else if (Names.count(Name)) {
     // Match full text.
-    Die.dump(OS, 0, getDumpOpts());
+    Die.dump(OS, ErrorHandler, 0, getDumpOpts());
     return true;
   }
   return false;
 }
 
 /// Print only DIEs that have a certain name.
 static void filterByName(const StringSet<> &Names,
-                         DWARFContext::unit_iterator_range CUs,
-                         raw_ostream &OS) {
+                         DWARFContext::unit_iterator_range CUs, raw_ostream &OS,
+                         function_ref<void(Error)> ErrorHandler) {
   for (const auto &CU : CUs)
     for (const auto &Entry : CU->dies()) {
       DWARFDie Die = {CU.get(), &Entry};
       if (const char *Name = Die.getName(DINameKind::ShortName))
-        if (filterByName(Names, Die, Name, OS))
+        if (filterByName(Names, Die, Name, OS, ErrorHandler))
           continue;
       if (const char *Name = Die.getName(DINameKind::LinkageName))
-        filterByName(Names, Die, Name, OS);
+        filterByName(Names, Die, Name, OS, ErrorHandler);
     }
 }
 
 static void getDies(DWARFContext &DICtx, const AppleAcceleratorTable &Accel,
                     StringRef Name, SmallVectorImpl<DWARFDie> &Dies) {
   for (const auto &Entry : Accel.equal_range(Name)) {
     if (llvm::Optional<uint64_t> Off = Entry.getDIESectionOffset()) {
       if (DWARFDie Die = DICtx.getDIEForOffset(*Off))
for (const auto &Name : Names) {
     getDies(DICtx, DICtx.getAppleTypes(), Name, Dies);
     getDies(DICtx, DICtx.getAppleNamespaces(), Name, Dies);
     getDies(DICtx, DICtx.getDebugNames(), Name, Dies);
   }
   llvm::sort(Dies);
   Dies.erase(std::unique(Dies.begin(), Dies.end()), Dies.end());
 
   for (DWARFDie Die : Dies)
-    Die.dump(OS, 0, getDumpOpts());
+    Die.dump(OS, DICtx.getRecoverableErrorHandler(), 0, getDumpOpts());
 }
 
 /// Handle the --lookup option and dump the DIEs and line info for the given
 /// address.
 /// TODO: specified Address for --lookup option could relate for several
 /// different sections(in case not-linked object file). llvm-dwarfdump
 /// need to do something with this: extend lookup option with section
 /// information or probably display all matched entries, or something else...
 static bool lookup(ObjectFile &Obj, DWARFContext &DICtx, uint64_t Address,
                    raw_ostream &OS) {
   auto DIEsForAddr = DICtx.getDIEsForAddress(Lookup);
 
   if (!DIEsForAddr)
     return false;
 
   DIDumpOptions DumpOpts = getDumpOpts();
   DumpOpts.ChildRecurseDepth = 0;
   DIEsForAddr.CompileUnit->dump(OS, DumpOpts);
   if (DIEsForAddr.FunctionDIE) {
-    DIEsForAddr.FunctionDIE.dump(OS, 2, DumpOpts);
+    DIEsForAddr.FunctionDIE.dump(OS, DICtx.getRecoverableErrorHandler(), 2,
+                                 DumpOpts);
     if (DIEsForAddr.BlockDIE)
-      DIEsForAddr.BlockDIE.dump(OS, 4, DumpOpts);
+      DIEsForAddr.BlockDIE.dump(OS, DICtx.getRecoverableErrorHandler(), 4,
+                                DumpOpts);
   }
 
   // TODO: it is neccessary to set proper SectionIndex here.
   // object::SectionedAddress::UndefSection works for only absolute addresses.
   if (DILineInfo LineInfo = DICtx.getLineInfoForAddress(
           {Lookup, object::SectionedAddress::UndefSection}))
     LineInfo.dump(OS);
 
if (Lookup)
     return lookup(Obj, DICtx, Lookup, OS);
 
   // Handle the --name option.
   if (!Name.empty()) {
     StringSet<> Names;
     for (auto name : Name)
       Names.insert((IgnoreCase && !UseRegex) ? StringRef(name).lower() : name);
 
-    filterByName(Names, DICtx.normal_units(), OS);
-    filterByName(Names, DICtx.dwo_units(), OS);
+    filterByName(Names, DICtx.normal_units(), OS,
+                 DICtx.getRecoverableErrorHandler());
+    filterByName(Names, DICtx.dwo_units(), OS,
+                 DICtx.getRecoverableErrorHandler());
     return true;
   }
 
   // Handle the --find option and lower it to --debug-info=<offset>.
   if (!Find.empty()) {
     filterByAccelName(Find, DICtx, OS);
     return true;
   }