[llvm-objdump] - Cleanup the error reporting.

[grimar]

Summary

The error reporting function are not consistent.

Before this change:

• They had inconsistent naming (e.g. 'error' vs 'report_error').
• Some of them reported the object name, others - dont.
• Some of them accepted the case when there was no error. (i.e. error code or Error had a success value).

This patch tries to cleanup it a bit.

It also renames report_error -> reportError, report_warning -> reportWarning
and removes a full stop from messages.

[grimar]

tools/llvm-objdump/llvm-objdump.h

130

btw, to be consistent, this should be void report_error(Twine Message, StringRef File)
But I'd like to do this in a separate NFC commit.

[grimar]

• Rebased on top.

[MaskRay]

tools/llvm-objdump/llvm-objdump.cpp

381

Keeping a separate LLVM_ATTRIBUTE_NORETURN void report_error(Twine Message); overload for the error message without a filename might be clearer. What do you think?

447

/*FileName=*/""

See above. Keeping a separate LLVM_ATTRIBUTE_NORETURN void report_error(Twine Message); might be better.

450

- static const Target *getTarget(const ObjectFile *Obj = nullptr) {
+ static const Target *getTarget(const ObjectFile *Obj) {

Nice!

2220

/*FileName=*/"" is probably more common. (If you add a space, clang-format will delete it for you.)

See above. Keeping a separate LLVM_ATTRIBUTE_NORETURN void report_error(Twine Message); might be better.

[grimar]

tools/llvm-objdump/llvm-objdump.cpp

381

I had to add this code to report_error and report_warn because of 2 users:

report_warn("section '" + S +
                "' mentioned in a -j/--section option, but not "
                "found in any input file",
            "" /*FileName*/);

and

report_error("" /*FileName*/, "start address should be less than stop address");

I.e. these are kind of exceptions, as others calls always have FileName.

What I afraid here is that people might want to continue using the void report_error(Twine Message)
everywhere if we have one. I am not sure what is better. Lets see what others think may be.

May be we should print something like the following for these two ?

warn: -j/--section: section XXX mentioned, but not found in any input file

error: --start-address/--stop-address: start address should be less than stop address

Then we do not need to have any code for an empty file name.

[jhenderson]

tools/llvm-objdump/llvm-objdump.cpp

373

I'd be more inclined to remove the full stop in the error messages than add it to the warnings. I don't believe we usually add full stops to diagnostic messages.

381

I like the idea of using the switch name as the "file name", but a couple of other options are:

1. Use "<cmdline>" or similar as the file name.
2. Call the no-filename overload reportCmdLineError or similar.

1576–1577

I'm not entirely convinced that a filename here makes sense?

tools/llvm-objdump/llvm-objdump.h

138

report_warn -> report_warning (or even reportWarning to conform to LLVM style).

[grimar]

tools/llvm-objdump/llvm-objdump.cpp

381

I like the idea of reportCmdLineError. I think it is almost the same as having report_error(Twine Message), but
kills my consern about misusing the error reporting API. I am going to use it.

[grimar]

• Address review comments.

tools/llvm-objdump/llvm-objdump.cpp

373

Ok, I wasn't sure here. Removed the full stop.

1576–1577

Well. applyTargetSpecificCLOption is not the code I am familar with, but seems it
has different implementations for ARMInstPrinter and a generic case which is:

/// Customize the printer according to a command line option.
/// @return true if the option is recognized and applied.
virtual bool applyTargetSpecificCLOption(StringRef Opt) { return false; }

What makes me think that for the different objects we might have the different result.
(e.g. when we have objects of different types in archive. It's a corner case probably, but seems a valid one?).

tools/llvm-objdump/llvm-objdump.h

138

Let me stick with report_warning in this patch. (To be a bit more consistent with report_error for now).

[grimar]

• Cosmetic change.

[grimar]

I'll recheck it.

[grimar]

Ready for review.

[MaskRay]

We probably should do reportWarning to conform to LLVM's coding style since it is a new function.

The description should mention that full stops are now deleted from the messages.

[rupprecht]

+1 to changing report_error->reportError, same for reportWarning. I suppose it can be a followup NFC patch since it's technically consistent with the existing code. LGTM to the rest.

[grimar]

Ok. I wanted to rename in a followup, but it is not a problem to do now.

Changes:

• report_error -> reportError
• report_warning -> reportWarning

[jhenderson]

tools/llvm-objdump/llvm-objdump.cpp

422

LLVM_ATTRIBUTE_NORETURN?

[grimar]

tools/llvm-objdump/llvm-objdump.cpp

422

Seems - yes. Is anything else needed to be fixed or will you be OK if I land this patch with this fix?

[jhenderson]

LGTM, with my suggestion.

test/Object/macho-invalid.test

 
 RUN: not llvm-objdump --macho --private-headers -arch all %p/Inputs/macho-universal-archive-bad2.x86_64.i386 2>&1 | FileCheck -check-prefix INCOMPLETE-SEGMENT-LOADC-FAT-ARCHIVE %s
 INCOMPLETE-SEGMENT-LOADC-FAT-ARCHIVE: macho-universal-archive-bad2.x86_64.i386(macho64-invalid-incomplete-segment-load-command) (for architecture x86_64): truncated or malformed object (load commands extend past the end of the file)
 
 RUN: not llvm-objdump --macho --universal-headers %p/Inputs/macho-invalid-fat 2>&1 | FileCheck -check-prefix INVALID-FAT %s
 INVALID-FAT: truncated or malformed fat file (fat_arch_64 structs would extend past the end of the file)
 
 RUN: not llvm-objdump --macho --private-headers -arch all %p/Inputs/macho-invalid-fat.obj.elf-x86_64 2>&1 | FileCheck -check-prefix INVALID-FAT-ELF %s
-INVALID-FAT-ELF: Mach-O universal file: {{.*}}/macho-invalid-fat.obj.elf-x86_64 for architecture x86_64 is not a Mach-O file or an archive file
+INVALID-FAT-ELF: error: '{{.*}}/macho-invalid-fat.obj.elf-x86_64': Mach-O universal file for architecture x86_64 is not a Mach-O file or an archive file.
 
 RUN: not llvm-objdump --macho --private-headers %p/Inputs/macho-invalid-segment-fileoff 2>&1 | FileCheck -check-prefix INVALID-SEGMENT-FILEOFF %s
 INVALID-SEGMENT-FILEOFF: macho-invalid-segment-fileoff': truncated or malformed object (load command 0 fileoff field in LC_SEGMENT extends past the end of the file)
 
 RUN: not llvm-nm %p/Inputs/macho-invalid-segment-fileoff 2>&1 | FileCheck -check-prefix INVALID-SEGMENT-FILEOFF-NM %s
 INVALID-SEGMENT-FILEOFF-NM: macho-invalid-segment-fileoff truncated or malformed object (load command 0 fileoff field in LC_SEGMENT extends past the end of the file)
 
 RUN: not llvm-size %p/Inputs/macho-invalid-segment-fileoff 2>&1 | FileCheck -check-prefix INVALID-SEGMENT-FILEOFF-SIZE %s

test/tools/llvm-objdump/X86/disassemble-functions-mangling.test

 # RUN: llvm-objdump -C --disassemble-functions='foo()' %t.o | FileCheck %s --check-prefix=DEMANGLED
 # RUN: llvm-objdump -C --disassemble-functions='_Z3foov' %t.o 2>&1 \
 # RUN:   | FileCheck %s --check-prefix=DEMANGLED-MISS
 # RUN: llvm-objdump -C --disassemble-functions='i,f' %t.o | FileCheck %s --check-prefix=NOMANGLE
 # RUN: llvm-objdump -C --disassemble-functions='std::allocator<wchar_t>::allocator()' %t.o 2>&1 \
 # RUN:   | FileCheck %s --check-prefix=DEMANGLED-MULTI
 
 # MANGLED: _Z3foov:
-# MANGLED-MISS: warning: failed to disassemble missing function foo
+# MANGLED-MISS: warning: '{{.*}}': failed to disassemble missing function foo
 
 # DEMANGLED: foo():
-# DEMANGLED-MISS: warning: failed to disassemble missing function _Z3foov
+# DEMANGLED-MISS: warning: '{{.*}}': failed to disassemble missing function _Z3foov
 
 # NOMANGLE: i:
 # NOMANGLE: f:
 
 # DEMANGLED-MULTI: std::allocator<wchar_t>::allocator():
 # DEMANGLED-MULTI: std::allocator<wchar_t>::allocator():
 
 --- !ELF

test/tools/llvm-objdump/X86/source-interleave-invalid-source.test

 ## Test llvm-objdump's --source behaviour when a line number is greater than the
 ## file length and ensure that we emit a warning.
 
 # RUN: sed -e "s,SRC_COMPDIR,%/p/Inputs,g" %p/Inputs/source-interleave.ll > %t.ll
 # RUN: sed -e "s,line: 7,line: 9999,g" %t.ll > %t2.ll
 
 # RUN: llc -o %t.o -filetype=obj -mtriple=x86_64-pc-linux %t.ll
 # RUN: llc -o %t2.o -filetype=obj -mtriple=x86_64-pc-linux %t2.ll
 
 # RUN: llvm-objdump --source %t.o | FileCheck %s --check-prefixes=CHECK,GOOD
 # RUN: llvm-objdump --source %t2.o 2> %t2.e | FileCheck %s --check-prefixes=CHECK --implicit-check-not="int *b = &a;"
 # RUN: FileCheck %s --input-file %t2.e --check-prefixes=WARN
 
 # CHECK:      main:
 # CHECK-NEXT: ; int main() {
-# WARN:       warning: debug info line number 9999 exceeds the number of lines in {{.*}}source-interleave-x86_64.c
+# WARN:       warning: '{{.*}}': debug info line number 9999 exceeds the number of lines in {{.*}}source-interleave-x86_64.c
 # GOOD:       ;   int *b = &a;
 # CHECK:      ;   return *b + foo();

test/tools/llvm-objdump/X86/source-interleave-missing-source.test

 ## Test that if the source cannot be found that disassembly is still printed,
 ## that no source is printed, and that we emit a warning.
 
 # RUN: sed -e "s,SRC_COMPDIR,%/t,g" %p/Inputs/source-interleave.ll > %t.ll
 # RUN: sed -e "s,SRC_COMPDIR,%/p/Inputs,g" %p/Inputs/source-interleave.ll > %t2.ll
 
 # RUN: llc -o %t.o -filetype=obj -mtriple=x86_64-pc-linux %t.ll
 # RUN: llc -o %t2.o -filetype=obj -mtriple=x86_64-pc-linux %t2.ll
 
 # RUN: llvm-objdump --source %t.o 2> %t.e | FileCheck %s --check-prefixes=CHECK --implicit-check-not='main()'
 # RUN: llvm-objdump --source %t2.o | FileCheck %s --check-prefixes=CHECK,SOURCE
 # RUN: FileCheck %s --input-file %t.e --check-prefixes=WARN
 
-# WARN:        warning: failed to find source {{.*}}source-interleave-x86_64.c
+# WARN:        warning: '{{.*}}': failed to find source {{.*}}source-interleave-x86_64.c
 # CHECK:       0000000000000010 main:
 # SOURCE-NEXT: ; int main() {
 # CHECK-NEXT:   10:   55                      pushq   %rbp

test/tools/llvm-objdump/X86/source-interleave-no-debug-info.test

 ## Test that if an object has no debug information, only the disassembly is
 ## printed when --source is specified, and that we emit a warning.
 
 # RUN: sed -e "s,SRC_COMPDIR,%/p/Inputs,g" %p/Inputs/source-interleave.ll > %t.ll
 # RUN: llc -o %t.o -filetype=obj -mtriple=x86_64-pc-linux %t.ll
 # RUN: llvm-objcopy --strip-debug %t.o %t2.o
 
 # RUN: llvm-objdump --source %t.o | FileCheck %s --check-prefixes=CHECK,SOURCE
 # RUN: llvm-objdump --source %t2.o 2> %t2.e | FileCheck %s --check-prefixes=CHECK --implicit-check-not='main()'
 # RUN: FileCheck %s --input-file %t2.e --check-prefixes=WARN
 
-# WARN:        warning: failed to parse debug information for {{.*}}2.o
+# WARN:        warning: '{{.*}}2.o': failed to parse debug information.
 # CHECK:       0000000000000010 main:
 # SOURCE-NEXT: ; int main() {
 # CHECK-NEXT:   10:   55                      pushq   %rbp

test/tools/llvm-objdump/X86/warn-missing-disasm-func.test

 ## Warn if --disassemble-functions specifies an unknown symbol.
 
 # RUN: yaml2obj -o %t.o %s
 # RUN: rm -f %t.a
 # RUN: llvm-ar qc %t.a %t.o %t.o
 # RUN: llvm-objdump --disassemble-functions=foo %t.o 2>&1 | FileCheck %s
 # RUN: llvm-objdump --disassemble-functions=foo %t.a 2>&1 | FileCheck %s --check-prefix=MULTI
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 
-# CHECK: warning: failed to disassemble missing function foo
+# CHECK: warning: {{.*}}: failed to disassemble missing function foo.
 
 # MULTI: file format ELF64-x86-64
-# MULTI: warning: failed to disassemble missing function foo
+# MULTI: warning: {{.*}}: failed to disassemble missing function foo.
 # MULTI: file format ELF64-x86-64
-# MULTI: warning: failed to disassemble missing function foo
+# MULTI: warning: {{.*}}: failed to disassemble missing function foo.

test/tools/llvm-objdump/warn-on-out-of-range-start-stop-address.test

 
 ## No warning for relocatable objects.
 # RUN: llvm-objdump --file-headers --start-address=0x1004 --stop-address=0x1005 %t.o 2>&1 \
 # RUN:   | FileCheck %s --implicit-check-not=warning:
 
 ## No warning if neither --start-address nor --stop-address are specified.
 # RUN: llvm-objdump --file-headers %t 2>&1 | FileCheck %s --implicit-check-not=warning:
 
-# WARN: warning: no section overlaps the range {{.*}} specified by --start-address/--stop-address
-# WARN-STOP-ONLY: warning: no section has address less than 0x1000 specified by --stop-address
-# WARN-START-ONLY: warning: no section has address greater than or equal to 0x1500 specified by --start-address
+# WARN: warning: {{.*}}: no section overlaps the range {{.*}} specified by --start-address/--stop-address
+# WARN-STOP-ONLY: warning: {{.*}}: no section has address less than 0x1000 specified by --stop-address
+# WARN-START-ONLY: warning: {{.*}}: no section has address greater than or equal to 0x1500 specified by --start-address
 
 # MULTI-INPUT: file format
-# MULTI-INPUT: warning: no section overlaps the range [0x2001,0x2005) specified by --start-address/--stop-address
+# MULTI-INPUT: warning: {{.*}}: no section overlaps the range [0x2001,0x2005) specified by --start-address/--stop-address
 # MULTI-INPUT: file format
 # MULTI-INPUT-NOT: warning:
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC

tools/llvm-objdump/COFFDump.cpp

static void printCOFFSymbolAddress(raw_ostream &Out,
   }
 }
 
 static void
 printSEHTable(const COFFObjectFile *Obj, uint32_t TableVA, int Count) {
   if (Count == 0)
     return;
 
-  uint32_t ImageBase = Obj->getPE32Header()->ImageBase;
   uintptr_t IntPtr = 0;
-  error(Obj->getVaPtr(TableVA, IntPtr));
+  if (std::error_code EC = Obj->getVaPtr(TableVA, IntPtr))
+    report_error(errorCodeToError(EC), Obj->getFileName());
+
   const support::ulittle32_t *P = (const support::ulittle32_t *)IntPtr;
   outs() << "SEH Table:";
   for (int I = 0; I < Count; ++I)
-    outs() << format(" 0x%x", P[I] + ImageBase);
+    outs() << format(" 0x%x", P[I] + Obj->getPE32Header()->ImageBase);
   outs() << "\n\n";
 }
 
 template <typename T>
 static void printTLSDirectoryT(const coff_tls_directory<T> *TLSDir) {
   size_t FormatWidth = sizeof(T) * 2;
   outs() << "TLS directory:"
          << "\n  StartAddressOfRawData: "
static void printTLSDirectory(const COFFObjectFile *Obj) {
   const pe32_header *PE32Header = Obj->getPE32Header();
   const pe32plus_header *PE32PlusHeader = Obj->getPE32PlusHeader();
 
   // Skip if it's not executable.
   if (!PE32Header && !PE32PlusHeader)
     return;
 
   const data_directory *DataDir;
-  error(Obj->getDataDirectory(COFF::TLS_TABLE, DataDir));
-  uintptr_t IntPtr = 0;
+  if (std::error_code EC = Obj->getDataDirectory(COFF::TLS_TABLE, DataDir))
+    report_error(errorCodeToError(EC), Obj->getFileName());
+
   if (DataDir->RelativeVirtualAddress == 0)
     return;
-  error(Obj->getRvaPtr(DataDir->RelativeVirtualAddress, IntPtr));
+
+  uintptr_t IntPtr = 0;
+  if (std::error_code EC =
+          Obj->getRvaPtr(DataDir->RelativeVirtualAddress, IntPtr))
+    report_error(errorCodeToError(EC), Obj->getFileName());
 
   if (PE32Header) {
     auto *TLSDir = reinterpret_cast<const coff_tls_directory32 *>(IntPtr);
     printTLSDirectoryT(TLSDir);
   } else {
     auto *TLSDir = reinterpret_cast<const coff_tls_directory64 *>(IntPtr);
     printTLSDirectoryT(TLSDir);
   }
 
   outs() << "\n";
 }
 
 static void printLoadConfiguration(const COFFObjectFile *Obj) {
   // Skip if it's not executable.
   if (!Obj->getPE32Header())
     return;
 
   // Currently only x86 is supported
   if (Obj->getMachine() != COFF::IMAGE_FILE_MACHINE_I386)
     return;
 
   const data_directory *DataDir;
-  error(Obj->getDataDirectory(COFF::LOAD_CONFIG_TABLE, DataDir));
+
+  if (std::error_code EC =
+          Obj->getDataDirectory(COFF::LOAD_CONFIG_TABLE, DataDir))
+    report_error(errorCodeToError(EC), Obj->getFileName());
+
   uintptr_t IntPtr = 0;
   if (DataDir->RelativeVirtualAddress == 0)
     return;
-  error(Obj->getRvaPtr(DataDir->RelativeVirtualAddress, IntPtr));
+
+  if (std::error_code EC =
+          Obj->getRvaPtr(DataDir->RelativeVirtualAddress, IntPtr))
+    report_error(errorCodeToError(EC), Obj->getFileName());
 
   auto *LoadConf = reinterpret_cast<const coff_load_configuration32 *>(IntPtr);
   outs() << "Load configuration:"
          << "\n  Timestamp: " << LoadConf->TimeDateStamp
          << "\n  Major Version: " << LoadConf->MajorVersion
          << "\n  Minor Version: " << LoadConf->MinorVersion
          << "\n  GlobalFlags Clear: " << LoadConf->GlobalFlagsClear
          << "\n  GlobalFlags Set: " << LoadConf->GlobalFlagsSet
for (const SectionRef &Section : Obj->sections()) {
     const coff_section *Pdata = Obj->getCOFFSection(Section);
     for (const RelocationRef &Reloc : Section.relocations())
       Rels.push_back(Reloc);
 
     // Sort relocations by address.
     llvm::sort(Rels, isRelocAddressLess);
 
     ArrayRef<uint8_t> Contents;
-    error(Obj->getSectionContents(Pdata, Contents));
+    if (Error E = Obj->getSectionContents(Pdata, Contents))
+      report_error(std::move(E), Obj->getFileName());
+
     if (Contents.empty())
       continue;
 
     RFStart = reinterpret_cast<const RuntimeFunction *>(Contents.data());
     NumRFs = Contents.size() / sizeof(RuntimeFunction);
     return true;
   }
   return false;
static void printRuntimeFunctionRels(const COFFObjectFile *Obj,
   printCOFFSymbolAddress(outs(), Rels,
                          SectionOffset +
                              /*offsetof(RuntimeFunction, UnwindInfoOffset)*/ 8,
                          RF.UnwindInfoOffset);
   outs() << "\n";
 
   ArrayRef<uint8_t> XContents;
   uint64_t UnwindInfoOffset = 0;
-  error(getSectionContents(
-          Obj, Rels, SectionOffset +
-                         /*offsetof(RuntimeFunction, UnwindInfoOffset)*/ 8,
-          XContents, UnwindInfoOffset));
+  if (Error E = getSectionContents(
+          Obj, Rels,
+          SectionOffset +
+          XContents, UnwindInfoOffset))
+    report_error(std::move(E), Obj->getFileName());
   if (XContents.empty())
     return;
 
   UnwindInfoOffset += RF.UnwindInfoOffset;
   if (UnwindInfoOffset > XContents.size())
     return;
 
   auto *UI = reinterpret_cast<const Win64EH::UnwindInfo *>(XContents.data() +
for (const object::BasicSymbolRef &Sym : i->symbols()) {
 
     ++Index;
   }
 }
 
 void printCOFFSymbolTable(const COFFObjectFile *coff) {
   for (unsigned SI = 0, SE = coff->getNumberOfSymbols(); SI != SE; ++SI) {
     Expected<COFFSymbolRef> Symbol = coff->getSymbol(SI);
+    if (!Symbol)
+      report_error(Symbol.takeError(), coff->getFileName());
+
     StringRef Name;
-    error(Symbol.takeError());
-    error(coff->getSymbolName(*Symbol, Name));
+    if (std::error_code EC = coff->getSymbolName(*Symbol, Name))
+      report_error(errorCodeToError(EC), coff->getFileName());
 
     outs() << "[" << format("%2d", SI) << "]"
            << "(sec " << format("%2d", int(Symbol->getSectionNumber())) << ")"
            << "(fl 0x00)" // Flag bits, which COFF doesn't have.
            << "(ty " << format("%3x", unsigned(Symbol->getType())) << ")"
            << "(scl " << format("%3x", unsigned(Symbol->getStorageClass()))
            << ") "
            << "(nx " << unsigned(Symbol->getNumberOfAuxSymbols()) << ") "
if (Demangle && Name.startswith("?")) {
         outs() << " (invalid mangled name)";
       }
     }
     outs() << "\n";
 
     for (unsigned AI = 0, AE = Symbol->getNumberOfAuxSymbols(); AI < AE; ++AI, ++SI) {
       if (Symbol->isSectionDefinition()) {
         const coff_aux_section_definition *asd;
-        error(coff->getAuxSymbol<coff_aux_section_definition>(SI + 1, asd));
+        if (std::error_code EC =
+                coff->getAuxSymbol<coff_aux_section_definition>(SI + 1, asd))
+          report_error(errorCodeToError(EC), coff->getFileName());
 
         int32_t AuxNumber = asd->getNumber(Symbol->isBigObj());
 
         outs() << "AUX "
                << format("scnlen 0x%x nreloc %d nlnno %d checksum 0x%x "
                          , unsigned(asd->Length)
                          , unsigned(asd->NumberOfRelocations)
                          , unsigned(asd->NumberOfLinenumbers)
                          , unsigned(asd->CheckSum))
                << format("assoc %d comdat %d\n"
                          , unsigned(AuxNumber)
                          , unsigned(asd->Selection));
       } else if (Symbol->isFileRecord()) {
         const char *FileName;
-        error(coff->getAuxSymbol<char>(SI + 1, FileName));
+        if (std::error_code EC = coff->getAuxSymbol<char>(SI + 1, FileName))
+          report_error(errorCodeToError(EC), coff->getFileName());
 
         StringRef Name(FileName, Symbol->getNumberOfAuxSymbols() *
                                      coff->getSymbolTableEntrySize());
         outs() << "AUX " << Name.rtrim(StringRef("\0", 1))  << '\n';
 
         SI = SI + Symbol->getNumberOfAuxSymbols();
         break;
       } else if (Symbol->isWeakExternal()) {
         const coff_aux_weak_external *awe;
-        error(coff->getAuxSymbol<coff_aux_weak_external>(SI + 1, awe));
+        if (std::error_code EC =
+                coff->getAuxSymbol<coff_aux_weak_external>(SI + 1, awe))
+          report_error(errorCodeToError(EC), coff->getFileName());
 
         outs() << "AUX " << format("indx %d srch %d\n",
                                    static_cast<uint32_t>(awe->TagIndex),
                                    static_cast<uint32_t>(awe->Characteristics));
       } else {
         outs() << "AUX Unknown\n";
       }
     }
   }
 }
 } // namespace llvm

tools/llvm-objdump/ELFDump.cpp

if (Dyn.d_tag == ELF::DT_NEEDED || Dyn.d_tag == ELF::DT_RPATH ||
         Dyn.d_tag == ELF::DT_RUNPATH || Dyn.d_tag == ELF::DT_SONAME ||
         Dyn.d_tag == ELF::DT_AUXILIARY || Dyn.d_tag == ELF::DT_FILTER) {
       Expected<StringRef> StrTabOrErr = getDynamicStrTab(Elf);
       if (StrTabOrErr) {
         const char *Data = StrTabOrErr.get().data();
         outs() << (Data + Dyn.d_un.d_val) << "\n";
         continue;
       }
-      warn(toString(StrTabOrErr.takeError()));
+      report_warn(toString(StrTabOrErr.takeError()), Filename);
       consumeError(StrTabOrErr.takeError());
     }
     outs() << format(Fmt, (uint64_t)Dyn.d_un.d_val);
   }
 }
 
 template <class ELFT> void printProgramHeaders(const ELFFile<ELFT> *o) {
   outs() << "Program Header:\n";

tools/llvm-objdump/MachODump.cpp

for (unsigned i = 0; i < ArchFlags.size(); ++i) {
               if (MachOObjectFile *O =
                       dyn_cast<MachOObjectFile>(&*ChildOrErr.get()))
                 ProcessMachO(Filename, O, O->getFileName(), ArchitectureName);
             }
             if (Err)
               report_error(std::move(Err), Filename);
           } else {
             consumeError(AOrErr.takeError());
-            error("Mach-O universal file: " + Filename + " for " +
-                  "architecture " + StringRef(I->getArchFlagName()) +
+            report_error(Filename,
+                         "Mach-O universal file for architecture " +
+                             StringRef(I->getArchFlagName()) +
                              " is not a Mach-O file or an archive file");
           }
         }
       }
       if (!ArchFound) {
         WithColor::error(errs(), "llvm-objdump")
             << "file: " + Filename + " does not contain "
             << "architecture: " + ArchFlags[i] + "\n";
         return;
for (MachOUniversalBinary::object_iterator I = UB->begin_objects(),
             if (MachOObjectFile *O =
                     dyn_cast<MachOObjectFile>(&*ChildOrErr.get()))
               ProcessMachO(Filename, O, O->getFileName());
           }
           if (Err)
             report_error(std::move(Err), Filename);
         } else {
           consumeError(AOrErr.takeError());
-          error("Mach-O universal file: " + Filename + " for architecture " +
+          report_error(Filename,
+                       "Mach-O universal file for architecture " +
                            StringRef(I->getArchFlagName()) +
                            " is not a Mach-O file or an archive file");
         }
         return;
       }
     }
   }
   // Either all architectures have been specified or none have been specified
   // and this does not contain the host architecture so dump all the slices.
   bool moreThanOneArch = UB->getNumberOfObjects() > 1;
