[llvm-objcopy][NFC] refactor error handling. part 3.

[avl]

Summary

Remove usages of special error reporting functions(error(),
reportError()). Errors are reported as Expected<>/Error returning
values. This part is for ELF subfolder of llvm-objcopy.

[avl]

fixed several minor mistakes.

[jhenderson]

Do we actually have any non-fatal errors in llvm-objcopy etc currently? If not, I think a better approach would be to simply bubble up the errors via Expected and Error usage, and handle the failures in the client code directly. The client code could then choose to either report them as errors (or warnings) and/or abort what it was doing. I imagine in the case of dwarfutil, you'd be best off aborting optimizing a given CU's debug data if it looked dodgy somehow, in which case, you don't need to distinguish between different classes of errors. This is the approach we take in our downstream port for our debug line rewriting that we've implemented.

[avl]

Do we actually have any non-fatal errors in llvm-objcopy etc currently?

yes. there are some. f.e. CopyConfig.cpp::parseObjcopyOptions uses ErrorCallback to decide whether the error would be fatal or non-fatal.
I can leave this callback for places where it is already used and convert interfaces into Expected and Error usage in other places.

If not, I think a better approach would be to simply bubble up the errors via Expected and Error usage, and handle the failures in the client code directly.

Ok. Currently the error is reported inplace and the program just dies(exit(1)). To change this behavior it would be necessary to update many interfaces(f.e. writeSectionData()->SectionBase::accept()->SectionVisitor::visitor()).
Will do that.

[avl]

addressed comments(reworked to use Expected and Error as returning values).

[jhenderson]

Before you go too much further with this, I'd like some comments from others on the approach. The fact that this code is far more extensive and has far more error paths suggests to me that we might be on the wrong approach here, and perhaps we should actually be using the error handler callback approach after all. @grimar/@rupprecht/@MaskRay - any thoughts?

If we had an error handler callback, we'd probably want it added to the objcopy config class, to avoid having to pass the callbacks themselves everywhere (only as far as the point where the config is created).

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

330

I'd find it more readable now that this is a non-trivial for loop, if it were to have braces.monospaced text

llvm/tools/llvm-objcopy/ELF/Object.cpp

55

Unrelated clang-formatting?

517–526

This isn't the way to report the error back. The message will have lost fidelity. You should probably change this to use the fallible constructor idiom - see https://llvm.org/docs/ProgrammersManual.html#fallible-constructors. That way, the error can be propagated back to the caller in the way it always was.

604–605

See https://llvm.org/docs/CodingStandards.html#don-t-use-braces-on-simple-single-statement-bodies-of-if-else-loop-statements: "readability is also harmed if an if/else chain does not use braced bodies for either all or none of its members".

But actually, this is one of several examples in this patch where you'd be better off doing something like this:

Expected<SymbolTableSection *> Sec = SecTable.getSectionOfType<SymbolTableSection>(
              Link,
              "Link field value " + Twine(Link) + " in section " + Name +
                  " is invalid",
              "Link field value " + Twine(Link) + " in section " + Name +
                  " is not a symbol table"));
if (!Sec)
  return Sec.takeError();

setSymTab(*Sec);
Symbols->setShndxTable(this);
return Error::success();

In this case, your code for what to do in the "good" case is kept all next to each other, rather than partially split between the if body and the post if/else bit.

743–744

Same as above.

1047–1052

Same as above.

1320

I'd avoid the auto here. It's not clear to me what sort of thing program_headers returns (in this case an Expected).

1411–1417

Same as above. This is also different to the style used elsewhere in this function.

1502–1505

Avoid unnecessary else.

1590

Don't use auto. The type isn't obvious.

1594

As you are changing this line, I'd get rid of this auto too. Same goes elsewhere.

1664–1665

Here and throughout this function, don't use auto if the type isn't obvious from the RHS, unless it's an iterator.

llvm/tools/llvm-objcopy/ELF/Object.h

129–130

No need to specify virtual when a function is marked as override.

llvm/tools/llvm-objcopy/llvm-objcopy.cpp

59–60

This might be an indication that you should use an error handler after all. You don't really want your library code printing warnings directly itself.

[avl]

llvm/tools/llvm-objcopy/ELF/Object.h

129–130

I mark them as virtual so that they look the same as following definitions - will remove them.

llvm/tools/llvm-objcopy/llvm-objcopy.cpp

59–60

This reportWarning() function is exactly implementation(used by only llvm-objcopy.cpp) of the error handler. It is not seen by other parts of llvm-objcopy. It is passed as "llvm::function_ref<Error(Error)> ErrorCallback" to other parts. Thus, It could/should not be used by library.

[jhenderson]

llvm/tools/llvm-objcopy/ELF/Object.h

129–130

Thanks - the key is that they AREN'T the same so we should be highlighting this by making them look different!

llvm/tools/llvm-objcopy/llvm-objcopy.cpp

59–60

Okay, thanks. That's good to know.

[avl]

addressed comments.

[grimar]

In D87987#2297596, @jhenderson wrote:

Before you go too much further with this, I'd like some comments from others on the approach. The fact that this code is far more extensive and has far more error paths suggests to me that we might be on the wrong approach here, and perhaps we should actually be using the error handler callback approach after all. @grimar/@rupprecht/@MaskRay - any thoughts?

I have 2 general comments/thoughts atm:

1. I've noticed that the code tries to address 2 a bit different situations currently:
   1. Cases that fix the unwrapOrError: like unwrapOrError(HeadersFile.program_headers()) which seems are trying to fix places related to broken inputs which were never tested before I think.
   2. Cases that are tested and report errors, like: error("program header with offset 0x" + Twine::utohexstr(Phdr.p_offset) + .....
      
      I think for start we should probably focus on (B) and probably can keep unwrapOrError untouched until we convert them and add tests.

2. Regarding the error handler callback suggested. I am thinking about something that is implemented in LLD. I.e. a error state is remembered and a error is reported via callback. Then we are trying to stop execution and exit at a convenient place. @jhenderson, did you mean something like this?

[jhenderson]

In D87987#2299935, @grimar wrote:

In D87987#2297596, @jhenderson wrote:

Before you go too much further with this, I'd like some comments from others on the approach. The fact that this code is far more extensive and has far more error paths suggests to me that we might be on the wrong approach here, and perhaps we should actually be using the error handler callback approach after all. @grimar/@rupprecht/@MaskRay - any thoughts?

2. Regarding the error handler callback suggested. I am thinking about something that is implemented in LLD. I.e. a error state is remembered and a error is reported via callback. Then we are trying to stop execution and exit at a convenient place. @jhenderson, did you mean something like this?

I was actually referring more to the style that this patch series initially looked at, which is based on something similar to what I did in the DebugLine parser, which in turn inspired my lightning talk on error handling in libraries three(?) years ago. In other words, the client would provide one or more callbacks for different degrees of severity of problems, which llvm-objcopy's code could then call when an error occurred.

I'm not convinced there are many points in the llvm-objcopy code where continuing after failure makes much sense, personally, so just storing an error state for reporting later seems unnecessary?

[jhenderson]

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

318–319

I would either replace both these names or neither of them, since these are the variable names already. I think we want to avoid an inconsistent style between shouldReplace and AddSection.

[avl]

I was actually referring more to the style that this patch series initially looked at, which is based on something similar to what I did in the DebugLine parser, which in turn inspired my lightning talk on error handling in libraries three(?) years ago. In other words, the client would provide one or more callbacks for different degrees of severity of problems, which llvm-objcopy's code could then call when an error occurred.

I'm not convinced there are many points in the llvm-objcopy code where continuing after failure makes much sense, personally, so just storing an error state for reporting later seems unnecessary?

Right, that patch initially was done in that manner - the client provide one or more callbacks for different degrees of severity of problems. The argument against such a solution was that there are only fatal_errors currently, which could be reported using Expected<>/Error returning values. It looks to me that It is OK to use that(Expected<>/Error) solution until we need to report other errors(warning/recoverable error). i.e. Let`s create handlers when we would need to report other kinds of errors.

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

318–319

My own preference is that it is OK to fix small style issues if they were encountered during making some patch. But it is often rejected with the reason - "It should be separate patch". Thus I am trying to change only lines affected by patch. In this concrete case clang-tidy reported style issue - So I fixed it. If it is OK - I would change shouldReplace also.

[jhenderson]

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

318–319

I think it's okay to ignore clang-tidy issues where you aren't modifying the specific bit it's complaining about. However, it's probably just better to fix the style issue for both function_ref instances in a separate patch, thinking about it.

What I don't think is okay is to have inconsistent style (I don't mind if it is a precursor patch to fix the style, or just ignoring the clang-tidy warning here).

[avl]

So, what about current solution in this patch to report fatal errors through Expected<>/Error in llvm-objcopy? Is it OK to do things that way? My understanding is that currently only fatal errors are reported and then no need to create handlers at the moment.

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

318–319

OK, I will return AddSection back and fix the style issue in a separate commit.

[jhenderson]

In D87987#2302840, @avl wrote:

So, what about current solution in this patch to report fatal errors through Expected<>/Error in llvm-objcopy? Is it OK to do things that way? My understanding is that currently only fatal errors are reported and then no need to create handlers at the moment.

I'm waiting on others feedback to see what they think. The advantage of the handler is that it would allow us to simplify the error handling a little probably (less of a need to repeatedly check for error/takeError patterns etc). The downside is the need for the handler, and the fact that there'd need to be some way of bailing out once an error is hit (the handler could be noreturn or something like that, I suppose).

[avl]

and the fact that there'd need to be some way of bailing out once an error is hit (the handler could be noreturn or something like that, I suppose).

yes, and that way(bailing out once an error is hit) could be not flexible enough. The Expected<>/Error solution allows to handle errors at any level, while handler would need to create some agreement on that. f.e. current agreement(before this patch) is that the program just dies with exit(1) at the point where error is occured. From that point of view, Expected<>/Error solution looks more flexible: it could be caught at some level and the execution continiues(kind of recoverable error).

[rupprecht]

I'm really happy to see this. I tried removing the error() methods from llvm-objcopy.h a year or two ago and didn't have the patience to work through all the plumbing seen here.

This approach LGTM to me. I just have a couple nits.

llvm/tools/llvm-objcopy/ELF/Object.cpp

524–531

Once we detect an error, we probably don't want to go on and process the rest of this function, e.g. use of CompressedData may not be valid.

You can't return early from the constructor IIUC, but maybe something like:

if (Error Err = zlib::compress(...)) {
  OutErr = ...
} { else {
  // Rest of constructor
}

529–537

Nothing's happening to this variable, so I think return CompressedSection(...) looks better here

1587

Is this actually necessary? I think the above switch statement handles all cases (including a default case), and if any of the types break instead of returning, you should get a -Wreturn error trying to build this.

1696–1699

nit: this pattern can be reduced:

if (Error E = foo()) return E;
return Error::success();

->

return foo();

[jhenderson]

llvm/tools/llvm-objcopy/ELF/Object.cpp

524–531

+1 to bailing out early here. You can use a return; (no value) in a constructor. See https://stackoverflow.com/questions/5255777/what-if-i-write-return-statement-in-constructor.

[avl]

addressed comments.

[avl]

fixed a small typo.

[jhenderson]

LGTM, but please wait for others.

[avl]

@grimar

I've noticed that the code tries to address 2 a bit different situations currently:

Cases that fix the unwrapOrError: like unwrapOrError(HeadersFile.program_headers()) which seems are trying to fix places related to >broken inputs which were never tested before I think.
Cases that are tested and report errors, like: error("program header with offset 0x" + Twine::utohexstr(Phdr.p_offset) + .....

I think for start we should probably focus on (B) and probably can keep unwrapOrError untouched until we convert them and add tests.

Probably, we could leave unwrapOrError expanded by this patch?
This patch does not change the logic existed with unwrapOrError.
It just removes the function and put the code inplace.
Before this patch:

for (const auto &Phdr : unwrapOrError(HeadersFile.program_headers()))

after this patch:

Expected<typename ELFFile<ELFT>::Elf_Phdr_Range> Headers =
    HeadersFile.program_headers();
if (!Headers)
  return Headers.takeError();

for (const typename ELFFile<ELFT>::Elf_Phdr &Phdr : *Headers)

The unwrapOrError was defined as :

template <class T> T unwrapOrError(Expected<T> EO) {
  if (EO)
    return *EO;
  std::string Buf;
  raw_string_ostream OS(Buf);
  logAllUnhandledErrors(EO.takeError(), OS);
  OS.flush();
  error(Buf);
}

i.e. it either continues execution, either report the error and die.
After unwrapOrError() is expanded the behavior is not changed: it either
continues execution, either report Error which is handled in llvm-objcopy.cpp and stop.

WDYT, Would it be OK to remove unwrapOrError() by this patch?

[rupprecht]

LGTM, thanks again!

[grimar]

In D87987#2305883, @avl wrote:

@grimar
....
WDYT, Would it be OK to remove unwrapOrError() by this patch?

Sorry, I've not noticed this question yesterday. It is probably fine.

llvm/tools/llvm-objcopy/COFF/COFFObjcopy.cpp

 static uint64_t getNextRVA(const Object &Obj) {
   if (Obj.getSections().empty())
     return 0;
   const Section &Last = Obj.getSections().back();
   return alignTo(Last.Header.VirtualAddress + Last.Header.VirtualSize,
                  Obj.IsPE ? Obj.PeHeader.SectionAlignment : 1);
 }
 
-static std::vector<uint8_t> createGnuDebugLinkSectionContents(StringRef File) {
+static std::vector<uint8_t>
+createGnuDebugLinkSectionContents(StringRef File,
+                                  const ErrorReporter &Reporter) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> LinkTargetOrErr =
       MemoryBuffer::getFile(File);
   if (!LinkTargetOrErr)
-    error("'" + File + "': " + LinkTargetOrErr.getError().message());
+    Reporter.fatalError(errc::invalid_argument,
+                        LinkTargetOrErr.getError().message(), File);
   auto LinkTarget = std::move(*LinkTargetOrErr);
   uint32_t CRC32 = llvm::crc32(arrayRefFromStringRef(LinkTarget->getBuffer()));
 
   StringRef FileName = sys::path::filename(File);
   size_t CRCPos = alignTo(FileName.size() + 1, 4);
   std::vector<uint8_t> Data(CRCPos + 4);
   memcpy(Data.data(), FileName.data(), FileName.size());
   support::endian::write32le(Data.data() + CRCPos, CRC32);
static void addSection(Object &Obj, StringRef Name, ArrayRef<uint8_t> Contents,
   Sec.Header.PointerToLinenumbers = 0;
   // Sec.Header.NumberOfRelocations is filled in by the writer.
   Sec.Header.NumberOfLinenumbers = 0;
   Sec.Header.Characteristics = Characteristics;
 
   Obj.addSections(Sec);
 }
 
-static void addGnuDebugLink(Object &Obj, StringRef DebugLinkFile) {
+static void addGnuDebugLink(Object &Obj, StringRef DebugLinkFile,
+                            const ErrorReporter &Reporter) {
   std::vector<uint8_t> Contents =
-      createGnuDebugLinkSectionContents(DebugLinkFile);
+      createGnuDebugLinkSectionContents(DebugLinkFile, Reporter);
   addSection(Obj, ".gnu_debuglink", Contents,
              IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ |
                  IMAGE_SCN_MEM_DISCARDABLE);
 }
 
 static void setSectionFlags(Section &Sec, SectionFlag AllFlags) {
   // Need to preserve alignment flags.
   const uint32_t PreserveMask =
Obj.removeSymbols([&](const Symbol &Sym) {
     // For StripAll, all relocations have been stripped and we remove all
     // symbols.
     if (Config.StripAll || Config.StripAllGNU)
       return true;
 
     if (Config.SymbolsToRemove.matches(Sym.Name)) {
       // Explicitly removing a referenced symbol is an error.
       if (Sym.Referenced)
-        reportError(Config.OutputFilename,
-                    createStringError(llvm::errc::invalid_argument,
-                                      "not stripping symbol '%s' because it is "
-                                      "named in a relocation",
-                                      Sym.Name.str().c_str()));
+        Config.Reporter.get().fatalError(
+                              Sym.Name.str().c_str()),
+            Config.OutputFilename);
       return true;
     }
 
     if (!Sym.Referenced) {
       // With --strip-unneeded, GNU objcopy removes all unreferenced local
       // symbols, and any unreferenced undefined external.
       // With --strip-unneeded-symbol we strip only specific unreferenced
       // local symbol instead of removing all of such.
for (const auto &Flag : Config.AddSection) {
     addSection(
         Obj, SecName,
         makeArrayRef(reinterpret_cast<const uint8_t *>(Buf->getBufferStart()),
                      Buf->getBufferSize()),
         IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_ALIGN_1BYTES);
   }
 
   if (!Config.AddGnuDebugLink.empty())
-    addGnuDebugLink(Obj, Config.AddGnuDebugLink);
+    addGnuDebugLink(Obj, Config.AddGnuDebugLink, Config.Reporter);
 
   if (Config.AllowBrokenLinks || !Config.BuildIdLinkDir.empty() ||
       Config.BuildIdLinkInput || Config.BuildIdLinkOutput ||
       !Config.SplitDWO.empty() || !Config.SymbolsPrefix.empty() ||
       !Config.AllocSectionsPrefix.empty() || !Config.DumpSection.empty() ||
       !Config.KeepSection.empty() || Config.NewSymbolVisibility ||
       !Config.SymbolsToGlobalize.empty() || !Config.SymbolsToKeep.empty() ||
       !Config.SymbolsToLocalize.empty() || !Config.SymbolsToWeaken.empty() ||

llvm/tools/llvm-objcopy/CopyConfig.h

 //===- CopyConfig.h -------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_OBJCOPY_COPY_CONFIG_H
 #define LLVM_TOOLS_LLVM_OBJCOPY_COPY_CONFIG_H
 
 #include "ELF/ELFConfig.h"
+#include "Error.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/BitmaskEnum.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Object/ELFTypes.h"
public:
   bool matches(StringRef S) const {
     return is_contained(PosMatchers, S) && !is_contained(NegMatchers, S);
   }
   bool empty() const { return PosMatchers.empty() && NegMatchers.empty(); }
 };
 
 // Configuration for copying/stripping a single file.
 struct CopyConfig {
+  CopyConfig(const ErrorReporter &Reporter) : Reporter(Reporter) {}
+
   // Format-specific options to be initialized lazily when needed.
   Optional<elf::ELFCopyConfig> ELF;
 
   // Main input/output options
   StringRef InputFilename;
   FileFormat InputFormat = FileFormat::Unspecified;
   StringRef OutputFilename;
   FileFormat OutputFormat = FileFormat::Unspecified;
struct CopyConfig {
   bool StripNonAlloc = false;
   bool StripSections = false;
   bool StripSwiftSymbols = false;
   bool StripUnneeded = false;
   bool Weaken = false;
   bool DecompressDebugSections = false;
   DebugCompressionType CompressionType = DebugCompressionType::None;
 
+  std::reference_wrapper<const ErrorReporter> Reporter;
+
   // parseELFConfig performs ELF-specific command-line parsing. Fills `ELF` on
   // success or returns an Error otherwise.
   Error parseELFConfig() {
     if (!ELF) {
       Expected<elf::ELFCopyConfig> ELFConfig = elf::parseConfig(*this);
       if (!ELFConfig)
         return ELFConfig.takeError();
       ELF = *ELFConfig;
     }
     return Error::success();
   }
 };
 
 // Configuration for the overall invocation of this tool. When invoked as
 // objcopy, will always contain exactly one CopyConfig. When invoked as strip,
 // will contain one or more CopyConfigs.
 struct DriverConfig {
   SmallVector<CopyConfig, 1> CopyConfigs;
   BumpPtrAllocator Alloc;
 };
 
 // ParseObjcopyOptions returns the config and sets the input arguments. If a
 // help flag is set then ParseObjcopyOptions will print the help messege and
-// exit. ErrorCallback is used to handle recoverable errors. An Error returned
-// by the callback aborts the parsing and is then returned by this function.
-Expected<DriverConfig>
-parseObjcopyOptions(ArrayRef<const char *> ArgsArr,
-                    llvm::function_ref<Error(Error)> ErrorCallback);
+// exit. ErrorReporter is used to report errors.
+Expected<DriverConfig> parseObjcopyOptions(ArrayRef<const char *> ArgsArr,
+                                           const ErrorReporter &Reporter);
 
 // ParseInstallNameToolOptions returns the config and sets the input arguments.
 // If a help flag is set then ParseInstallNameToolOptions will print the help
-// messege and exit.
+// messege and exit. ErrorReporter is used to report errors.
 Expected<DriverConfig>
-parseInstallNameToolOptions(ArrayRef<const char *> ArgsArr);
+parseInstallNameToolOptions(ArrayRef<const char *> ArgsArr,
+                            const ErrorReporter &Reporter);
 
 // ParseBitcodeStripOptions returns the config and sets the input arguments.
 // If a help flag is set then ParseBitcodeStripOptions will print the help
-// messege and exit.
-Expected<DriverConfig> parseBitcodeStripOptions(ArrayRef<const char *> ArgsArr);
+// messege and exit. ErrorReporter is used to report errors.
+Expected<DriverConfig> parseBitcodeStripOptions(ArrayRef<const char *> ArgsArr,
+                                                const ErrorReporter &Reporter);
 
 // ParseStripOptions returns the config and sets the input arguments. If a
 // help flag is set then ParseStripOptions will print the help messege and
-// exit. ErrorCallback is used to handle recoverable errors. An Error returned
-// by the callback aborts the parsing and is then returned by this function.
-Expected<DriverConfig>
-parseStripOptions(ArrayRef<const char *> ArgsArr,
-                  llvm::function_ref<Error(Error)> ErrorCallback);
+// exit. ErrorReporter is used to handle errors.
+Expected<DriverConfig> parseStripOptions(ArrayRef<const char *> ArgsArr,
+                                         const ErrorReporter &Reporter);
 } // namespace objcopy
 } // namespace llvm
 
 #endif

llvm/tools/llvm-objcopy/CopyConfig.cpp

static void printHelp(const opt::OptTable &OptTable, raw_ostream &OS,
   // The CommandLine library has a cl::extrahelp class to support this,
   // but libOption does not have that yet.
   OS << "\nPass @FILE as argument to read options from FILE.\n";
 }
 
 // ParseObjcopyOptions returns the config and sets the input arguments. If a
 // help flag is set then ParseObjcopyOptions will print the help messege and
 // exit.
-Expected<DriverConfig>
-parseObjcopyOptions(ArrayRef<const char *> ArgsArr,
-                    llvm::function_ref<Error(Error)> ErrorCallback) {
+Expected<DriverConfig> parseObjcopyOptions(ArrayRef<const char *> ArgsArr,
+                                           const ErrorReporter &Reporter) {
   DriverConfig DC;
   ObjcopyOptTable T;
   unsigned MissingArgumentIndex, MissingArgumentCount;
   llvm::opt::InputArgList InputArgs =
       T.ParseArgs(ArgsArr, MissingArgumentIndex, MissingArgumentCount);
 
   if (InputArgs.size() == 0) {
     printHelp(T, errs(), ToolType::Objcopy);
Expected<DriverConfig> parseObjcopyOptions(ArrayRef<const char *> ArgsArr,
 
   if (Positional.empty())
     return createStringError(errc::invalid_argument, "no input file specified");
 
   if (Positional.size() > 2)
     return createStringError(errc::invalid_argument,
                              "too many positional arguments");
 
-  CopyConfig Config;
+  CopyConfig Config(Reporter);
   Config.InputFilename = Positional[0];
   Config.OutputFilename = Positional[Positional.size() == 1 ? 0 : 1];
   if (InputArgs.hasArg(OBJCOPY_target) &&
       (InputArgs.hasArg(OBJCOPY_input_target) ||
        InputArgs.hasArg(OBJCOPY_output_target)))
     return createStringError(
         errc::invalid_argument,
         "--target cannot be used with --input-target or --output-target");
for (const auto &E : Config.SectionsToRename) {
     if (Config.SetSectionFlags.count(SR.NewName))
       return createStringError(
           errc::invalid_argument,
           "--set-section-flags=%s conflicts with --rename-section=%s=%s",
           SR.NewName.str().c_str(), SR.OriginalName.str().c_str(),
           SR.NewName.str().c_str());
   }
 
+  std::function<Error(Error)> ErrorCallback = [&Reporter](Error Err) {
+    Reporter.warning(std::move(Err));
+    return Error::success();
+  };
   for (auto Arg : InputArgs.filtered(OBJCOPY_remove_section))
     if (Error E = Config.ToRemove.addMatcher(NameOrPattern::create(
             Arg->getValue(), SectionMatchStyle, ErrorCallback)))
       return std::move(E);
   for (auto Arg : InputArgs.filtered(OBJCOPY_keep_section))
     if (Error E = Config.KeepSection.addMatcher(NameOrPattern::create(
             Arg->getValue(), SectionMatchStyle, ErrorCallback)))
       return std::move(E);
Expected<DriverConfig> parseObjcopyOptions(ArrayRef<const char *> ArgsArr,
   DC.CopyConfigs.push_back(std::move(Config));
   return std::move(DC);
 }
 
 // ParseInstallNameToolOptions returns the config and sets the input arguments.
 // If a help flag is set then ParseInstallNameToolOptions will print the help
 // messege and exit.
 Expected<DriverConfig>
-parseInstallNameToolOptions(ArrayRef<const char *> ArgsArr) {
+parseInstallNameToolOptions(ArrayRef<const char *> ArgsArr,
+                            const ErrorReporter &Reporter) {
   DriverConfig DC;
-  CopyConfig Config;
+  CopyConfig Config(Reporter);
   InstallNameToolOptTable T;
   unsigned MissingArgumentIndex, MissingArgumentCount;
   llvm::opt::InputArgList InputArgs =
       T.ParseArgs(ArgsArr, MissingArgumentIndex, MissingArgumentCount);
 
   if (MissingArgumentCount)
     return createStringError(
         errc::invalid_argument,
return createStringError(
         "llvm-install-name-tool expects a single input file");
   Config.InputFilename = Positional[0];
   Config.OutputFilename = Positional[0];
 
   DC.CopyConfigs.push_back(std::move(Config));
   return std::move(DC);
 }
 
-Expected<DriverConfig>
-parseBitcodeStripOptions(ArrayRef<const char *> ArgsArr) {
+Expected<DriverConfig> parseBitcodeStripOptions(ArrayRef<const char *> ArgsArr,
+                                                const ErrorReporter &Reporter) {
   DriverConfig DC;
-  CopyConfig Config;
+  CopyConfig Config(Reporter);
   BitcodeStripOptTable T;
   unsigned MissingArgumentIndex, MissingArgumentCount;
   opt::InputArgList InputArgs =
       T.ParseArgs(ArgsArr, MissingArgumentIndex, MissingArgumentCount);
 
   if (InputArgs.size() == 0) {
     printHelp(T, errs(), ToolType::BitcodeStrip);
     exit(1);
Expected<DriverConfig> parseBitcodeStripOptions(ArrayRef<const char *> ArgsArr,
 
   DC.CopyConfigs.push_back(std::move(Config));
   return std::move(DC);
 }
 
 // ParseStripOptions returns the config and sets the input arguments. If a
 // help flag is set then ParseStripOptions will print the help messege and
 // exit.
-Expected<DriverConfig>
-parseStripOptions(ArrayRef<const char *> ArgsArr,
-                  llvm::function_ref<Error(Error)> ErrorCallback) {
+Expected<DriverConfig> parseStripOptions(ArrayRef<const char *> ArgsArr,
+                                         const ErrorReporter &Reporter) {
   StripOptTable T;
   unsigned MissingArgumentIndex, MissingArgumentCount;
   llvm::opt::InputArgList InputArgs =
       T.ParseArgs(ArgsArr, MissingArgumentIndex, MissingArgumentCount);
 
   if (InputArgs.size() == 0) {
     printHelp(T, errs(), ToolType::Strip);
     exit(1);
Expected<DriverConfig> parseStripOptions(ArrayRef<const char *> ArgsArr,
   if (Positional.empty())
     return createStringError(errc::invalid_argument, "no input file specified");
 
   if (Positional.size() > 1 && InputArgs.hasArg(STRIP_output))
     return createStringError(
         errc::invalid_argument,
         "multiple input files cannot be used in combination with -o");
 
-  CopyConfig Config;
+  CopyConfig Config(Reporter);
 
   if (InputArgs.hasArg(STRIP_regex) && InputArgs.hasArg(STRIP_wildcard))
     return createStringError(errc::invalid_argument,
                              "--regex and --wildcard are incompatible");
   MatchStyle SectionMatchStyle =
       InputArgs.hasArg(STRIP_regex) ? MatchStyle::Regex : MatchStyle::Wildcard;
   MatchStyle SymbolMatchStyle = InputArgs.hasArg(STRIP_regex)
                                     ? MatchStyle::Regex
Expected<DriverConfig> parseStripOptions(ArrayRef<const char *> ArgsArr,
   Config.StripUnneeded = InputArgs.hasArg(STRIP_strip_unneeded);
   if (auto Arg = InputArgs.getLastArg(STRIP_strip_all, STRIP_no_strip_all))
     Config.StripAll = Arg->getOption().getID() == STRIP_strip_all;
   Config.StripAllGNU = InputArgs.hasArg(STRIP_strip_all_gnu);
   Config.StripSwiftSymbols = InputArgs.hasArg(STRIP_strip_swift_symbols);
   Config.OnlyKeepDebug = InputArgs.hasArg(STRIP_only_keep_debug);
   Config.KeepFileSymbols = InputArgs.hasArg(STRIP_keep_file_symbols);
 
+  std::function<Error(Error)> ErrorCallback = [&Reporter](Error Err) {
+    Reporter.warning(std::move(Err));
+    return Error::success();
+  };
   for (auto Arg : InputArgs.filtered(STRIP_keep_section))
     if (Error E = Config.KeepSection.addMatcher(NameOrPattern::create(
             Arg->getValue(), SectionMatchStyle, ErrorCallback)))
       return std::move(E);
 
   for (auto Arg : InputArgs.filtered(STRIP_remove_section))
     if (Error E = Config.ToRemove.addMatcher(NameOrPattern::create(
             Arg->getValue(), SectionMatchStyle, ErrorCallback)))

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

 }
 
 static std::unique_ptr<Writer> createELFWriter(const CopyConfig &Config,
                                                Object &Obj, Buffer &Buf,
                                                ElfType OutputElfType) {
   // Depending on the initial ELFT and OutputFormat we need a different Writer.
   switch (OutputElfType) {
   case ELFT_ELF32LE:
-    return std::make_unique<ELFWriter<ELF32LE>>(Obj, Buf, !Config.StripSections,
-                                                Config.OnlyKeepDebug);
+    return std::make_unique<ELFWriter<ELF32LE>>(
+        Obj, Buf, !Config.StripSections, Config.OnlyKeepDebug, Config.Reporter);
   case ELFT_ELF64LE:
-    return std::make_unique<ELFWriter<ELF64LE>>(Obj, Buf, !Config.StripSections,
-                                                Config.OnlyKeepDebug);
+    return std::make_unique<ELFWriter<ELF64LE>>(
+        Obj, Buf, !Config.StripSections, Config.OnlyKeepDebug, Config.Reporter);
   case ELFT_ELF32BE:
-    return std::make_unique<ELFWriter<ELF32BE>>(Obj, Buf, !Config.StripSections,
-                                                Config.OnlyKeepDebug);
+    return std::make_unique<ELFWriter<ELF32BE>>(
+        Obj, Buf, !Config.StripSections, Config.OnlyKeepDebug, Config.Reporter);
   case ELFT_ELF64BE:
-    return std::make_unique<ELFWriter<ELF64BE>>(Obj, Buf, !Config.StripSections,
-                                                Config.OnlyKeepDebug);
+    return std::make_unique<ELFWriter<ELF64BE>>(
+        Obj, Buf, !Config.StripSections, Config.OnlyKeepDebug, Config.Reporter);
   }
   llvm_unreachable("Invalid output format");
 }
 
 static std::unique_ptr<Writer> createWriter(const CopyConfig &Config,
                                             Object &Obj, Buffer &Buf,
                                             ElfType OutputElfType) {
   switch (Config.OutputFormat) {
   case FileFormat::Binary:
-    return std::make_unique<BinaryWriter>(Obj, Buf);
+    return std::make_unique<BinaryWriter>(Obj, Buf, Config.Reporter);
   case FileFormat::IHex:
-    return std::make_unique<IHexWriter>(Obj, Buf);
+    return std::make_unique<IHexWriter>(Obj, Buf, Config.Reporter);
   default:
     return createELFWriter(Config, Obj, Buf, OutputElfType);
   }
 }
 
 template <class ELFT>
 static Expected<ArrayRef<uint8_t>>
 findBuildID(const CopyConfig &Config, const object::ELFFile<ELFT> &In) {

 
 static bool isCompressable(const SectionBase &Sec) {
   return !(Sec.Flags & ELF::SHF_COMPRESSED) &&
          StringRef(Sec.Name).startswith(".debug");
 }
 
 static void replaceDebugSections(
     Object &Obj, SectionPred &RemovePred,
     function_ref<bool(const SectionBase &)> shouldReplace,
     function_ref<SectionBase *(const SectionBase *)> addSection) {
   // Build a list of the debug sections we are going to replace.
   // We can't call `addSection` while iterating over sections,
   // because it would mutate the sections array.
   SmallVector<SectionBase *, 13> ToReplace;
   for (auto &Sec : Obj.sections())
     if (shouldReplace(Sec))
       ToReplace.push_back(&Sec);
 
   // Build a mapping from original section to a new one.
   DenseMap<SectionBase *, SectionBase *> FromTo;
   for (SectionBase *S : ToReplace)
     FromTo[S] = addSection(S);
 
   // Now we want to update the target sections of relocation
   // sections. Also we will update the relocations themselves
   // to update the symbol references.
   for (auto &Sec : Obj.sections())
     Sec.replaceSectionReferences(FromTo);
 
RemovePred = [&Obj, RemovePred](const SectionBase &Sec) {
       return RemovePred(Sec);
     };
   }
 
   if (Config.CompressionType != DebugCompressionType::None)
     replaceDebugSections(Obj, RemovePred, isCompressable,
                          [&Config, &Obj](const SectionBase *S) {
                            return &Obj.addSection<CompressedSection>(
-                                *S, Config.CompressionType);
+                               *S, Config.CompressionType, Config.Reporter);
                          });
   else if (Config.DecompressDebugSections)
     replaceDebugSections(
         Obj, RemovePred,
         [](const SectionBase &S) { return isa<CompressedSection>(&S); },
         [&Obj](const SectionBase *S) {
           auto CS = cast<CompressedSection>(S);
           return &Obj.addSection<DecompressedSection>(*CS);
std::unique_ptr<Writer> Writer =
       createWriter(Config, Obj, Out, OutputElfType);
   if (Error E = Writer->finalize())
     return E;
   return Writer->write();
 }
 
 Error executeObjcopyOnIHex(const CopyConfig &Config, MemoryBuffer &In,
                            Buffer &Out) {
-  IHexReader Reader(&In);
+  IHexReader Reader(&In, Config.Reporter);
   std::unique_ptr<Object> Obj = Reader.create(true);
   const ElfType OutputElfType =
     getOutputElfType(Config.OutputArch.getValueOr(MachineInfo()));
   if (Error E = handleArgs(Config, *Obj, Reader, OutputElfType))
     return E;
   return writeOutput(Config, *Obj, Out, OutputElfType);
 }
 
 Error executeObjcopyOnRawBinary(const CopyConfig &Config, MemoryBuffer &In,
                                 Buffer &Out) {
   uint8_t NewSymbolVisibility =
       Config.ELF->NewSymbolVisibility.getValueOr((uint8_t)ELF::STV_DEFAULT);
-  BinaryReader Reader(&In, NewSymbolVisibility);
+  BinaryReader Reader(&In, NewSymbolVisibility, Config.Reporter);
   std::unique_ptr<Object> Obj = Reader.create(true);
 
   // Prefer OutputArch (-O<format>) if set, otherwise fallback to BinaryArch
   // (-B<arch>).
   const ElfType OutputElfType =
       getOutputElfType(Config.OutputArch.getValueOr(MachineInfo()));
   if (Error E = handleArgs(Config, *Obj, Reader, OutputElfType))
     return E;
   return writeOutput(Config, *Obj, Out, OutputElfType);
 }
 
 Error executeObjcopyOnBinary(const CopyConfig &Config,
                              object::ELFObjectFileBase &In, Buffer &Out) {
-  ELFReader Reader(&In, Config.ExtractPartition);
+  ELFReader Reader(&In, Config.ExtractPartition, Config.Reporter);
   std::unique_ptr<Object> Obj = Reader.create(!Config.SymbolsToAdd.empty());
   // Prefer OutputArch (-O<format>) if set, otherwise infer it from the input.
   const ElfType OutputElfType =
       Config.OutputArch ? getOutputElfType(Config.OutputArch.getValue())
                         : getOutputElfType(In);
   ArrayRef<uint8_t> BuildIdBytes;
 
   if (!Config.BuildIdLinkDir.empty()) {

llvm/tools/llvm-objcopy/ELF/Object.h

public:
   explicit SectionTableRef(MutableArrayRef<std::unique_ptr<SectionBase>> Secs)
       : Sections(Secs) {}
   SectionTableRef(const SectionTableRef &) = default;
 
   iterator begin() const { return iterator(Sections.data()); }
   iterator end() const { return iterator(Sections.data() + Sections.size()); }
   size_t size() const { return Sections.size(); }
 
-  SectionBase *getSection(uint32_t Index, Twine ErrMsg);
+  SectionBase *getSection(uint32_t Index, Twine ErrMsg,
+                          const ErrorReporter &Reporter);
 
   template <class T>
-  T *getSectionOfType(uint32_t Index, Twine IndexErrMsg, Twine TypeErrMsg);
+  T *getSectionOfType(uint32_t Index, Twine IndexErrMsg, Twine TypeErrMsg,
+                      const ErrorReporter &Reporter);
 };
 
 enum ElfType { ELFT_ELF32LE, ELFT_ELF64LE, ELFT_ELF32BE, ELFT_ELF64BE };
 
 class SectionVisitor {
 public:
+  SectionVisitor(const ErrorReporter &Reporter) : Reporter(Reporter) {}
   virtual ~SectionVisitor() = default;
 
   virtual void visit(const Section &Sec) = 0;
   virtual void visit(const OwnedDataSection &Sec) = 0;
   virtual void visit(const StringTableSection &Sec) = 0;
   virtual void visit(const SymbolTableSection &Sec) = 0;
   virtual void visit(const RelocationSection &Sec) = 0;
   virtual void visit(const DynamicRelocationSection &Sec) = 0;
   virtual void visit(const GnuDebugLinkSection &Sec) = 0;
   virtual void visit(const GroupSection &Sec) = 0;
   virtual void visit(const SectionIndexSection &Sec) = 0;
   virtual void visit(const CompressedSection &Sec) = 0;
   virtual void visit(const DecompressedSection &Sec) = 0;
+
+protected:
+  const ErrorReporter &Reporter;
 };
 
 class MutableSectionVisitor {
 public:
   virtual ~MutableSectionVisitor() = default;
 
   virtual void visit(Section &Sec) = 0;
   virtual void visit(OwnedDataSection &Sec) = 0;
public:
   void visit(const StringTableSection &Sec) override;
   void visit(const DynamicRelocationSection &Sec) override;
   virtual void visit(const SymbolTableSection &Sec) override = 0;
   virtual void visit(const RelocationSection &Sec) override = 0;
   virtual void visit(const GnuDebugLinkSection &Sec) override = 0;
   virtual void visit(const GroupSection &Sec) override = 0;
   virtual void visit(const SectionIndexSection &Sec) override = 0;
   virtual void visit(const CompressedSection &Sec) override = 0;
   virtual void visit(const DecompressedSection &Sec) override = 0;
 
-  explicit SectionWriter(Buffer &Buf) : Out(Buf) {}
+  explicit SectionWriter(Buffer &Buf, const ErrorReporter &Reporter)
+      : SectionVisitor(Reporter), Out(Buf) {}
 };
 
 template <class ELFT> class ELFSectionWriter : public SectionWriter {
 private:
   using Elf_Word = typename ELFT::Word;
   using Elf_Rel = typename ELFT::Rel;
   using Elf_Rela = typename ELFT::Rela;
   using Elf_Sym = typename ELFT::Sym;
 
 public:
   virtual ~ELFSectionWriter() {}
   void visit(const SymbolTableSection &Sec) override;
   void visit(const RelocationSection &Sec) override;
   void visit(const GnuDebugLinkSection &Sec) override;
   void visit(const GroupSection &Sec) override;
   void visit(const SectionIndexSection &Sec) override;
   void visit(const CompressedSection &Sec) override;
   void visit(const DecompressedSection &Sec) override;
 
-  explicit ELFSectionWriter(Buffer &Buf) : SectionWriter(Buf) {}
+  explicit ELFSectionWriter(Buffer &Buf, const ErrorReporter &Reporter)
+      : SectionWriter(Buf, Reporter) {}
 };
 
 template <class ELFT> class ELFSectionSizer : public MutableSectionVisitor {
 private:
   using Elf_Rel = typename ELFT::Rel;
   using Elf_Rela = typename ELFT::Rela;
   using Elf_Sym = typename ELFT::Sym;
   using Elf_Word = typename ELFT::Word;
public:
   void visit(const SymbolTableSection &Sec) override;
   void visit(const RelocationSection &Sec) override;
   void visit(const GnuDebugLinkSection &Sec) override;
   void visit(const GroupSection &Sec) override;
   void visit(const SectionIndexSection &Sec) override;
   void visit(const CompressedSection &Sec) override;
   void visit(const DecompressedSection &Sec) override;
 
-  explicit BinarySectionWriter(Buffer &Buf) : SectionWriter(Buf) {}
+  explicit BinarySectionWriter(Buffer &Buf, const ErrorReporter &Reporter)
+      : SectionWriter(Buf, Reporter) {}
 };
 
 using IHexLineData = SmallVector<char, 64>;
 
 struct IHexRecord {
   // Memory address of the record.
   uint16_t Addr;
   // Record type (see below).

 protected:
   // Offset in the output buffer
   uint64_t Offset = 0;
 
   void writeSection(const SectionBase *Sec, ArrayRef<uint8_t> Data);
   virtual void writeData(uint8_t Type, uint16_t Addr, ArrayRef<uint8_t> Data);
 
 public:
-  explicit IHexSectionWriterBase(Buffer &Buf) : BinarySectionWriter(Buf) {}
+  explicit IHexSectionWriterBase(Buffer &Buf, const ErrorReporter &Reporter)
+      : BinarySectionWriter(Buf, Reporter) {}
 
   uint64_t getBufferOffset() const { return Offset; }
   void visit(const Section &Sec) final;
   void visit(const OwnedDataSection &Sec) final;
   void visit(const StringTableSection &Sec) override;
   void visit(const DynamicRelocationSection &Sec) final;
   using BinarySectionWriter::visit;
 };
 
 // Real IHEX section writer
 class IHexSectionWriter : public IHexSectionWriterBase {
 public:
-  IHexSectionWriter(Buffer &Buf) : IHexSectionWriterBase(Buf) {}
+  IHexSectionWriter(Buffer &Buf, const ErrorReporter &Reporter)
+      : IHexSectionWriterBase(Buf, Reporter) {}
 
   void writeData(uint8_t Type, uint16_t Addr, ArrayRef<uint8_t> Data) override;
   void visit(const StringTableSection &Sec) override;
 };
 
 class Writer {
 protected:
   Object &Obj;
   Buffer &Buf;
+  const ErrorReporter &Reporter;
 
 public:
   virtual ~Writer();
   virtual Error finalize() = 0;
   virtual Error write() = 0;
 
-  Writer(Object &O, Buffer &B) : Obj(O), Buf(B) {}
+  Writer(Object &O, Buffer &B, const ErrorReporter &Reporter)
+      : Obj(O), Buf(B), Reporter(Reporter) {}
 };
 
 template <class ELFT> class ELFWriter : public Writer {
 private:
   using Elf_Addr = typename ELFT::Addr;
   using Elf_Shdr = typename ELFT::Shdr;
   using Elf_Phdr = typename ELFT::Phdr;
   using Elf_Ehdr = typename ELFT::Ehdr;
public:
   bool WriteSectionHeaders;
 
   // For --only-keep-debug, select an alternative section/segment layout
   // algorithm.
   bool OnlyKeepDebug;
 
   Error finalize() override;
   Error write() override;
-  ELFWriter(Object &Obj, Buffer &Buf, bool WSH, bool OnlyKeepDebug);
+  ELFWriter(Object &Obj, Buffer &Buf, bool WSH, bool OnlyKeepDebug,
+            const ErrorReporter &Reporter);
 };
 
 class BinaryWriter : public Writer {
 private:
   std::unique_ptr<BinarySectionWriter> SecWriter;
 
   uint64_t TotalSize = 0;
 
 public:
   ~BinaryWriter() {}
   Error finalize() override;
   Error write() override;
-  BinaryWriter(Object &Obj, Buffer &Buf) : Writer(Obj, Buf) {}
+  BinaryWriter(Object &Obj, Buffer &Buf, const ErrorReporter &Reporter)
+      : Writer(Obj, Buf, Reporter) {}
 };
 
 class IHexWriter : public Writer {
   struct SectionCompare {
     bool operator()(const SectionBase *Lhs, const SectionBase *Rhs) const;
   };
 
   std::set<const SectionBase *, SectionCompare> Sections;
   size_t TotalSize = 0;
 
   Error checkSection(const SectionBase &Sec);
   uint64_t writeEntryPointRecord(uint8_t *Buf);
   uint64_t writeEndOfFileRecord(uint8_t *Buf);
 
 public:
   ~IHexWriter() {}
   Error finalize() override;
   Error write() override;
-  IHexWriter(Object &Obj, Buffer &Buf) : Writer(Obj, Buf) {}
+  IHexWriter(Object &Obj, Buffer &Buf, const ErrorReporter &Reporter)
+      : Writer(Obj, Buf, Reporter) {}
 };
 
 class SectionBase {
 public:
   std::string Name;
   Segment *ParentSegment = nullptr;
   uint64_t HeaderOffset = 0;
   uint32_t Index = 0;
public:
   uint64_t Type = ELF::SHT_NULL;
   ArrayRef<uint8_t> OriginalData;
 
   SectionBase() = default;
   SectionBase(const SectionBase &) = default;
 
   virtual ~SectionBase() = default;
 
-  virtual void initialize(SectionTableRef SecTable);
+  virtual void initialize(SectionTableRef SecTable,
+                          const ErrorReporter &Reporter);
   virtual void finalize();
   // Remove references to these sections. The list of sections must be sorted.
   virtual Error
   removeSectionReferences(bool AllowBrokenLinks,
                           function_ref<bool(const SectionBase *)> ToRemove);
   virtual Error removeSymbols(function_ref<bool(const Symbol &)> ToRemove);
   virtual void accept(SectionVisitor &Visitor) const = 0;
   virtual void accept(MutableSectionVisitor &Visitor) = 0;

 
 public:
   explicit Section(ArrayRef<uint8_t> Data) : Contents(Data) {}
 
   void accept(SectionVisitor &Visitor) const override;
   void accept(MutableSectionVisitor &Visitor) override;
   Error removeSectionReferences(bool AllowBrokenLinks,
       function_ref<bool(const SectionBase *)> ToRemove) override;
-  void initialize(SectionTableRef SecTable) override;
+  void initialize(SectionTableRef SecTable,
+                  const ErrorReporter &Reporter) override;
   void finalize() override;
 };
 
 class OwnedDataSection : public SectionBase {
   MAKE_SEC_WRITER_FRIEND
 
   std::vector<uint8_t> Data;
 
class CompressedSection : public SectionBase {
 
   DebugCompressionType CompressionType;
   uint64_t DecompressedSize;
   uint64_t DecompressedAlign;
   SmallVector<char, 128> CompressedData;
 
 public:
   CompressedSection(const SectionBase &Sec,
-                    DebugCompressionType CompressionType);
+                    DebugCompressionType CompressionType,
+                    const ErrorReporter &Reporter);
   CompressedSection(ArrayRef<uint8_t> CompressedData, uint64_t DecompressedSize,
                     uint64_t DecompressedAlign);
 
   uint64_t getDecompressedSize() const { return DecompressedSize; }
   uint64_t getDecompressedAlign() const { return DecompressedAlign; }
 
   void accept(SectionVisitor &Visitor) const override;
   void accept(MutableSectionVisitor &Visitor) override;
void addIndex(uint32_t Index) {
     Indexes.push_back(Index);    
   }
 
   void reserve(size_t NumSymbols) {
     Indexes.reserve(NumSymbols);
     Size = NumSymbols * 4;
   }  
   void setSymTab(SymbolTableSection *SymTab) { Symbols = SymTab; }
-  void initialize(SectionTableRef SecTable) override;
+  void initialize(SectionTableRef SecTable,
+                  const ErrorReporter &Reporter) override;
   void finalize() override;
   void accept(SectionVisitor &Visitor) const override;
   void accept(MutableSectionVisitor &Visitor) override;
 
   SectionIndexSection() {
     Name = ".symtab_shndx";
     Align = 4;
     EntrySize = 4;
public:
   // An 'empty' symbol table still contains a null symbol.
   bool empty() const { return Symbols.size() == 1; }
   void setShndxTable(SectionIndexSection *ShndxTable) {
     SectionIndexTable = ShndxTable;
   }
   const SectionIndexSection *getShndxTable() const { return SectionIndexTable; }
   void fillShndxTable();
   const SectionBase *getStrTab() const { return SymbolNames; }
-  const Symbol *getSymbolByIndex(uint32_t Index) const;
-  Symbol *getSymbolByIndex(uint32_t Index);
+  const Symbol *getSymbolByIndex(uint32_t Index,
+                                 const ErrorReporter &Reporter) const;
+  Symbol *getSymbolByIndex(uint32_t Index, const ErrorReporter &Reporter);
   void updateSymbols(function_ref<void(Symbol &)> Callable);
 
   Error removeSectionReferences(bool AllowBrokenLinks,
       function_ref<bool(const SectionBase *)> ToRemove) override;
-  void initialize(SectionTableRef SecTable) override;
+  void initialize(SectionTableRef SecTable, const ErrorReporter &) override;
   void finalize() override;
   void accept(SectionVisitor &Visitor) const override;
   void accept(MutableSectionVisitor &Visitor) override;
   Error removeSymbols(function_ref<bool(const Symbol &)> ToRemove) override;
   void replaceSectionReferences(
       const DenseMap<SectionBase *, SectionBase *> &FromTo) override;
 
   static bool classof(const SectionBase *S) {
class RelocSectionWithSymtabBase : public RelocationSectionBase {
   void setSymTab(SymTabType *SymTab) { Symbols = SymTab; }
 
 protected:
   RelocSectionWithSymtabBase() = default;
 
   SymTabType *Symbols = nullptr;
 
 public:
-  void initialize(SectionTableRef SecTable) override;
+  void initialize(SectionTableRef SecTable,
+                  const ErrorReporter &Reporter) override;
   void finalize() override;
 };
 
 class RelocationSection
     : public RelocSectionWithSymtabBase<SymbolTableSection> {
   MAKE_SEC_WRITER_FRIEND
 
   std::vector<Relocation> Relocations;
public:
   // If we add this section from an external source we can use this ctor.
   explicit GnuDebugLinkSection(StringRef File, uint32_t PrecomputedCRC);
   void accept(SectionVisitor &Visitor) const override;
   void accept(MutableSectionVisitor &Visitor) override;
 };
 
 class Reader {
 public:
+  Reader(const ErrorReporter &Reporter) : Reporter(Reporter) {}
   virtual ~Reader();
   virtual std::unique_ptr<Object> create(bool EnsureSymtab) const = 0;
+
+protected:
+  const ErrorReporter &Reporter;
 };
 
 using object::Binary;
 using object::ELFFile;
 using object::ELFObjectFile;
 using object::OwningBinary;
 
 class BasicELFBuilder {
 protected:
   std::unique_ptr<Object> Obj;
+  const ErrorReporter &Reporter;
 
   void initFileHeader();
   void initHeaderSegment();
   StringTableSection *addStrTab();
   SymbolTableSection *addSymTab(StringTableSection *StrTab);
   void initSections();
 
 public:
-  BasicELFBuilder() : Obj(std::make_unique<Object>()) {}
+  BasicELFBuilder(const ErrorReporter &Reporter)
+      : Obj(std::make_unique<Object>(Reporter)), Reporter(Reporter) {}
 };
 
 class BinaryELFBuilder : public BasicELFBuilder {
   MemoryBuffer *MemBuf;
   uint8_t NewSymbolVisibility;
   void addData(SymbolTableSection *SymTab);
 
 public:
-  BinaryELFBuilder(MemoryBuffer *MB, uint8_t NewSymbolVisibility)
-      : BasicELFBuilder(), MemBuf(MB),
+  BinaryELFBuilder(MemoryBuffer *MB, uint8_t NewSymbolVisibility,
+                   const ErrorReporter &Reporter)
+      : BasicELFBuilder(Reporter), MemBuf(MB),
         NewSymbolVisibility(NewSymbolVisibility) {}
 
   std::unique_ptr<Object> build();
 };
 
 class IHexELFBuilder : public BasicELFBuilder {
   const std::vector<IHexRecord> &Records;
 
   void addDataSections();
 
 public:
-  IHexELFBuilder(const std::vector<IHexRecord> &Records)
-      : BasicELFBuilder(), Records(Records) {}
+  IHexELFBuilder(const std::vector<IHexRecord> &Records,
+                 const ErrorReporter &Reporter)
+      : BasicELFBuilder(Reporter), Records(Records) {}
 
   std::unique_ptr<Object> build();
 };
 
 template <class ELFT> class ELFBuilder {
 private:
   using Elf_Addr = typename ELFT::Addr;
   using Elf_Shdr = typename ELFT::Shdr;
   using Elf_Word = typename ELFT::Word;
 
   const ELFFile<ELFT> &ElfFile;
   Object &Obj;
   size_t EhdrOffset = 0;
   Optional<StringRef> ExtractPartition;
+  const ErrorReporter &Reporter;
 
   void setParentSegment(Segment &Child);
   void readProgramHeaders(const ELFFile<ELFT> &HeadersFile);
   void initGroupSection(GroupSection *GroupSec);
   void initSymbolTable(SymbolTableSection *SymTab);
   void readSectionHeaders();
   void readSections(bool EnsureSymtab);
   void findEhdrOffset();
   SectionBase &makeSection(const Elf_Shdr &Shdr);
 
 public:
   ELFBuilder(const ELFObjectFile<ELFT> &ElfObj, Object &Obj,
-             Optional<StringRef> ExtractPartition)
+             Optional<StringRef> ExtractPartition,
+             const ErrorReporter &Reporter)
       : ElfFile(*ElfObj.getELFFile()), Obj(Obj),
-        ExtractPartition(ExtractPartition) {}
+        ExtractPartition(ExtractPartition), Reporter(Reporter) {}
 
   void build(bool EnsureSymtab);
 };
 
 class BinaryReader : public Reader {
   MemoryBuffer *MemBuf;
   uint8_t NewSymbolVisibility;
 
 public:
-  BinaryReader(MemoryBuffer *MB, const uint8_t NewSymbolVisibility)
-      : MemBuf(MB), NewSymbolVisibility(NewSymbolVisibility) {}
+  BinaryReader(MemoryBuffer *MB, const uint8_t NewSymbolVisibility,
+               const ErrorReporter &Reporter)
+      : Reader(Reporter), MemBuf(MB), NewSymbolVisibility(NewSymbolVisibility) {
+  }
   std::unique_ptr<Object> create(bool EnsureSymtab) const override;
 };
 
 class IHexReader : public Reader {
   MemoryBuffer *MemBuf;
 
   Expected<std::vector<IHexRecord>> parse() const;
   Error parseError(size_t LineNo, Error E) const {
     return LineNo == -1U
                ? createFileError(MemBuf->getBufferIdentifier(), std::move(E))
                : createFileError(MemBuf->getBufferIdentifier(), LineNo,
                                  std::move(E));
   }
   template <typename... Ts>
   Error parseError(size_t LineNo, char const *Fmt, const Ts &... Vals) const {
     Error E = createStringError(errc::invalid_argument, Fmt, Vals...);
     return parseError(LineNo, std::move(E));
   }
 
 public:
-  IHexReader(MemoryBuffer *MB) : MemBuf(MB) {}
+  IHexReader(MemoryBuffer *MB, const ErrorReporter &Reporter)
+      : Reader(Reporter), MemBuf(MB) {}
 
   std::unique_ptr<Object> create(bool EnsureSymtab) const override;
 };
 
 class ELFReader : public Reader {
   Binary *Bin;
   Optional<StringRef> ExtractPartition;
 
 public:
   std::unique_ptr<Object> create(bool EnsureSymtab) const override;
-  explicit ELFReader(Binary *B, Optional<StringRef> ExtractPartition)
-      : Bin(B), ExtractPartition(ExtractPartition) {}
+  explicit ELFReader(Binary *B, Optional<StringRef> ExtractPartition,
+                     const ErrorReporter &Reporter)
+      : Reader(Reporter), Bin(B), ExtractPartition(ExtractPartition) {}
 };
 
 class Object {
 private:
   using SecPtr = std::unique_ptr<SectionBase>;
   using SegPtr = std::unique_ptr<Segment>;
 
   std::vector<SecPtr> Sections;
   std::vector<SegPtr> Segments;
   std::vector<SecPtr> RemovedSections;
 
+  const ErrorReporter &Reporter;
+
   static bool sectionIsAlloc(const SectionBase &Sec) {
     return Sec.Flags & ELF::SHF_ALLOC;
   };
 
 public:
+  Object(const ErrorReporter &Reporter) : Reporter(Reporter) {}
+
   template <class T>
   using Range = iterator_range<
       pointee_iterator<typename std::vector<std::unique_ptr<T>>::iterator>>;
 
   template <class T>
   using ConstRange = iterator_range<pointee_iterator<
       typename std::vector<std::unique_ptr<T>>::const_iterator>>;
 

llvm/tools/llvm-objcopy/ELF/Object.cpp

template <class ELFT> void ELFWriter<ELFT>::writePhdr(const Segment &Seg) {
   Phdr.p_paddr = Seg.PAddr;
   Phdr.p_filesz = Seg.FileSize;
   Phdr.p_memsz = Seg.MemSize;
   Phdr.p_align = Seg.Align;
 }
 
 Error SectionBase::removeSectionReferences(
     bool AllowBrokenLinks,
     function_ref<bool(const SectionBase *)> ToRemove) {
   return Error::success();
 }
 
 Error SectionBase::removeSymbols(function_ref<bool(const Symbol &)> ToRemove) {
   return Error::success();
 }
 
-void SectionBase::initialize(SectionTableRef SecTable) {}
+void SectionBase::initialize(SectionTableRef SecTable,
+                             const ErrorReporter &Reporter) {}
 void SectionBase::finalize() {}
 void SectionBase::markSymbols() {}
 void SectionBase::replaceSectionReferences(
     const DenseMap<SectionBase *, SectionBase *> &) {}
 void SectionBase::onRemove() {}
 
 template <class ELFT> void ELFWriter<ELFT>::writeShdr(const SectionBase &Sec) {
   uint8_t *B = Buf.getBufferStart() + Sec.HeaderOffset;

 
 template <class ELFT>
 void ELFSectionSizer<ELFT>::visit(CompressedSection &Sec) {}
 
 template <class ELFT>
 void ELFSectionSizer<ELFT>::visit(DecompressedSection &Sec) {}
 
 void BinarySectionWriter::visit(const SectionIndexSection &Sec) {
-  error("cannot write symbol section index table '" + Sec.Name + "' ");
+  Reporter.fatalError(errc::operation_not_permitted,
+                      "cannot write symbol section index table '" + Sec.Name +
+                          "' ");
 }
 
 void BinarySectionWriter::visit(const SymbolTableSection &Sec) {
-  error("cannot write symbol table '" + Sec.Name + "' out to binary");
+  Reporter.fatalError(errc::operation_not_permitted,
+                      "cannot write symbol table '" + Sec.Name +
+                          "' out to binary");
 }
 
 void BinarySectionWriter::visit(const RelocationSection &Sec) {
-  error("cannot write relocation section '" + Sec.Name + "' out to binary");
+  Reporter.fatalError(errc::operation_not_permitted,
+                      "cannot write relocation section '" + Sec.Name +
+                          "' out to binary");
 }
 
 void BinarySectionWriter::visit(const GnuDebugLinkSection &Sec) {
-  error("cannot write '" + Sec.Name + "' out to binary");
+  Reporter.fatalError(errc::operation_not_permitted,
+                      "cannot write '" + Sec.Name + "' out to binary");
 }
 
 void BinarySectionWriter::visit(const GroupSection &Sec) {
-  error("cannot write '" + Sec.Name + "' out to binary");
+  Reporter.fatalError(errc::operation_not_permitted,
+                      "cannot write '" + Sec.Name + "' out to binary");
 }
 
 void SectionWriter::visit(const Section &Sec) {
   if (Sec.Type != SHT_NOBITS)
     llvm::copy(Sec.Contents, Out.getBufferStart() + Sec.Offset);
 }
 
 static bool addressOverflows32bit(uint64_t Addr) {
void ELFSectionWriter<ELFT>::visit(const DecompressedSection &Sec) {
 
   StringRef CompressedContent(
       reinterpret_cast<const char *>(Sec.OriginalData.data()) + DataOffset,
       Sec.OriginalData.size() - DataOffset);
 
   SmallVector<char, 128> DecompressedContent;
   if (Error E = zlib::uncompress(CompressedContent, DecompressedContent,
                                  static_cast<size_t>(Sec.Size)))
-    reportError(Sec.Name, std::move(E));
+    Reporter.fatalError(std::move(E), Sec.Name);
 
   uint8_t *Buf = Out.getBufferStart() + Sec.Offset;
   std::copy(DecompressedContent.begin(), DecompressedContent.end(), Buf);
 }
 
 void BinarySectionWriter::visit(const DecompressedSection &Sec) {
-  error("cannot write compressed section '" + Sec.Name + "' ");
+  Reporter.fatalError(errc::operation_not_permitted,
+                      "cannot write compressed section '" + Sec.Name + "' ");
 }
 
 void DecompressedSection::accept(SectionVisitor &Visitor) const {
   Visitor.visit(*this);
 }
 
 void DecompressedSection::accept(MutableSectionVisitor &Visitor) {
   Visitor.visit(*this);
void OwnedDataSection::appendHexData(StringRef HexData) {
   while (!HexData.empty()) {
     Data.push_back(checkedGetHex<uint8_t>(HexData.take_front(2)));
     HexData = HexData.drop_front(2);
   }
   Size = Data.size();
 }
 
 void BinarySectionWriter::visit(const CompressedSection &Sec) {
-  error("cannot write compressed section '" + Sec.Name + "' ");
+  Reporter.fatalError(errc::operation_not_permitted,
+                      "cannot write compressed section '" + Sec.Name + "' ");
 }
 
 template <class ELFT>
 void ELFSectionWriter<ELFT>::visit(const CompressedSection &Sec) {
   uint8_t *Buf = Out.getBufferStart() + Sec.Offset;
   if (Sec.CompressionType == DebugCompressionType::None) {
     std::copy(Sec.OriginalData.begin(), Sec.OriginalData.end(), Buf);
     return;
if (Sec.CompressionType == DebugCompressionType::GNU) {
     Chdr.ch_addralign = Sec.DecompressedAlign;
     memcpy(Buf, &Chdr, sizeof(Chdr));
     Buf += sizeof(Chdr);
   }
 
   std::copy(Sec.CompressedData.begin(), Sec.CompressedData.end(), Buf);
 }
 
 CompressedSection::CompressedSection(const SectionBase &Sec,
-                                     DebugCompressionType CompressionType)
+                                     DebugCompressionType CompressionType,
+                                     const ErrorReporter &Reporter)
     : SectionBase(Sec), CompressionType(CompressionType),
       DecompressedSize(Sec.OriginalData.size()), DecompressedAlign(Sec.Align) {
   if (Error E = zlib::compress(
           StringRef(reinterpret_cast<const char *>(OriginalData.data()),
                     OriginalData.size()),
           CompressedData))
-    reportError(Name, std::move(E));
+    Reporter.fatalError(std::move(E), Name);
 
   size_t ChdrSize;
   if (CompressionType == DebugCompressionType::GNU) {
     Name = ".z" + Sec.Name.substr(1);
     ChdrSize = sizeof("ZLIB") - 1 + sizeof(uint64_t);
   } else {
     Flags |= ELF::SHF_COMPRESSED;
     ChdrSize =
         std::max(std::max(sizeof(object::Elf_Chdr_Impl<object::ELF64LE>),
                           sizeof(object::Elf_Chdr_Impl<object::ELF64BE>)),
                  std::max(sizeof(object::Elf_Chdr_Impl<object::ELF32LE>),
                           sizeof(object::Elf_Chdr_Impl<object::ELF32BE>)));
   }
   Size = ChdrSize + CompressedData.size();
   Align = 8;
 }
 
 CompressedSection::CompressedSection(ArrayRef<uint8_t> CompressedData,
                                      uint64_t DecompressedSize,

 }
 
 template <class ELFT>
 void ELFSectionWriter<ELFT>::visit(const SectionIndexSection &Sec) {
   uint8_t *Buf = Out.getBufferStart() + Sec.Offset;
   llvm::copy(Sec.Indexes, reinterpret_cast<Elf_Word *>(Buf));
 }
 
-void SectionIndexSection::initialize(SectionTableRef SecTable) {
+void SectionIndexSection::initialize(SectionTableRef SecTable,
+                                     const ErrorReporter &Reporter) {
   Size = 0;
   setSymTab(SecTable.getSectionOfType<SymbolTableSection>(
       Link,
       "Link field value " + Twine(Link) + " in section " + Name + " is invalid",
       "Link field value " + Twine(Link) + " in section " + Name +
-          " is not a symbol table"));
+          " is not a symbol table",
+      Reporter));
   Symbols->setShndxTable(this);
 }
 
 void SectionIndexSection::finalize() { Link = Symbols->Index; }
 
 void SectionIndexSection::accept(SectionVisitor &Visitor) const {
   Visitor.visit(*this);
 }
 
 void SectionIndexSection::accept(MutableSectionVisitor &Visitor) {
   Visitor.visit(*this);
 }
 
 static bool isValidReservedSectionIndex(uint16_t Index, uint16_t Machine) {
   switch (Index) {
   case SHN_ABS:

 
 void SymbolTableSection::replaceSectionReferences(
     const DenseMap<SectionBase *, SectionBase *> &FromTo) {
   for (std::unique_ptr<Symbol> &Sym : Symbols)
     if (SectionBase *To = FromTo.lookup(Sym->DefinedIn))
       Sym->DefinedIn = To;
 }
 
-void SymbolTableSection::initialize(SectionTableRef SecTable) {
+void SymbolTableSection::initialize(SectionTableRef SecTable,
+                                    const ErrorReporter &Reporter) {
   Size = 0;
   setStrTab(SecTable.getSectionOfType<StringTableSection>(
       Link,
       "Symbol table has link index of " + Twine(Link) +
           " which is not a valid index",
       "Symbol table has link index of " + Twine(Link) +
-          " which is not a string table"));
+          " which is not a string table",
+      Reporter));
 }
 
 void SymbolTableSection::finalize() {
   uint32_t MaxLocalIndex = 0;
   for (std::unique_ptr<Symbol> &Sym : Symbols) {
     Sym->NameIndex =
         SymbolNames == nullptr ? 0 : SymbolNames->findIndex(Sym->Name);
     if (Sym->Binding == STB_LOCAL)
void SymbolTableSection::fillShndxTable() {
   for (const std::unique_ptr<Symbol> &Sym : Symbols) {
     if (Sym->DefinedIn != nullptr && Sym->DefinedIn->Index >= SHN_LORESERVE)
       SectionIndexTable->addIndex(Sym->DefinedIn->Index);
     else
       SectionIndexTable->addIndex(SHN_UNDEF);
   }
 }
 
-const Symbol *SymbolTableSection::getSymbolByIndex(uint32_t Index) const {
+const Symbol *
+SymbolTableSection::getSymbolByIndex(uint32_t Index,
+                                     const ErrorReporter &Reporter) const {
   if (Symbols.size() <= Index)
-    error("invalid symbol index: " + Twine(Index));
+    Reporter.fatalError(errc::invalid_argument,
+                        "invalid symbol index: " + Twine(Index));
   return Symbols[Index].get();
 }
 
-Symbol *SymbolTableSection::getSymbolByIndex(uint32_t Index) {
+Symbol *SymbolTableSection::getSymbolByIndex(uint32_t Index,
+                                             const ErrorReporter &Reporter) {
   return const_cast<Symbol *>(
-      static_cast<const SymbolTableSection *>(this)->getSymbolByIndex(Index));
+      static_cast<const SymbolTableSection *>(this)->getSymbolByIndex(
+          Index, Reporter));
 }
 
 template <class ELFT>
 void ELFSectionWriter<ELFT>::visit(const SymbolTableSection &Sec) {
   Elf_Sym *Sym = reinterpret_cast<Elf_Sym *>(Out.getBufferStart() + Sec.Offset);
   // Loop though symbols setting each entry of the symbol table.
   for (const std::unique_ptr<Symbol> &Symbol : Sec.Symbols) {
     Sym->st_name = Symbol->NameIndex;
return createStringError(llvm::errc::invalid_argument,
                              R.RelocSymbol->Name.c_str());
   }
 
   return Error::success();
 }
 
 template <class SymTabType>
 void RelocSectionWithSymtabBase<SymTabType>::initialize(
-    SectionTableRef SecTable) {
+    SectionTableRef SecTable, const ErrorReporter &Reporter) {
   if (Link != SHN_UNDEF)
     setSymTab(SecTable.getSectionOfType<SymTabType>(
         Link,
         "Link field value " + Twine(Link) + " in section " + Name +
             " is invalid",
         "Link field value " + Twine(Link) + " in section " + Name +
-            " is not a symbol table"));
+            " is not a symbol table",
+        Reporter));
 
   if (Info != SHN_UNDEF)
-    setSection(SecTable.getSection(Info, "Info field value " + Twine(Info) +
-                                             " in section " + Name +
-                                             " is invalid"));
+    setSection(SecTable.getSection(Info,
+                                   "Info field value " + Twine(Info) +
+                                       " in section " + Name + " is invalid",
+                                   Reporter));
   else
     setSection(nullptr);
 }
 
 template <class SymTabType>
 void RelocSectionWithSymtabBase<SymTabType>::finalize() {
   this->Link = Symbols ? Symbols->Index : 0;
 

 
 void GroupSection::onRemove() {
   // As the header section of the group is removed, drop the Group flag in its
   // former members.
   for (SectionBase *Sec : GroupMembers)
     Sec->Flags &= ~SHF_GROUP;
 }
 
-void Section::initialize(SectionTableRef SecTable) {
+void Section::initialize(SectionTableRef SecTable,
+                         const ErrorReporter &Reporter) {
   if (Link == ELF::SHN_UNDEF)
     return;
-  LinkSection =
-      SecTable.getSection(Link, "Link field value " + Twine(Link) +
-                                    " in section " + Name + " is invalid");
+  LinkSection = SecTable.getSection(Link,
+                                    "Link field value " + Twine(Link) +
+                                        " in section " + Name + " is invalid",
+                                    Reporter);
   if (LinkSection->Type == ELF::SHT_SYMTAB)
     LinkSection = nullptr;
 }
 
 void Section::finalize() { this->Link = LinkSection ? LinkSection->Index : 0; }
 
 void GnuDebugLinkSection::init(StringRef File) {
   FileName = sys::path::filename(File);
   // The format for the .gnu_debuglink starts with the file name and is
   // followed by a null terminator and then the CRC32 of the file. The CRC32
   // should be 4 byte aligned. So we add the FileName size, a 1 for the null
   // byte, and then finally push the size to alignment and add 4.
SymbolTableSection *BasicELFBuilder::addSymTab(StringTableSection *StrTab) {
   SymTab.addSymbol("", 0, 0, nullptr, 0, 0, 0, 0);
 
   Obj->SymbolTable = &SymTab;
   return &SymTab;
 }
 
 void BasicELFBuilder::initSections() {
   for (SectionBase &Sec : Obj->sections())
-    Sec.initialize(Obj->sections());
+    Sec.initialize(Obj->sections(), Reporter);
 }
 
 void BinaryELFBuilder::addData(SymbolTableSection *SymTab) {
   auto Data = ArrayRef<uint8_t>(
       reinterpret_cast<const uint8_t *>(MemBuf->getBufferStart()),
       MemBuf->getBufferSize());
   auto &DataSection = Obj->addSection<Section>(Data);
   DataSection.Name = ".data";
if (!ExtractPartition)
     return;
 
   for (const SectionBase &Sec : Obj.sections()) {
     if (Sec.Type == SHT_LLVM_PART_EHDR && Sec.Name == *ExtractPartition) {
       EhdrOffset = Sec.Offset;
       return;
     }
   }
-  error("could not find partition named '" + *ExtractPartition + "'");
+  Reporter.fatalError(errc::invalid_argument,
+                      "could not find partition named '" + *ExtractPartition +
+                          "'");
 }
 
 template <class ELFT>
 void ELFBuilder<ELFT>::readProgramHeaders(const ELFFile<ELFT> &HeadersFile) {
   uint32_t Index = 0;
-  for (const auto &Phdr : unwrapOrError(HeadersFile.program_headers())) {
+  for (const auto &Phdr :
+       unwrapOrFatalError(HeadersFile.program_headers(), Reporter)) {
     if (Phdr.p_offset + Phdr.p_filesz > HeadersFile.getBufSize())
-      error("program header with offset 0x" + Twine::utohexstr(Phdr.p_offset) +
+      Reporter.fatalError(
+          errc::invalid_argument,
+          "program header with offset 0x" + Twine::utohexstr(Phdr.p_offset) +
               " and file size 0x" + Twine::utohexstr(Phdr.p_filesz) +
               " goes past the end of the file");
 
     ArrayRef<uint8_t> Data{HeadersFile.base() + Phdr.p_offset,
                            (size_t)Phdr.p_filesz};
     Segment &Seg = Obj.addSegment(Data);
     Seg.Type = Phdr.p_type;
     Seg.Flags = Phdr.p_flags;
     Seg.OriginalOffset = Phdr.p_offset + EhdrOffset;
     Seg.Offset = Phdr.p_offset + EhdrOffset;
for (Segment &Child : Obj.segments())
     setParentSegment(Child);
   setParentSegment(ElfHdr);
   setParentSegment(PrHdr);
 }
 
 template <class ELFT>
 void ELFBuilder<ELFT>::initGroupSection(GroupSection *GroupSec) {
   if (GroupSec->Align % sizeof(ELF::Elf32_Word) != 0)
-    error("invalid alignment " + Twine(GroupSec->Align) + " of group section '" +
-          GroupSec->Name + "'");
+    Reporter.fatalError(errc::invalid_argument,
+                        "invalid alignment " + Twine(GroupSec->Align) +
+                            " of group section '" + GroupSec->Name + "'");
   SectionTableRef SecTable = Obj.sections();
   if (GroupSec->Link != SHN_UNDEF) {
     auto SymTab = SecTable.template getSectionOfType<SymbolTableSection>(
         GroupSec->Link,
         "link field value '" + Twine(GroupSec->Link) + "' in section '" +
             GroupSec->Name + "' is invalid",
         "link field value '" + Twine(GroupSec->Link) + "' in section '" +
-            GroupSec->Name + "' is not a symbol table");
-    Symbol *Sym = SymTab->getSymbolByIndex(GroupSec->Info);
+            GroupSec->Name + "' is not a symbol table",
+        Reporter);
+    Symbol *Sym = SymTab->getSymbolByIndex(GroupSec->Info, Reporter);
     if (!Sym)
-      error("info field value '" + Twine(GroupSec->Info) + "' in section '" +
-            GroupSec->Name + "' is not a valid symbol index");
+      Reporter.fatalError(errc::invalid_argument,
+                          "info field value '" + Twine(GroupSec->Info) +
+                              "' in section '" + GroupSec->Name +
+                              "' is not a valid symbol index");
     GroupSec->setSymTab(SymTab);
     GroupSec->setSymbol(Sym);
   }
   if (GroupSec->Contents.size() % sizeof(ELF::Elf32_Word) ||
       GroupSec->Contents.empty())
-    error("the content of the section " + GroupSec->Name + " is malformed");
+    Reporter.fatalError(errc::invalid_argument, "the content of the section " +
+                                                    GroupSec->Name +
+                                                    " is malformed");
   const ELF::Elf32_Word *Word =
       reinterpret_cast<const ELF::Elf32_Word *>(GroupSec->Contents.data());
   const ELF::Elf32_Word *End =
       Word + GroupSec->Contents.size() / sizeof(ELF::Elf32_Word);
   GroupSec->setFlagWord(*Word++);
   for (; Word != End; ++Word) {
     uint32_t Index = support::endian::read32<ELFT::TargetEndianness>(Word);
-    GroupSec->addMember(SecTable.getSection(
-        Index, "group member index " + Twine(Index) + " in section '" +
-                   GroupSec->Name + "' is invalid"));
+    GroupSec->addMember(SecTable.getSection(Index,
+                                            "group member index " +
+                                                Twine(Index) + " in section '" +
+                                                GroupSec->Name + "' is invalid",
+                                            Reporter));
   }
 }
 
 template <class ELFT>
 void ELFBuilder<ELFT>::initSymbolTable(SymbolTableSection *SymTab) {
-  const Elf_Shdr &Shdr = *unwrapOrError(ElfFile.getSection(SymTab->Index));
-  StringRef StrTabData = unwrapOrError(ElfFile.getStringTableForSymtab(Shdr));
+  const Elf_Shdr &Shdr =
+      *unwrapOrFatalError(ElfFile.getSection(SymTab->Index), Reporter);
+  StringRef StrTabData =
+      unwrapOrFatalError(ElfFile.getStringTableForSymtab(Shdr), Reporter);
   ArrayRef<Elf_Word> ShndxData;
 
-  auto Symbols = unwrapOrError(ElfFile.symbols(&Shdr));
+  auto Symbols = unwrapOrFatalError(ElfFile.symbols(&Shdr), Reporter);
   for (const auto &Sym : Symbols) {
     SectionBase *DefSection = nullptr;
-    StringRef Name = unwrapOrError(Sym.getName(StrTabData));
+    StringRef Name = unwrapOrFatalError(Sym.getName(StrTabData), Reporter);
 
     if (Sym.st_shndx == SHN_XINDEX) {
       if (SymTab->getShndxTable() == nullptr)
-        error("symbol '" + Name +
-              "' has index SHN_XINDEX but no SHT_SYMTAB_SHNDX section exists");
+        Reporter.fatalError(errc::invalid_argument,
+                            "symbol '" + Name +
+                                "' has index SHN_XINDEX but no "
+                                "SHT_SYMTAB_SHNDX section exists");
       if (ShndxData.data() == nullptr) {
-        const Elf_Shdr &ShndxSec =
-            *unwrapOrError(ElfFile.getSection(SymTab->getShndxTable()->Index));
-        ShndxData = unwrapOrError(
-            ElfFile.template getSectionContentsAsArray<Elf_Word>(ShndxSec));
+        const Elf_Shdr &ShndxSec = *unwrapOrFatalError(
+            ElfFile.getSection(SymTab->getShndxTable()->Index), Reporter);
+        ShndxData = unwrapOrFatalError(
+            ElfFile.template getSectionContentsAsArray<Elf_Word>(ShndxSec),
+            Reporter);
         if (ShndxData.size() != Symbols.size())
-          error("symbol section index table does not have the same number of "
-                "entries as the symbol table");
+          Reporter.fatalError(
+              errc::invalid_argument,
+              "symbol section index table does not have the same number of "
       }
       Elf_Word Index = ShndxData[&Sym - Symbols.begin()];
       DefSection = Obj.sections().getSection(
           Index,
-          "symbol '" + Name + "' has invalid section index " + Twine(Index));
+          "symbol '" + Name + "' has invalid section index " + Twine(Index),
+          Reporter);
     } else if (Sym.st_shndx >= SHN_LORESERVE) {
       if (!isValidReservedSectionIndex(Sym.st_shndx, Obj.Machine)) {
-        error(
+        Reporter.fatalError(errc::invalid_argument,
                             "symbol '" + Name +
-            "' has unsupported value greater than or equal to SHN_LORESERVE: " +
+                                "' has unsupported value greater than or equal "
+                                "to SHN_LORESERVE: " +
                                 Twine(Sym.st_shndx));
       }
     } else if (Sym.st_shndx != SHN_UNDEF) {
       DefSection = Obj.sections().getSection(
-          Sym.st_shndx, "symbol '" + Name +
-                            "' is defined has invalid section index " +
-                            Twine(Sym.st_shndx));
+          Sym.st_shndx,
+          "symbol '" + Name + "' is defined has invalid section index " +
+              Twine(Sym.st_shndx),
+          Reporter);
     }
 
     SymTab->addSymbol(Name, Sym.getBinding(), Sym.getType(), DefSection,
                       Sym.getValue(), Sym.st_other, Sym.st_shndx, Sym.st_size);
   }
 }
 
 template <class ELFT>
 static void getAddend(uint64_t &ToSet, const Elf_Rel_Impl<ELFT, false> &Rel) {}
 
 template <class ELFT>
 static void getAddend(uint64_t &ToSet, const Elf_Rel_Impl<ELFT, true> &Rela) {
   ToSet = Rela.r_addend;
 }
 
 template <class T>
 static void initRelocations(RelocationSection *Relocs,
-                            SymbolTableSection *SymbolTable, T RelRange) {
+                            SymbolTableSection *SymbolTable, T RelRange,
+                            const ErrorReporter &Reporter) {
   for (const auto &Rel : RelRange) {
     Relocation ToAdd;
     ToAdd.Offset = Rel.r_offset;
     getAddend(ToAdd.Addend, Rel);
     ToAdd.Type = Rel.getType(false);
 
     if (uint32_t Sym = Rel.getSymbol(false)) {
       if (!SymbolTable)
-        error("'" + Relocs->Name +
-              "': relocation references symbol with index " + Twine(Sym) +
-              ", but there is no symbol table");
-      ToAdd.RelocSymbol = SymbolTable->getSymbolByIndex(Sym);
+        Reporter.fatalError(errc::invalid_argument,
+                            "'" + Relocs->Name +
+                                "': relocation references symbol with index " +
+                                Twine(Sym) + ", but there is no symbol table");
+      ToAdd.RelocSymbol = SymbolTable->getSymbolByIndex(Sym, Reporter);
     }
 
     Relocs->addRelocation(ToAdd);
   }
 }
 
-SectionBase *SectionTableRef::getSection(uint32_t Index, Twine ErrMsg) {
+SectionBase *SectionTableRef::getSection(uint32_t Index, Twine ErrMsg,
+                                         const ErrorReporter &Reporter) {
   if (Index == SHN_UNDEF || Index > Sections.size())
-    error(ErrMsg);
+    Reporter.fatalError(errc::invalid_argument, ErrMsg);
   return Sections[Index - 1].get();
 }
 
 template <class T>
 T *SectionTableRef::getSectionOfType(uint32_t Index, Twine IndexErrMsg,
-                                     Twine TypeErrMsg) {
-  if (T *Sec = dyn_cast<T>(getSection(Index, IndexErrMsg)))
+                                     Twine TypeErrMsg,
+                                     const ErrorReporter &Reporter) {
+  if (T *Sec = dyn_cast<T>(getSection(Index, IndexErrMsg, Reporter)))
     return Sec;
-  error(TypeErrMsg);
+  Reporter.fatalError(errc::invalid_argument, TypeErrMsg);
 }
 
 template <class ELFT>
 SectionBase &ELFBuilder<ELFT>::makeSection(const Elf_Shdr &Shdr) {
   ArrayRef<uint8_t> Data;
   switch (Shdr.sh_type) {
   case SHT_REL:
   case SHT_RELA:
     if (Shdr.sh_flags & SHF_ALLOC) {
-      Data = unwrapOrError(ElfFile.getSectionContents(Shdr));
+      Data = unwrapOrFatalError(ElfFile.getSectionContents(Shdr), Reporter);
       return Obj.addSection<DynamicRelocationSection>(Data);
     }
     return Obj.addSection<RelocationSection>();
   case SHT_STRTAB:
     // If a string table is allocated we don't want to mess with it. That would
     // mean altering the memory image. There are no special link types or
     // anything so we can just use a Section.
     if (Shdr.sh_flags & SHF_ALLOC) {
-      Data = unwrapOrError(ElfFile.getSectionContents(Shdr));
+      Data = unwrapOrFatalError(ElfFile.getSectionContents(Shdr), Reporter);
       return Obj.addSection<Section>(Data);
     }
     return Obj.addSection<StringTableSection>();
   case SHT_HASH:
   case SHT_GNU_HASH:
     // Hash tables should refer to SHT_DYNSYM which we're not going to change.
     // Because of this we don't need to mess with the hash tables either.
-    Data = unwrapOrError(ElfFile.getSectionContents(Shdr));
+    Data = unwrapOrFatalError(ElfFile.getSectionContents(Shdr), Reporter);
     return Obj.addSection<Section>(Data);
   case SHT_GROUP:
-    Data = unwrapOrError(ElfFile.getSectionContents(Shdr));
+    Data = unwrapOrFatalError(ElfFile.getSectionContents(Shdr), Reporter);
     return Obj.addSection<GroupSection>(Data);
   case SHT_DYNSYM:
-    Data = unwrapOrError(ElfFile.getSectionContents(Shdr));
+    Data = unwrapOrFatalError(ElfFile.getSectionContents(Shdr), Reporter);
     return Obj.addSection<DynamicSymbolTableSection>(Data);
   case SHT_DYNAMIC:
-    Data = unwrapOrError(ElfFile.getSectionContents(Shdr));
+    Data = unwrapOrFatalError(ElfFile.getSectionContents(Shdr), Reporter);
     return Obj.addSection<DynamicSection>(Data);
   case SHT_SYMTAB: {
     auto &SymTab = Obj.addSection<SymbolTableSection>();
     Obj.SymbolTable = &SymTab;
     return SymTab;
   }
   case SHT_SYMTAB_SHNDX: {
     auto &ShndxSection = Obj.addSection<SectionIndexSection>();
     Obj.SectionIndexTable = &ShndxSection;
     return ShndxSection;
   }
   case SHT_NOBITS:
     return Obj.addSection<Section>(Data);
   default: {
-    Data = unwrapOrError(ElfFile.getSectionContents(Shdr));
+    Data = unwrapOrFatalError(ElfFile.getSectionContents(Shdr), Reporter);
 
-    StringRef Name = unwrapOrError(ElfFile.getSectionName(Shdr));
+    StringRef Name = unwrapOrFatalError(ElfFile.getSectionName(Shdr), Reporter);
     if (Name.startswith(".zdebug") || (Shdr.sh_flags & ELF::SHF_COMPRESSED)) {
       uint64_t DecompressedSize, DecompressedAlign;
       std::tie(DecompressedSize, DecompressedAlign) =
           getDecompressedSizeAndAlignment<ELFT>(Data);
       return Obj.addSection<CompressedSection>(Data, DecompressedSize,
                                                DecompressedAlign);
     }
 
     return Obj.addSection<Section>(Data);
   }
   }
 }
 
 template <class ELFT> void ELFBuilder<ELFT>::readSectionHeaders() {
   uint32_t Index = 0;
-  for (const auto &Shdr : unwrapOrError(ElfFile.sections())) {
+  for (const auto &Shdr : unwrapOrFatalError(ElfFile.sections(), Reporter)) {
     if (Index == 0) {
       ++Index;
       continue;
     }
     auto &Sec = makeSection(Shdr);
-    Sec.Name = std::string(unwrapOrError(ElfFile.getSectionName(Shdr)));
+    Sec.Name =
+        std::string(unwrapOrFatalError(ElfFile.getSectionName(Shdr), Reporter));
     Sec.Type = Sec.OriginalType = Shdr.sh_type;
     Sec.Flags = Sec.OriginalFlags = Shdr.sh_flags;
     Sec.Addr = Shdr.sh_addr;
     Sec.Offset = Shdr.sh_offset;
     Sec.OriginalOffset = Shdr.sh_offset;
     Sec.Size = Shdr.sh_size;
     Sec.Link = Shdr.sh_link;
     Sec.Info = Shdr.sh_info;
     Sec.Align = Shdr.sh_addralign;
     Sec.EntrySize = Shdr.sh_entsize;
     Sec.Index = Index++;
     Sec.OriginalData =
         ArrayRef<uint8_t>(ElfFile.base() + Shdr.sh_offset,
                           (Shdr.sh_type == SHT_NOBITS) ? 0 : Shdr.sh_size);
   }
 }
 
 template <class ELFT> void ELFBuilder<ELFT>::readSections(bool EnsureSymtab) {
   uint32_t ShstrIndex = ElfFile.getHeader().e_shstrndx;
   if (ShstrIndex == SHN_XINDEX)
-    ShstrIndex = unwrapOrError(ElfFile.getSection(0))->sh_link;
+    ShstrIndex = unwrapOrFatalError(ElfFile.getSection(0), Reporter)->sh_link;
 
   if (ShstrIndex == SHN_UNDEF)
     Obj.HadShdrs = false;
   else
     Obj.SectionNames =
         Obj.sections().template getSectionOfType<StringTableSection>(
             ShstrIndex,
             "e_shstrndx field value " + Twine(ShstrIndex) + " in elf header " +
                 " is invalid",
             "e_shstrndx field value " + Twine(ShstrIndex) + " in elf header " +
-                " does not reference a string table");
+                " does not reference a string table",
+            Reporter);
 
   // If a section index table exists we'll need to initialize it before we
   // initialize the symbol table because the symbol table might need to
   // reference it.
   if (Obj.SectionIndexTable)
-    Obj.SectionIndexTable->initialize(Obj.sections());
+    Obj.SectionIndexTable->initialize(Obj.sections(), Reporter);
 
   // Now that all of the sections have been added we can fill out some extra
   // details about symbol tables. We need the symbol table filled out before
   // any relocations.
   if (Obj.SymbolTable) {
-    Obj.SymbolTable->initialize(Obj.sections());
+    Obj.SymbolTable->initialize(Obj.sections(), Reporter);
     initSymbolTable(Obj.SymbolTable);
   } else if (EnsureSymtab) {
     Obj.addNewSymbolTable();
   }
 
   // Now that all sections and symbols have been added we can add
   // relocations that reference symbols and set the link and info fields for
   // relocation sections.
   for (auto &Sec : Obj.sections()) {
     if (&Sec == Obj.SymbolTable)
       continue;
-    Sec.initialize(Obj.sections());
+    Sec.initialize(Obj.sections(), Reporter);
     if (auto RelSec = dyn_cast<RelocationSection>(&Sec)) {
-      auto Shdr = unwrapOrError(ElfFile.sections()).begin() + RelSec->Index;
+      auto Shdr = unwrapOrFatalError(ElfFile.sections(), Reporter).begin() +
+                  RelSec->Index;
       if (RelSec->Type == SHT_REL)
         initRelocations(RelSec, Obj.SymbolTable,
-                        unwrapOrError(ElfFile.rels(*Shdr)));
+                        unwrapOrFatalError(ElfFile.rels(*Shdr), Reporter),
+                        Reporter);
       else
         initRelocations(RelSec, Obj.SymbolTable,
-                        unwrapOrError(ElfFile.relas(*Shdr)));
+                        unwrapOrFatalError(ElfFile.relas(*Shdr), Reporter),
+                        Reporter);
     } else if (auto GroupSec = dyn_cast<GroupSection>(&Sec)) {
       initGroupSection(GroupSec);
     }
   }
 }
 
 template <class ELFT> void ELFBuilder<ELFT>::build(bool EnsureSymtab) {
   readSectionHeaders();
   findEhdrOffset();
 
   // The ELFFile whose ELF headers and program headers are copied into the
   // output file. Normally the same as ElfFile, but if we're extracting a
   // loadable partition it will point to the partition's headers.
-  ELFFile<ELFT> HeadersFile = unwrapOrError(ELFFile<ELFT>::create(toStringRef(
-      {ElfFile.base() + EhdrOffset, ElfFile.getBufSize() - EhdrOffset})));
+  ELFFile<ELFT> HeadersFile = unwrapOrFatalError(
+      ELFFile<ELFT>::create(toStringRef(
+          {ElfFile.base() + EhdrOffset, ElfFile.getBufSize() - EhdrOffset})),
+      Reporter);
 
   auto &Ehdr = HeadersFile.getHeader();
   Obj.OSABI = Ehdr.e_ident[EI_OSABI];
   Obj.ABIVersion = Ehdr.e_ident[EI_ABIVERSION];
   Obj.Type = Ehdr.e_type;
   Obj.Machine = Ehdr.e_machine;
   Obj.Version = Ehdr.e_version;
   Obj.Entry = Ehdr.e_entry;
   Obj.Flags = Ehdr.e_flags;
 
   readSections(EnsureSymtab);
   readProgramHeaders(HeadersFile);
 }
 
 Writer::~Writer() {}
 
 Reader::~Reader() {}
 
 std::unique_ptr<Object> BinaryReader::create(bool /*EnsureSymtab*/) const {
-  return BinaryELFBuilder(MemBuf, NewSymbolVisibility).build();
+  return BinaryELFBuilder(MemBuf, NewSymbolVisibility, Reporter).build();
 }
 
 Expected<std::vector<IHexRecord>> IHexReader::parse() const {
   SmallVector<StringRef, 16> Lines;
   std::vector<IHexRecord> Records;
   bool HasSections = false;
 
   MemBuf->getBuffer().split(Lines, '\n');
Expected<std::vector<IHexRecord>> IHexReader::parse() const {
   }
   if (!HasSections)
     return parseError(-1U, "no sections");
 
   return std::move(Records);
 }
 
 std::unique_ptr<Object> IHexReader::create(bool /*EnsureSymtab*/) const {
-  std::vector<IHexRecord> Records = unwrapOrError(parse());
-  return IHexELFBuilder(Records).build();
+  std::vector<IHexRecord> Records = unwrapOrFatalError(parse(), Reporter);
+  return IHexELFBuilder(Records, Reporter).build();
 }
 
 std::unique_ptr<Object> ELFReader::create(bool EnsureSymtab) const {
-  auto Obj = std::make_unique<Object>();
+  auto Obj = std::make_unique<Object>(Reporter);
   if (auto *O = dyn_cast<ELFObjectFile<ELF32LE>>(Bin)) {
-    ELFBuilder<ELF32LE> Builder(*O, *Obj, ExtractPartition);
+    ELFBuilder<ELF32LE> Builder(*O, *Obj, ExtractPartition, Reporter);
     Builder.build(EnsureSymtab);
     return Obj;
   } else if (auto *O = dyn_cast<ELFObjectFile<ELF64LE>>(Bin)) {
-    ELFBuilder<ELF64LE> Builder(*O, *Obj, ExtractPartition);
+    ELFBuilder<ELF64LE> Builder(*O, *Obj, ExtractPartition, Reporter);
     Builder.build(EnsureSymtab);
     return Obj;
   } else if (auto *O = dyn_cast<ELFObjectFile<ELF32BE>>(Bin)) {
-    ELFBuilder<ELF32BE> Builder(*O, *Obj, ExtractPartition);
+    ELFBuilder<ELF32BE> Builder(*O, *Obj, ExtractPartition, Reporter);
     Builder.build(EnsureSymtab);
     return Obj;
   } else if (auto *O = dyn_cast<ELFObjectFile<ELF64BE>>(Bin)) {
-    ELFBuilder<ELF64BE> Builder(*O, *Obj, ExtractPartition);
+    ELFBuilder<ELF64BE> Builder(*O, *Obj, ExtractPartition, Reporter);
     Builder.build(EnsureSymtab);
     return Obj;
   }
-  error("invalid file type");
+  Reporter.fatalError(errc::invalid_argument, "invalid file type");
 }
 
 template <class ELFT> void ELFWriter<ELFT>::writeEhdr() {
   Elf_Ehdr &Ehdr = *reinterpret_cast<Elf_Ehdr *>(Buf.getBufferStart());
   std::fill(Ehdr.e_ident, Ehdr.e_ident + 16, 0);
   Ehdr.e_ident[EI_MAG0] = 0x7f;
   Ehdr.e_ident[EI_MAG1] = 'E';
   Ehdr.e_ident[EI_MAG2] = 'L';
for (auto &Sec : Obj.removedSections()) {
     uint64_t Offset =
         Sec.OriginalOffset - Parent->OriginalOffset + Parent->Offset;
     std::memset(Buf.getBufferStart() + Offset, 0, Sec.Size);
   }
 }
 
 template <class ELFT>
 ELFWriter<ELFT>::ELFWriter(Object &Obj, Buffer &Buf, bool WSH,
-                           bool OnlyKeepDebug)
-    : Writer(Obj, Buf), WriteSectionHeaders(WSH && Obj.HadShdrs),
+                           bool OnlyKeepDebug, const ErrorReporter &Reporter)
+    : Writer(Obj, Buf, Reporter), WriteSectionHeaders(WSH && Obj.HadShdrs),
       OnlyKeepDebug(OnlyKeepDebug) {}
 
 Error Object::removeSections(bool AllowBrokenLinks,
     std::function<bool(const SectionBase &)> ToRemove) {
 
   auto Iter = std::stable_partition(
       std::begin(Sections), std::end(Sections), [=](const SecPtr &Sec) {
         if (ToRemove(*Sec))
for (SectionBase &Sec : sections()) {
     }
   }
   if (!StrTab)
     StrTab = &addSection<StringTableSection>();
 
   SymbolTableSection &SymTab = addSection<SymbolTableSection>();
   SymTab.Name = ".symtab";
   SymTab.Link = StrTab->Index;
-  SymTab.initialize(sections());
+  SymTab.initialize(sections(), Reporter);
   SymTab.addSymbol("", 0, 0, nullptr, 0, 0, 0, 0);
 
   SymbolTable = &SymTab;
 }
 
 void Object::sortSections() {
   // Use stable_sort to maintain the original ordering as closely as possible.
   llvm::stable_sort(Sections, [](const SecPtr &A, const SecPtr &B) {
for (SectionBase &Sec : Obj.sections()) {
     Offset += sizeof(Elf_Shdr);
     if (WriteSectionHeaders)
       Sec.NameIndex = Obj.SectionNames->findIndex(Sec.Name);
     Sec.finalize();
   }
 
   if (Error E = Buf.allocate(totalSize()))
     return E;
-  SecWriter = std::make_unique<ELFSectionWriter<ELFT>>(Buf);
+  SecWriter = std::make_unique<ELFSectionWriter<ELFT>>(Buf, Reporter);
   return Error::success();
 }
 
 Error BinaryWriter::write() {
   for (const SectionBase &Sec : Obj.allocSections())
     Sec.accept(*SecWriter);
   return Buf.commit();
 }
Error BinaryWriter::finalize() {
   for (SectionBase &Sec : Obj.allocSections())
     if (Sec.Type != SHT_NOBITS && Sec.Size > 0) {
       Sec.Offset = Sec.Addr - MinAddr;
       TotalSize = std::max(TotalSize, Sec.Offset + Sec.Size);
     }
 
   if (Error E = Buf.allocate(TotalSize))
     return E;
-  SecWriter = std::make_unique<BinarySectionWriter>(Buf);
+  SecWriter = std::make_unique<BinarySectionWriter>(Buf, Reporter);
   return Error::success();
 }
 
 bool IHexWriter::SectionCompare::operator()(const SectionBase *Lhs,
                                             const SectionBase *Rhs) const {
   return (sectionPhysicalAddr(Lhs) & 0xFFFFFFFFU) <
          (sectionPhysicalAddr(Rhs) & 0xFFFFFFFFU);
 }

 
 uint64_t IHexWriter::writeEndOfFileRecord(uint8_t *Buf) {
   IHexLineData HexData = IHexRecord::getLine(IHexRecord::EndOfFile, 0, {});
   memcpy(Buf, HexData.data(), HexData.size());
   return HexData.size();
 }
 
 Error IHexWriter::write() {
-  IHexSectionWriter Writer(Buf);
+  IHexSectionWriter Writer(Buf, Reporter);
   // Write sections.
   for (const SectionBase *Sec : Sections)
     Sec->accept(Writer);
 
   uint64_t Offset = Writer.getBufferOffset();
   // Write entry point address.
   Offset += writeEntryPointRecord(Buf.getBufferStart() + Offset);
   // Write EOF.
Error IHexWriter::finalize() {
 
   for (const SectionBase &Sec : Obj.sections())
     if (ShouldWrite(Sec) && (!UseSegments || IsInPtLoad(Sec))) {
       if (Error E = checkSection(Sec))
         return E;
       Sections.insert(&Sec);
     }
 
-  IHexSectionWriterBase LengthCalc(Buf);
+  IHexSectionWriterBase LengthCalc(Buf, Reporter);
   for (const SectionBase *Sec : Sections)
     Sec->accept(LengthCalc);
 
   // We need space to write section records + StartAddress record
   // (if start adress is not zero) + EndOfFile record.
   TotalSize = LengthCalc.getBufferOffset() +
               (Obj.Entry ? IHexRecord::getLineLength(4) : 0) +
               IHexRecord::getLineLength(0);

llvm/tools/llvm-objcopy/Error.h

+//===- Error.h --------------------------------------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TOOLS_LLVM_OBJCOPY_ERROR_H
+#define LLVM_TOOLS_LLVM_OBJCOPY_ERROR_H
+
+#include "llvm/ADT/Twine.h"
+#include "llvm/Support/Compiler.h"
+#include "llvm/Support/Errc.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/WithColor.h"
+#include "llvm/Support/raw_ostream.h"
+#include <string>
+
+namespace llvm {
+namespace objcopy {
+
+/// ErrorReporter class reports error messages(errors/fatal errors/warnings)
+/// to llvm::errs() output stream.
+class ErrorReporter {
+public:
+  virtual ~ErrorReporter() {}
+
+  virtual void error(std::error_code EC, Twine Message,
+                     StringRef Context = "") const {
+    RecoverableErrorHandler(createStringError(EC, Message), Context);
+  }
+  virtual void error(Error E, StringRef Context = "") const {
+    RecoverableErrorHandler(std::move(E), Context);
+  }
+
+  virtual LLVM_ATTRIBUTE_NORETURN void
+  fatalError(std::error_code EC, Twine Message, StringRef Context = "") const {
+    UnrecoverableErrorHandler(createStringError(EC, Message), Context);
+    exit(1);
+  }
+  virtual LLVM_ATTRIBUTE_NORETURN void
+  fatalError(Error E, StringRef Context = "") const {
+    UnrecoverableErrorHandler(std::move(E), Context);
+    exit(1);
+  }
+
+  virtual void warning(std::error_code EC, Twine Message,
+                       StringRef Context = "") const {
+    WarningHandler(createStringError(EC, Message), Context);
+  }
+  virtual void warning(Error E, StringRef Context = "") const {
+    WarningHandler(std::move(E), Context);
+  }
+
+  virtual void setGlobalContext(StringRef GlobalContext) {
+    this->GlobalContext = GlobalContext.str();
+  }
+
+  virtual void setRecoverableErrorHandler(
+      std::function<void(Error, StringRef)> RecoverableErrorHandler) {
+    this->RecoverableErrorHandler = RecoverableErrorHandler;
+  }
+
+  virtual void setUnrecoverableErrorHandler(
+      std::function<void(Error, StringRef)> UnrecoverableErrorHandler) {
+    this->UnrecoverableErrorHandler = UnrecoverableErrorHandler;
+  }
+
+  virtual void
+  setWarningHandler(std::function<void(Error, StringRef)> WarningHandler) {
+    this->WarningHandler = WarningHandler;
+  }
+
+protected:
+  // Name of global context(usually binary/utility name).
+  std::string GlobalContext;
+
+  // Handler for recoverable errors.
+  std::function<void(Error, StringRef)> RecoverableErrorHandler =
+      [&](Error Err, StringRef Context) {
+        defaultHandlerImpl(std::move(Err), Context, true);
+      };
+
+  // Handler for unrecoverable errors.
+  std::function<void(Error, StringRef)> UnrecoverableErrorHandler =
+      [&](Error Err, StringRef Context) {
+        defaultHandlerImpl(std::move(Err), Context, true);
+      };
+
+  // Handler for warnings.
+  std::function<void(Error, StringRef)> WarningHandler =
+      [&](Error Err, StringRef Context) {
+        defaultHandlerImpl(std::move(Err), Context, false);
+      };
+
+  void defaultHandlerImpl(Error Err, StringRef Context, bool IsError) {
+    if (!GlobalContext.empty())
+      errs() << GlobalContext << ": ";
+    raw_ostream &Out = IsError ? WithColor::error() : WithColor::warning();
+    handleAllErrors(std::move(Err), [&](ErrorInfoBase &Info) {
+      if (!Context.empty())
+        Out << "'" << Context << "': ";
+
+      Out << Info.message() << '\n';
+    });
+  }
+};
+
+template <class T>
+T unwrapOrFatalError(Expected<T> EO, const ErrorReporter &Reporter) {
+  if (EO)
+    return *EO;
+  Reporter.fatalError(EO.takeError());
+}
+
+} // end namespace objcopy
+} // end namespace llvm
+
+#endif // LLVM_TOOLS_LLVM_OBJCOPY_ERROR_H

llvm/tools/llvm-objcopy/MachO/MachOObjcopy.cpp

static Error handleArgs(const CopyConfig &Config, Object &Obj) {
   if (Error E = processLoadCommands(Config, Obj))
     return E;
 
   return Error::success();
 }
 
 Error executeObjcopyOnBinary(const CopyConfig &Config,
                              object::MachOObjectFile &In, Buffer &Out) {
-  MachOReader Reader(In);
+  MachOReader Reader(In, Config.Reporter);
   std::unique_ptr<Object> O = Reader.create();
   if (!O)
     return createFileError(
         Config.InputFilename,
         createStringError(object_error::parse_failed,
                           "unable to deserialize MachO object"));
 
   if (Error E = handleArgs(Config, *O))

llvm/tools/llvm-objcopy/MachO/MachOReader.h

 //===- MachOReader.h --------------------------------------------*- C++ -*-===//
 //
 // 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 "Error.h"
 #include "MachOObjcopy.h"
 #include "Object.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/Object/MachO.h"
 #include <memory>
 
 namespace llvm {
 namespace objcopy {
 namespace macho {
 
 // The hierarchy of readers is responsible for parsing different inputs:
 // raw binaries and regular MachO object files.
 class Reader {
 public:
+  Reader(const ErrorReporter &Reporter) : Reporter(Reporter) {}
   virtual ~Reader(){};
   virtual std::unique_ptr<Object> create() const = 0;
+
+protected:
+  const ErrorReporter &Reporter;
 };
 
 class MachOReader : public Reader {
   const object::MachOObjectFile &MachOObj;
 
   void readHeader(Object &O) const;
   void readLoadCommands(Object &O) const;
   void readSymbolTable(Object &O) const;
   void setSymbolInRelocationInfo(Object &O) const;
   void readRebaseInfo(Object &O) const;
   void readBindInfo(Object &O) const;
   void readWeakBindInfo(Object &O) const;
   void readLazyBindInfo(Object &O) const;
   void readExportInfo(Object &O) const;
   void readLinkData(Object &O, Optional<size_t> LCIndex, LinkData &LD) const;
   void readCodeSignature(Object &O) const;
   void readDataInCodeData(Object &O) const;
   void readFunctionStartsData(Object &O) const;
   void readIndirectSymbolTable(Object &O) const;
   void readSwiftVersion(Object &O) const;
 
 public:
-  explicit MachOReader(const object::MachOObjectFile &Obj) : MachOObj(Obj) {}
+  explicit MachOReader(const object::MachOObjectFile &Obj,
+                       const ErrorReporter &Reporter)
+      : Reader(Reporter), MachOObj(Obj) {}
 
   std::unique_ptr<Object> create() const override;
 };
 
 } // end namespace macho
 } // end namespace objcopy
 } // end namespace llvm

llvm/tools/llvm-objcopy/MachO/MachOReader.cpp

template <> Section constructSection(MachO::section_64 Sec, uint32_t Index) {
   return S;
 }
 
 // TODO: get rid of reportError and make MachOReader return Expected<> instead.
 template <typename SectionType, typename SegmentType>
 std::vector<std::unique_ptr<Section>>
 extractSections(const object::MachOObjectFile::LoadCommandInfo &LoadCmd,
                 const object::MachOObjectFile &MachOObj,
-                uint32_t &NextSectionIndex) {
+                uint32_t &NextSectionIndex, const ErrorReporter &Reporter) {
   auto End = LoadCmd.Ptr + LoadCmd.C.cmdsize;
   const SectionType *Curr =
       reinterpret_cast<const SectionType *>(LoadCmd.Ptr + sizeof(SegmentType));
   std::vector<std::unique_ptr<Section>> Sections;
   for (; reinterpret_cast<const void *>(Curr) < End; Curr++) {
     if (MachOObj.isLittleEndian() != sys::IsLittleEndianHost) {
       SectionType Sec;
       memcpy((void *)&Sec, Curr, sizeof(SectionType));
       MachO::swapStruct(Sec);
       Sections.push_back(
           std::make_unique<Section>(constructSection(Sec, NextSectionIndex)));
     } else {
       Sections.push_back(
           std::make_unique<Section>(constructSection(*Curr, NextSectionIndex)));
     }
 
     Section &S = *Sections.back();
 
     Expected<object::SectionRef> SecRef =
         MachOObj.getSection(NextSectionIndex++);
     if (!SecRef)
-      reportError(MachOObj.getFileName(), SecRef.takeError());
+      Reporter.fatalError(SecRef.takeError(), MachOObj.getFileName());
 
     if (Expected<ArrayRef<uint8_t>> E =
             MachOObj.getSectionContents(SecRef->getRawDataRefImpl()))
       S.Content =
           StringRef(reinterpret_cast<const char *>(E->data()), E->size());
     else
-      reportError(MachOObj.getFileName(), E.takeError());
+      Reporter.fatalError(E.takeError(), MachOObj.getFileName());
 
     S.Relocations.reserve(S.NReloc);
     for (auto RI = MachOObj.section_rel_begin(SecRef->getRawDataRefImpl()),
               RE = MachOObj.section_rel_end(SecRef->getRawDataRefImpl());
          RI != RE; ++RI) {
       RelocationInfo R;
       R.Symbol = nullptr; // We'll fill this field later.
       R.Info = MachOObj.getRelocation(RI->getRawDataRefImpl());
void MachOReader::readLoadCommands(Object &O) const {
   for (auto LoadCmd : MachOObj.load_commands()) {
     LoadCommand LC;
     switch (LoadCmd.C.cmd) {
     case MachO::LC_CODE_SIGNATURE:
       O.CodeSignatureCommandIndex = O.LoadCommands.size();
       break;
     case MachO::LC_SEGMENT:
       LC.Sections = extractSections<MachO::section, MachO::segment_command>(
-          LoadCmd, MachOObj, NextSectionIndex);
+          LoadCmd, MachOObj, NextSectionIndex, Reporter);
       break;
     case MachO::LC_SEGMENT_64:
       LC.Sections =
           extractSections<MachO::section_64, MachO::segment_command_64>(
-              LoadCmd, MachOObj, NextSectionIndex);
+              LoadCmd, MachOObj, NextSectionIndex, Reporter);
       break;
     case MachO::LC_SYMTAB:
       O.SymTabCommandIndex = O.LoadCommands.size();
       break;
     case MachO::LC_DYSYMTAB:
       O.DySymTabCommandIndex = O.LoadCommands.size();
       break;
     case MachO::LC_DYLD_INFO:

llvm/tools/llvm-objcopy/llvm-objcopy.h

 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/raw_ostream.h"
 #include <string>
 
 namespace llvm {
 namespace objcopy {
 
-LLVM_ATTRIBUTE_NORETURN extern void error(Twine Message);
-LLVM_ATTRIBUTE_NORETURN extern void error(Error E);
-LLVM_ATTRIBUTE_NORETURN extern void reportError(StringRef File, Error E);
-LLVM_ATTRIBUTE_NORETURN extern void reportError(StringRef File,
-                                                std::error_code EC);
-
-// This is taken from llvm-readobj.
-// [see here](llvm/tools/llvm-readobj/llvm-readobj.h:38)
-template <class T> T unwrapOrError(Expected<T> EO) {
-  if (EO)
-    return *EO;
-  std::string Buf;
-  raw_string_ostream OS(Buf);
-  logAllUnhandledErrors(EO.takeError(), OS);
-  OS.flush();
-  error(Buf);
-}
-
 } // end namespace objcopy
 } // end namespace llvm
 
 #endif // LLVM_TOOLS_OBJCOPY_OBJCOPY_H

llvm/tools/llvm-objcopy/llvm-objcopy.cpp

 #include <system_error>
 #include <utility>
 
 namespace llvm {
 namespace objcopy {
 
 // The name this program was invoked as.
 StringRef ToolName;
 
-LLVM_ATTRIBUTE_NORETURN void error(Twine Message) {
-  WithColor::error(errs(), ToolName) << Message << "\n";
-  exit(1);
-}
-
-LLVM_ATTRIBUTE_NORETURN void error(Error E) {
-  assert(E);
-  std::string Buf;
-  raw_string_ostream OS(Buf);
-  logAllUnhandledErrors(std::move(E), OS);
-  OS.flush();
-  WithColor::error(errs(), ToolName) << Buf;
-  exit(1);
-}
-
-LLVM_ATTRIBUTE_NORETURN void reportError(StringRef File, std::error_code EC) {
-  assert(EC);
-  error(createFileError(File, EC));
-}
-
-LLVM_ATTRIBUTE_NORETURN void reportError(StringRef File, Error E) {
-  assert(E);
-  std::string Buf;
-  raw_string_ostream OS(Buf);
-  logAllUnhandledErrors(std::move(E), OS);
-  OS.flush();
-  WithColor::error(errs(), ToolName) << "'" << File << "': " << Buf;
-  exit(1);
-}
-
-ErrorSuccess reportWarning(Error E) {
-  assert(E);
-  WithColor::warning(errs(), ToolName) << toString(std::move(E)) << '\n';
-  return Error::success();
-}
+ErrorReporter Reporter;
 
 } // end namespace objcopy
 } // end namespace llvm
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::objcopy;
 

 
 enum class ToolType { Objcopy, Strip, InstallNameTool, BitcodeStrip };
 
 } // anonymous namespace
 
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
   ToolName = argv[0];
+  Reporter.setGlobalContext(ToolName);
 
   StringRef Stem = sys::path::stem(ToolName);
   auto Is = [=](StringRef Tool) {
     // We need to recognize the following filenames:
     //
     // llvm-objcopy -> objcopy
     // strip-10.exe -> strip
     // powerpc64-unknown-freebsd13-objcopy -> objcopy
cl::ExpandResponseFiles(Saver,
                           Triple(sys::getProcessTriple()).isOSWindows()
                               ? cl::TokenizeWindowsCommandLine
                               : cl::TokenizeGNUCommandLine,
                           NewArgv);
 
   auto Args = makeArrayRef(NewArgv).drop_front();
   Expected<DriverConfig> DriverConfig =
       (Tool == ToolType::Strip)
-          ? parseStripOptions(Args, reportWarning)
+          ? parseStripOptions(Args, Reporter)
           : ((Tool == ToolType::InstallNameTool)
-                 ? parseInstallNameToolOptions(Args)
+                 ? parseInstallNameToolOptions(Args, Reporter)
                  : ((Tool == ToolType::BitcodeStrip)
-                        ? parseBitcodeStripOptions(Args)
-                        : parseObjcopyOptions(Args, reportWarning)));
+                        ? parseBitcodeStripOptions(Args, Reporter)
+                        : parseObjcopyOptions(Args, Reporter)));
   if (!DriverConfig) {
     logAllUnhandledErrors(DriverConfig.takeError(),
                           WithColor::error(errs(), ToolName));
     return 1;
   }
   for (CopyConfig &CopyConfig : DriverConfig->CopyConfigs) {
     if (Error E = executeObjcopy(CopyConfig)) {
       logAllUnhandledErrors(std::move(E), WithColor::error(errs(), ToolName));
       return 1;
     }
   }
 
   return 0;
 }