if (ObjOrErr) {
             ProcessMachO(Filename, MachOOF, MachOOF->getFileName(),
                           ArchitectureName);
         }
       }
       if (Err)
         report_error(std::move(Err), Filename);
     } else {
       consumeError(AOrErr.takeError());
-      error("Mach-O universal file: " + Filename + " for architecture " +
+      report_error(Filename, "Mach-O universal file for architecture " +
                                  StringRef(I->getArchFlagName()) +
                                  " is not a Mach-O file or an archive file");
     }
   }
 }
 
 // The block of info used by the Symbolizer call backs.
 struct DisassembleInfo {
   DisassembleInfo(MachOObjectFile *O, SymbolAddressMap *AddrMap,
                   std::vector<SectionRef> *Sections, bool verbose)

tools/llvm-objdump/llvm-objdump.h

Error getWasmRelocationValueString(const object::WasmObjectFile *Obj,
                                    const object::RelocationRef &RelRef,
                                    llvm::SmallVectorImpl<char> &Result);
 Error getMachORelocationValueString(const object::MachOObjectFile *Obj,
                                     const object::RelocationRef &RelRef,
                                     llvm::SmallVectorImpl<char> &Result);
 
 uint64_t getELFSectionLMA(const object::ELFSectionRef& Sec);
 
-void error(std::error_code ec);
-void error(Error E);
 bool isRelocAddressLess(object::RelocationRef A, object::RelocationRef B);
 void parseInputMachO(StringRef Filename);
 void parseInputMachO(object::MachOUniversalBinary *UB);
 void printCOFFUnwindInfo(const object::COFFObjectFile *O);
 void printMachOUnwindInfo(const object::MachOObjectFile *O);
 void printMachOExportsTrie(const object::MachOObjectFile *O);
 void printMachORebaseTable(object::MachOObjectFile *O);
 void printMachOBindTable(object::MachOObjectFile *O);

 void printWeakBindTable(object::ObjectFile *O);
 void printRawClangAST(const object::ObjectFile *O);
 void printRelocations(const object::ObjectFile *O);
 void printDynamicRelocations(const object::ObjectFile *O);
 void printSectionHeaders(const object::ObjectFile *O);
 void printSectionContents(const object::ObjectFile *O);
 void printSymbolTable(const object::ObjectFile *O, StringRef ArchiveName,
                       StringRef ArchitectureName = StringRef());
-void warn(Twine Message);
-LLVM_ATTRIBUTE_NORETURN void error(Twine Message);
 LLVM_ATTRIBUTE_NORETURN void report_error(StringRef File, Twine Message);
 LLVM_ATTRIBUTE_NORETURN void report_error(Error E, StringRef File);
 LLVM_ATTRIBUTE_NORETURN void
 report_error(Error E, StringRef FileName, StringRef ArchiveName,
              StringRef ArchitectureName = StringRef());
 LLVM_ATTRIBUTE_NORETURN void
 report_error(Error E, StringRef ArchiveName, const object::Archive::Child &C,
              StringRef ArchitectureName = StringRef());
+void report_warn(Twine Message, StringRef File);
 
 template <typename T, typename... Ts>
 T unwrapOrError(Expected<T> EO, Ts &&... Args) {
   if (EO)
     return std::move(*EO);
   report_error(EO.takeError(), std::forward<Ts>(Args)...);
 }
 
 } // end namespace llvm
 
 #endif

tools/llvm-objdump/llvm-objdump.cpp

if (!SecName.empty())
     FoundSectionSet.insert(SecName);
   return is_contained(FilterSections, SecName);
 }
 
 SectionFilter ToolSectionFilter(object::ObjectFile const &O) {
   return SectionFilter([](object::SectionRef S) { return shouldKeep(S); }, O);
 }
 
-void error(std::error_code EC) {
-  if (!EC)
-    return;
-  WithColor::error(errs(), ToolName)
-      << "reading file: " << EC.message() << ".\n";
-  errs().flush();
-  exit(1);
-}
-
-void error(Error E) {
-  if (!E)
-    return;
-  WithColor::error(errs(), ToolName) << toString(std::move(E));
-  exit(1);
-}
-
-LLVM_ATTRIBUTE_NORETURN void error(Twine Message) {
-  WithColor::error(errs(), ToolName) << Message << ".\n";
-  errs().flush();
-  exit(1);
-}
-
-void warn(Twine Message) {
+void report_warn(Twine Message, StringRef File) {
   // Output order between errs() and outs() matters especially for archive
   // files where the output is per member object.
   outs().flush();
-  WithColor::warning(errs(), ToolName) << Message << "\n";
+
+  if (File.empty())
+    WithColor::warning(errs(), ToolName) << Message << ".\n";
+  else
+    WithColor::warning(errs(), ToolName)
+        << "'" << File << "': " << Message << ".\n";
   errs().flush();
 }
 
 LLVM_ATTRIBUTE_NORETURN void report_error(StringRef File, Twine Message) {
+  if (File.empty())
+    WithColor::error(errs(), ToolName) << Message << ".\n";
+  else
     WithColor::error(errs(), ToolName)
         << "'" << File << "': " << Message << ".\n";
   exit(1);
 }
 
 LLVM_ATTRIBUTE_NORETURN void report_error(Error E, StringRef File) {
   assert(E);
   std::string Buf;
   raw_string_ostream OS(Buf);
   logAllUnhandledErrors(std::move(E), OS);
LLVM_ATTRIBUTE_NORETURN void report_error(Error E, StringRef ArchiveName,
   errs() << ": " << Buf;
   exit(1);
 }
 
 LLVM_ATTRIBUTE_NORETURN void report_error(Error E, StringRef ArchiveName,
                                           const object::Archive::Child &C,
                                           StringRef ArchitectureName) {
   Expected<StringRef> NameOrErr = C.getName();
   // TODO: if we have a error getting the name then it would be nice to print
   // the index of which archive member this is and or its offset in the
   // archive instead of "???" as the name.
   if (!NameOrErr) {
     consumeError(NameOrErr.takeError());
     report_error(std::move(E), ArchiveName, "???", ArchitectureName);
   } else
     report_error(std::move(E), ArchiveName, NameOrErr.get(), ArchitectureName);
 }
 
 static void warnOnNoMatchForSections() {
   SetVector<StringRef> MissingSections;
   for (StringRef S : FilterSections) {
     if (FoundSectionSet.count(S))
       return;
     // User may specify a unnamed section. Don't warn for it.
     if (!S.empty())
       MissingSections.insert(S);
   }
 
   // Warn only if no section in FilterSections is matched.
   for (StringRef S : MissingSections)
-    warn("section '" + S + "' mentioned in a -j/--section option, but not "
-         "found in any input file");
+    report_warn("section '" + S +
+                    "' mentioned in a -j/--section option, but not "
+                    "found in any input file",
+                "" /*FileName*/);
 }
 
-static const Target *getTarget(const ObjectFile *Obj = nullptr) {
+static const Target *getTarget(const ObjectFile *Obj) {
   // Figure out the target triple.
   Triple TheTriple("unknown-unknown-unknown");
   if (TripleName.empty()) {
-    if (Obj)
-      TheTriple = Obj->makeTriple();
   } else {
     TheTriple.setTriple(Triple::normalize(TripleName));
 
     // Use the triple, but also try to combine with ARM build attributes.
-    if (Obj) {
-      auto Arch = Obj->getArch();
-      if (Arch == Triple::arm || Arch == Triple::armeb)
-        Obj->setARMSubArch(TheTriple);
-    }
-  }
 
   // Get the target specific parser.
   std::string Error;
   const Target *TheTarget = TargetRegistry::lookupTarget(ArchName, TheTriple,
                                                          Error);
-  if (!TheTarget) {
-    if (Obj)
-      report_error(Obj->getFileName(), "can't find target: " + Error);
-    else
-      error("can't find target: " + Error);
-  }
+  if (!TheTarget)
 
   // Update the triple name and return the found target.
   TripleName = TheTriple.getTriple();
   return TheTarget;
 }
 
 bool isRelocAddressLess(RelocationRef A, RelocationRef B) {
   return A.getOffset() < B.getOffset();

 bool SourcePrinter::cacheSource(const DILineInfo &LineInfo) {
   std::unique_ptr<MemoryBuffer> Buffer;
   if (LineInfo.Source) {
     Buffer = MemoryBuffer::getMemBuffer(*LineInfo.Source);
   } else {
     auto BufferOrError = MemoryBuffer::getFile(LineInfo.FileName);
     if (!BufferOrError) {
       if (MissingSources.insert(LineInfo.FileName).second)
-        warn("failed to find source " + LineInfo.FileName);
-
+        report_warn("failed to find source " + LineInfo.FileName,
+                    Obj->getFileName());
       return false;
     }
     Buffer = std::move(*BufferOrError);
   }
   // Chomp the file to get lines
   const char *BufferStart = Buffer->getBufferStart(),
              *BufferEnd = Buffer->getBufferEnd();
   std::vector<StringRef> &Lines = LineCache[LineInfo.FileName];
void SourcePrinter::printSourceLine(raw_ostream &OS,
   std::string ErrorMessage;
   if (!ExpectedLineInfo)
     ErrorMessage = toString(ExpectedLineInfo.takeError());
   else
     LineInfo = *ExpectedLineInfo;
 
   if (LineInfo.FileName == DILineInfo::BadString) {
     if (!WarnedNoDebugInfo) {
-      std::string Warning =
-          "failed to parse debug information for " + ObjectFilename.str();
+      std::string Warning = "failed to parse debug information";
       if (!ErrorMessage.empty())
         Warning += ": " + ErrorMessage;
-      warn(Warning);
+      report_warn(Warning, ObjectFilename);
       WarnedNoDebugInfo = true;
     }
     return;
   }
 
   if (LineInfo.Line == 0 || ((OldLineInfo.Line == LineInfo.Line) &&
                              (OldLineInfo.FileName == LineInfo.FileName)))
     return;
 
   if (PrintLines)
     OS << Delimiter << LineInfo.FileName << ":" << LineInfo.Line << "\n";
   if (PrintSource) {
     if (SourceCache.find(LineInfo.FileName) == SourceCache.end())
       if (!cacheSource(LineInfo))
         return;
     auto LineBuffer = LineCache.find(LineInfo.FileName);
     if (LineBuffer != LineCache.end()) {
       if (LineInfo.Line > LineBuffer->second.size()) {
-        warn(formatv(
+        report_warn(
+            formatv(
                 "debug info line number {0} exceeds the number of lines in {1}",
-            LineInfo.Line, LineInfo.FileName));
+                LineInfo.Line, LineInfo.FileName),
+            ObjectFilename);
         return;
       }
       // Vector begins at 0, line numbers are non-zero
       OS << Delimiter << LineBuffer->second[LineInfo.Line - 1] << '\n';
     }
   }
   OldLineInfo = LineInfo;
 }
 
 static bool isAArch64Elf(const ObjectFile *Obj) {
   const auto *Elf = dyn_cast<ELFObjectFileBase>(Obj);
   return Elf && Elf->getEMachine() == ELF::EM_AARCH64;
 }
 
 static bool isArmElf(const ObjectFile *Obj) {
   const auto *Elf = dyn_cast<ELFObjectFileBase>(Obj);
   return Elf && Elf->getEMachine() == ELF::EM_ARM;
 }
 
 static bool hasMappingSymbols(const ObjectFile *Obj) {
   return isArmElf(Obj) || isAArch64Elf(Obj);
 }
 
-static void printRelocation(const RelocationRef &Rel, uint64_t Address,
-                            bool Is64Bits) {
+static void printRelocation(StringRef FileName, const RelocationRef &Rel,
+                            uint64_t Address, bool Is64Bits) {
   StringRef Fmt = Is64Bits ? "\t\t%016" PRIx64 ":  " : "\t\t\t%08" PRIx64 ":  ";
   SmallString<16> Name;
   SmallString<32> Val;
   Rel.getTypeName(Name);
-  error(getRelocationValueString(Rel, Val));
+  if (Error E = getRelocationValueString(Rel, Val))
+    report_error(std::move(E), FileName);
   outs() << format(Fmt.data(), Address) << Name << "\t" << Val << "\n";
 }
 
 class PrettyPrinter {
 public:
   virtual ~PrettyPrinter() = default;
   virtual void printInst(MCInstPrinter &IP, const MCInst *MI,
                          ArrayRef<uint8_t> Bytes,
void printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef<uint8_t> Bytes,
 
     // Hexagon's packets require relocations to be inline rather than
     // clustered at the end of the packet.
     std::vector<RelocationRef>::const_iterator RelCur = Rels->begin();
     std::vector<RelocationRef>::const_iterator RelEnd = Rels->end();
     auto PrintReloc = [&]() -> void {
       while ((RelCur != RelEnd) && (RelCur->getOffset() <= Address.Address)) {
         if (RelCur->getOffset() == Address.Address) {
-          printRelocation(*RelCur, Address.Address, false);
+          printRelocation(ObjectFilename, *RelCur, Address.Address, false);
           return;
         }
         ++RelCur;
       }
     };
 
     while (!HeadTail.first.empty()) {
       OS << Separator;
for (SectionRef Sec : Obj->sections())
     SectionAddresses.emplace_back(Sec.getAddress(), Sec);
   array_pod_sort(SectionAddresses.begin(), SectionAddresses.end());
 
   // Linked executables (.exe and .dll files) typically don't include a real
   // symbol table but they might contain an export table.
   if (const auto *COFFObj = dyn_cast<COFFObjectFile>(Obj)) {
     for (const auto &ExportEntry : COFFObj->export_directories()) {
       StringRef Name;
-      error(ExportEntry.getSymbolName(Name));
+      if (std::error_code EC = ExportEntry.getSymbolName(Name))
+        report_error(errorCodeToError(EC), Obj->getFileName());
       if (Name.empty())
         continue;
+
       uint32_t RVA;
-      error(ExportEntry.getExportRVA(RVA));
+      if (std::error_code EC = ExportEntry.getExportRVA(RVA))
+        report_error(errorCodeToError(EC), Obj->getFileName());
 
       uint64_t VA = COFFObj->getImageBase() + RVA;
       auto Sec = partition_point(
           SectionAddresses, [VA](const std::pair<uint64_t, SectionRef> &O) {
             return O.first <= VA;
           });
       if (Sec != SectionAddresses.begin()) {
         --Sec;
#endif
             if (RelCur->getSymbol() != Obj->symbol_end()) {
               Expected<section_iterator> SymSI =
                   RelCur->getSymbol()->getSection();
               if (SymSI && *SymSI != Obj->section_end() &&
                   shouldAdjustVA(**SymSI))
                 Offset += AdjustVMA;
             }
 
-            printRelocation(*RelCur, SectionAddr + Offset, Is64Bits);
+            printRelocation(Obj->getFileName(), *RelCur, SectionAddr + Offset,
+                            Is64Bits);
             ++RelCur;
           }
         }
 
         Index += Size;
       }
     }
   }
   StringSet<> MissingDisasmFuncsSet =
       set_difference(DisasmFuncsSet, FoundDisasmFuncsSet);
   for (StringRef MissingDisasmFunc : MissingDisasmFuncsSet.keys())
-    warn("failed to disassemble missing function " + MissingDisasmFunc);
+    report_warn("failed to disassemble missing function " + MissingDisasmFunc,
+                FileName);
 }
 
 static void disassembleObject(const ObjectFile *Obj, bool InlineRelocs) {
   const Target *TheTarget = getTarget(Obj);
 
   // Package up features to be passed to target/subtarget
   SubtargetFeatures Features = Obj->getFeatures();
   if (!MAttrs.empty())
report_error(Obj->getFileName(),
                  "no instruction printer for target " + TripleName);
   IP->setPrintImmHex(PrintImmHex);
 
   PrettyPrinter &PIP = selectPrettyPrinter(Triple(TripleName));
   SourcePrinter SP(Obj, TheTarget->getName());
 
   for (StringRef Opt : DisassemblerOptions)
     if (!IP->applyTargetSpecificCLOption(Opt))
-      error("Unrecognized disassembler option: " + Opt);
+      report_error(Obj->getFileName(),
+                   "Unrecognized disassembler option: " + Opt);
 
   disassembleObject(TheTarget, Obj, Ctx, DisAsm.get(), SecondaryDisAsm.get(),
                     MIA.get(), IP.get(), STI.get(), SecondarySTI.get(), PIP,
                     SP, InlineRelocs);
 }
 
 void printRelocations(const ObjectFile *Obj) {
   StringRef Fmt = Obj->getBytesInAddress() > 4 ? "%016" PRIx64 :
for (std::pair<SectionRef, std::vector<SectionRef>> &P : SecToRelSec) {
     for (SectionRef Section : P.second) {
       for (const RelocationRef &Reloc : Section.relocations()) {
         uint64_t Address = Reloc.getOffset();
         SmallString<32> RelocName;
         SmallString<32> ValueStr;
         if (Address < StartAddress || Address > StopAddress || getHidden(Reloc))
           continue;
         Reloc.getTypeName(RelocName);
-        error(getRelocationValueString(Reloc, ValueStr));
+        if (Error E = getRelocationValueString(Reloc, ValueStr))
+          report_error(std::move(E), Obj->getFileName());
+
         outs() << format(Fmt.data(), Address) << " " << RelocName << " "
                << ValueStr << "\n";
       }
     }
     outs() << "\n";
   }
 }
 
 void printDynamicRelocations(const ObjectFile *Obj) {
   // For the moment, this option is for ELF only
   if (!Obj->isELF())
     return;
 
   const auto *Elf = dyn_cast<ELFObjectFileBase>(Obj);
   if (!Elf || Elf->getEType() != ELF::ET_DYN) {
-    error("not a dynamic object");
+    report_error(Obj->getFileName(), "not a dynamic object");
     return;
   }
 
   std::vector<SectionRef> DynRelSec = Obj->dynamic_relocation_sections();
   if (DynRelSec.empty())
     return;
 
   outs() << "DYNAMIC RELOCATION RECORDS\n";
   StringRef Fmt = Obj->getBytesInAddress() > 4 ? "%016" PRIx64 : "%08" PRIx64;
   for (const SectionRef &Section : DynRelSec)
     for (const RelocationRef &Reloc : Section.relocations()) {
       uint64_t Address = Reloc.getOffset();
       SmallString<32> RelocName;
       SmallString<32> ValueStr;
       Reloc.getTypeName(RelocName);
-      error(getRelocationValueString(Reloc, ValueStr));
+      if (Error E = getRelocationValueString(Reloc, ValueStr))
+        report_error(std::move(E), Obj->getFileName());
+
       outs() << format(Fmt.data(), Address) << " " << RelocName << " "
              << ValueStr << "\n";
     }
 }
 
 // Returns true if we need to show LMA column when dumping section headers. We
 // show it only when the platform is ELF and either we have at least one section
 // whose VMA and LMA are different and/or when --show-lma flag is used.
for (const SectionRef &Section : Obj->sections())
     if (ELFSectionRef(Section).getFlags() & ELF::SHF_ALLOC) {
       uint64_t BaseAddr = Section.getAddress();
       uint64_t Size = Section.getSize();
       if ((Start < BaseAddr + Size) && Stop > BaseAddr)
         return;
     }
 
   if (StartAddress.getNumOccurrences() == 0)
-    warn("no section has address less than 0x" +
-         Twine::utohexstr(Stop) + " specified by --stop-address");
+    report_warn("no section has address less than 0x" + Twine::utohexstr(Stop) +
+                    " specified by --stop-address",
+                Obj->getFileName());
   else if (StopAddress.getNumOccurrences() == 0)
-    warn("no section has address greater than or equal to 0x" +
-         Twine::utohexstr(Start) + " specified by --start-address");
-  else
-    warn("no section overlaps the range [0x" +
-         Twine::utohexstr(Start) + ",0x" + Twine::utohexstr(Stop) +
-         ") specified by --start-address/--stop-address");
+    report_warn("no section has address greater than or equal to 0x" +
+                    Twine::utohexstr(Start) + " specified by --start-address",
+                Obj->getFileName());
+  else
+    report_warn("no section overlaps the range [0x" + Twine::utohexstr(Start) +
+                    ",0x" + Twine::utohexstr(Stop) +
+                    ") specified by --start-address/--stop-address",
+                Obj->getFileName());
 }
 
 static void dumpObject(ObjectFile *O, const Archive *A = nullptr,
                        const Archive::Child *C = nullptr) {
   // Avoid other output when using a raw option.
   if (!RawClangAST) {
     outs() << '\n';
     if (A)
int main(int argc, char **argv) {
   InitializeAllDisassemblers();
 
   // Register the target printer for --version.
   cl::AddExtraVersionPrinter(TargetRegistry::printRegisteredTargetsForVersion);
 
   cl::ParseCommandLineOptions(argc, argv, "llvm object file dumper\n");
 
   if (StartAddress >= StopAddress)
-    error("start address should be less than stop address");
+    report_error("" /*FileName*/,
+                 "start address should be less than stop address");
 
   ToolName = argv[0];
 
   // Defaults to a.out if no filenames specified.
   if (InputFilenames.empty())
     InputFilenames.push_back("a.out");
 
   if (AllHeaders)