[llvm-readobj/llvm-readelf] - Improve/cleanup the error reporting API.

[grimar]

Summary

Currently we have the following functions for error reporting:

LLVM_ATTRIBUTE_NORETURN void reportError(Twine Msg);
void reportError(Error Err, StringRef Input); 
void reportWarning(Twine Msg);
void reportWarning(StringRef Input, Error Err);
void warn(llvm::Error Err);
void error(std::error_code EC);

Problems are: naming is inconsistent, arguments order is inconsistent,
some of the functions looks excessive.

After applying this patch we have:

void reportError(Error Err, StringRef Input); 
void reportError(std::error_code EC, StringRef Input);
void reportWarning(Error Err, StringRef Input);

I'd be happy to remove reportError(std::error_code EC, StringRef Input) too, but it
is used by COFF heavily.

Test cases were updated, they show an improvement introduced.

[jhenderson]

tools/llvm-readobj/ObjDumper.cpp

27 ↗

(On Diff #215367)

Can you use createStringError here?

[MaskRay]

tools/llvm-readobj/ELFDumper.cpp

4623 ↗

(On Diff #215367)

I think if a variable already exists, keeping it probably doesn't hurt. Typing Obj->getFileName() takes a bit more characters.

[rupprecht]

tools/llvm-readobj/ELFDumper.cpp

141–144 ↗

(On Diff #215367)

I think <?> is confusing, and is worth fixing in this patch instead of deferring to a followup cleanup.

Could you perhaps make DynRegionInfo take a required filename parameter which can be initialized in ELFDumper's constructor so it's always available?

tools/llvm-readobj/llvm-readobj.cpp

400 ↗

(On Diff #215367)

... any idea why this was necessary before? This is a different stream. Might be nice to have a comment in the code. (Same for above in error()).

tools/llvm-readobj/llvm-readobj.h

24–25 ↗

(On Diff #215367)

Can these both be LLVM_ATTRIBUTE_NORETURN? I think they should have been so before too.

[grimar]

• Addressed review comments.

tools/llvm-readobj/ELFDumper.cpp

141–144 ↗

(On Diff #215367)

Ok, done.
(FTR, "<?>" is used in COFFDumper.cpp, I took the idea from there.)

4623 ↗

(On Diff #215367)

Ok.

tools/llvm-readobj/ObjDumper.cpp

27 ↗

(On Diff #215367)

Done.

tools/llvm-readobj/llvm-readobj.cpp

400 ↗

(On Diff #215367)

... any idea why this was necessary before? This is a different stream.

Yes, I added it in D64472 because otherwise warnings reported could be printed at the wrong places.
(i.e. they were kind of randomly mixed to the standart output).

I added comments requested.

tools/llvm-readobj/llvm-readobj.h

24–25 ↗

(On Diff #215367)

Done.

[MaskRay]

tools/llvm-readobj/llvm-readobj.cpp

392 ↗

(On Diff #215557)

llvm_unreachable after handleAllErrors. handleAllErrors is not marked noreturn, so it needs manual annotation.

[grimar]

• Addressed review comment.

[rupprecht]

tools/llvm-readobj/llvm-readobj.cpp

379 ↗

(On Diff #215570)

standart -> standard

403 ↗

(On Diff #215570)

standart -> standard

llvm/trunk/test/Object/invalid.test

- Name: .symtab
     Type: SHT_SYMTAB
     EntSize: 32
 Symbols:
   - Name: foo
 
 ## Check that llvm-readobj reports a warning if .dynsym has an invalid sh_entsize.
 
 # RUN: yaml2obj %s --docnum=7 -o %t7
-# RUN: llvm-readobj --dyn-symbols %t7 2>&1 | FileCheck --check-prefix=INVALID-DYNSYM-SIZE %s
+# RUN: llvm-readobj --dyn-symbols %t7 2>&1 | FileCheck -DFILE=%t7 --check-prefix=INVALID-DYNSYM-SIZE %s
 
-# INVALID-DYNSYM-SIZE: warning: invalid section size (48) or entity size (32)
+# INVALID-DYNSYM-SIZE: warning: '[[FILE]]': invalid section size (48) or entity size (32)
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
- Name: .strtab
     Size: 1
 Symbols:
   - Name: foo
 
 ## Version index in .gnu.version overflows the version map.
 ## Check llvm-readobj reports it.
 
 # RUN: yaml2obj %s --docnum=20 -o %t20
-# RUN: not llvm-readobj -dt %t20 2>&1 | FileCheck --check-prefix=INVALID-VERSION %s
+# RUN: not llvm-readobj -dt %t20 2>&1 | FileCheck -DFILE=%t20 --check-prefix=INVALID-VERSION %s
 
-# INVALID-VERSION: error: Invalid version entry
+# INVALID-VERSION: error: '[[FILE]]': Invalid version entry
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:

 # RUN:   | FileCheck -DFILE=%p/Inputs/corrupt-invalid-phentsize.elf.x86-64 --check-prefix=PHENTSIZE %s
 
 # PHENTSIZE: error: '[[FILE]]': invalid e_phentsize: 57
 
 ## The dynamic table contains DT_STRTAB with a value that is not in any loadable segment.
 ## Check llvm-readobj reports it.
 
 # RUN: yaml2obj %s --docnum=21 -o %t21
-# RUN: llvm-readobj --dynamic-table %t21 2>&1 | FileCheck --check-prefix=INVALID-DTSTRTAB %s
+# RUN: llvm-readobj --dynamic-table %t21 2>&1 | FileCheck -DFILE=%t21 --check-prefix=INVALID-DTSTRTAB %s
 
-# INVALID-DTSTRTAB: warning: Unable to parse DT_STRTAB: virtual address is not in any segment: 0xffff0000
+# INVALID-DTSTRTAB: warning: '[[FILE]]': Unable to parse DT_STRTAB: virtual address is not in any segment: 0xffff0000
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
- Type: PT_LOAD
     Sections:
       - Section: .dynamic
 
 ## Check that llvm-readobj reports a warning when a dynamic relocation section
 ## has sh_entsize field with size != sizeof(Elf_Rela).
 
 # RUN: llvm-readobj --dyn-relocations \
 # RUN:   %p/Inputs/corrupt-invalid-relocation-size.elf.x86-64 2>&1 \
-# RUN:    | FileCheck --check-prefix=RELOC-BROKEN-ENTSIZE %s
+# RUN:    | FileCheck -DFILE=%p/Inputs/corrupt-invalid-relocation-size.elf.x86-64 --check-prefix=RELOC-BROKEN-ENTSIZE %s
 
-# RELOC-BROKEN-ENTSIZE: warning: invalid section size (24) or entity size (25)
+# RELOC-BROKEN-ENTSIZE: warning: '[[FILE]]': invalid section size (24) or entity size (25)
 
 ## Check that llvm-readobj reports a warning when .dynamic section has an invalid
 ## size, which isn't a multiple of the dynamic entry size. 
 
 # RUN: yaml2obj %s --docnum=22 -o %t22
-# RUN: llvm-readobj --dyn-relocations %t22 2>&1 | FileCheck --check-prefix=DYN-TABLE-SIZE %s
+# RUN: llvm-readobj --dyn-relocations %t22 2>&1 | FileCheck -DFILE=%t22 --check-prefix=DYN-TABLE-SIZE %s
 
-# DYN-TABLE-SIZE: warning: invalid section size (1) or entity size (16)
+# DYN-TABLE-SIZE: warning: '[[FILE]]': invalid section size (1) or entity size (16)
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name:    .dynamic
     Type:    SHT_DYNAMIC
     Content: "00"
 
 ## PT_DYNAMIC's p_offset field is so large that p_offset + p_filesz is larger
 ## than the object size. Check llvm-readobj reports it.
 
 # RUN: yaml2obj %s --docnum=23 -o %t23
-# RUN: llvm-readobj --dyn-relocations %t23 2>&1 | FileCheck --check-prefix=DYN-TABLE-PHDR %s
+# RUN: llvm-readobj --dyn-relocations %t23 2>&1 | FileCheck -DFILE=%t23 --check-prefix=DYN-TABLE-PHDR %s
 
-# DYN-TABLE-PHDR: warning: PT_DYNAMIC segment offset + size exceeds the size of the file
+# DYN-TABLE-PHDR: warning: '[[FILE]]': PT_DYNAMIC segment offset + size exceeds the size of the file
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name: .dynamic
     Type: SHT_DYNAMIC
     Entries:
       - Tag:   DT_NULL
         Value: 0
 ProgramHeaders:
   - Type:   PT_DYNAMIC
     Offset: 0xffff0000
     Sections:
       - Section: .dynamic
 
 ## PT_DYNAMIC's p_filesz field is so large that p_offset + p_filesz is larger
 ## than the object size. Check llvm-readobj reports it.
 
 # RUN: yaml2obj %s --docnum=24 -o %t24
 # RUN: llvm-readobj --dyn-relocations %t24 2>&1 \
-# RUN:  | FileCheck --check-prefix=DYN-TABLE-PHDR %s
+# RUN:  | FileCheck -DFILE=%t24 --check-prefix=DYN-TABLE-PHDR %s
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:

llvm/trunk/test/tools/llvm-readobj/elf-broken-dynsym-link.test

 ## Test that we are able to dump section headers even if the
 ## .dynsym section's sh_link field is broken.
 
 ## Case 1: sh_link is set to 0.
 # RUN: yaml2obj --docnum=1 %s -o %t1
-# RUN: llvm-readobj -S %t1 2>&1 | FileCheck %s --check-prefixes=LLVM,ERR
-# RUN: llvm-readelf -S %t1 2>&1 | FileCheck %s --check-prefixes=GNU,ERR
+# RUN: llvm-readobj -S %t1 2>&1 | FileCheck %s -DFILE=%t1 --check-prefixes=LLVM,ERR
+# RUN: llvm-readelf -S %t1 2>&1 | FileCheck %s -DFILE=%t1 --check-prefixes=GNU,ERR
 
-# ERR: warning: invalid sh_type for string table section [index 0]: expected SHT_STRTAB, but got SHT_NULL
+# ERR: warning: '[[FILE]]': invalid sh_type for string table section [index 0]: expected SHT_STRTAB, but got SHT_NULL
 
 # LLVM:      Name: .dynsym
 # LLVM-NEXT:  Type: SHT_DYNSYM
 # LLVM-NEXT:  Flags [
 # LLVM-NEXT:    SHF_ALLOC
 # LLVM-NEXT:  ]
 # LLVM-NEXT:  Address: 0x0
 # LLVM-NEXT:  Offset: 0x180
FileHeader:
   Machine: EM_X86_64
 Sections:
   - Name: .dynsym
     Type: SHT_DYNSYM
 
 ## Case 2: sh_link is set to 255, which is larger than the number of the sections.
 # RUN: yaml2obj --docnum=2 %s -o %t2
 
-# RUN: llvm-readobj -S %t2 2>&1 | FileCheck %s --check-prefixes=LLVM2,ERR2
-# RUN: llvm-readelf -S %t2 2>&1 | FileCheck %s --check-prefixes=GNU2,ERR2
+# RUN: llvm-readobj -S %t2 2>&1 | FileCheck -DFILE=%t2 %s --check-prefixes=LLVM2,ERR2
+# RUN: llvm-readelf -S %t2 2>&1 | FileCheck -DFILE=%t2 %s --check-prefixes=GNU2,ERR2
 
-# ERR2: warning: invalid section index
+# ERR2: warning: '[[FILE]]': invalid section index
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:

llvm/trunk/test/tools/llvm-readobj/elf-dynamic-malformed.test

 ## Test handling of a dynamic section size which is not a multiple of its entry size.
 ## Test the full output to demonstrate how we print the warnings.
 
 # RUN: yaml2obj %s --docnum=1 -o %t.bad-size
 # RUN: llvm-readobj --all %t.bad-size 2>&1 \
-# RUN:   | FileCheck %s --implicit-check-not=warning --check-prefix WARN
+# RUN:   | FileCheck %s -DFILE=%t.bad-size --implicit-check-not=warning --check-prefix WARN
 # RUN: llvm-readelf --all %t.bad-size 2>&1 \
-# RUN:   | FileCheck %s --implicit-check-not=warning --check-prefix WARN-GNU
+# RUN:   | FileCheck %s -DFILE=%t.bad-size --implicit-check-not=warning --check-prefix WARN-GNU
 
 # WARN-NOT: warning
-# WARN: warning: invalid section size (4) or entity size (16)
+# WARN: warning: '[[FILE]]': invalid section size (4) or entity size (16)
 # WARN-EMPTY:
 # WARN-NEXT: File:
 # WARN:      Symbols [
 # WARN:      ]
 # WARN-EMPTY:
 ## A warning is printed at the place where a normal dynamic table should be. 
-# WARN-NEXT: warning: invalid section size (4) or entity size (16)
+# WARN-NEXT: warning: '[[FILE]]': invalid section size (4) or entity size (16)
 # WARN-NEXT: ProgramHeaders [
 
 # WARN-GNU-NOT:  warning
-# WARN-GNU:      warning: invalid section size (4) or entity size (16)
+# WARN-GNU:      warning: '[[FILE]]': invalid section size (4) or entity size (16)
 # WARN-GNU-NEXT: ELF Header:
 # WARN-GNU:      Symbol table '.symtab' contains 1 entries:
 # WARN-GNU:        0:
 # WARN-GNU-EMPTY:
 ## A warning is printed at the place where a normal dynamic table should be. 
-# WARN-GNU:      warning: invalid section size (4) or entity size (16)
+# WARN-GNU:      warning: '[[FILE]]': invalid section size (4) or entity size (16)
 # WARN-GNU-EMPTY:
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
ProgramHeaders:
   - Type: PT_DYNAMIC
     VAddr: 0x1010
     Sections:
       - Section: .dynamic
 
 ## Test handling of DT_STRTAB pointing outside the file's address space.
 # RUN: yaml2obj %s --docnum=4 -o %t.bad-strtab
 
-# RUN: llvm-readobj --dynamic-table %t.bad-strtab 2>&1 >/dev/null | FileCheck %s --check-prefix BAD-STRTAB-ERR
-# RUN: llvm-readelf --dynamic-table %t.bad-strtab 2>&1 >/dev/null | FileCheck %s --check-prefix BAD-STRTAB-ERR
-# BAD-STRTAB-ERR: warning: Unable to parse DT_STRTAB: virtual address is not in any segment: 0x2000000
+# RUN: llvm-readobj --dynamic-table %t.bad-strtab 2>&1 >/dev/null | FileCheck -DFILE=%t.bad-strtab %s --check-prefix BAD-STRTAB-ERR
+# RUN: llvm-readelf --dynamic-table %t.bad-strtab 2>&1 >/dev/null | FileCheck -DFILE=%t.bad-strtab %s --check-prefix BAD-STRTAB-ERR
+# BAD-STRTAB-ERR: warning: '[[FILE]]': Unable to parse DT_STRTAB: virtual address is not in any segment: 0x2000000
 
 # RUN: llvm-readobj --dynamic-table --needed-libs %t.bad-strtab | FileCheck %s --check-prefixes=BAD-STRTAB,BAD-STRTAB-LLVM
 # RUN: llvm-readelf --dynamic-table --needed-libs %t.bad-strtab | FileCheck %s --check-prefixes=BAD-STRTAB,BAD-STRTAB-GNU
 # BAD-STRTAB-LLVM: LoadName: <String table is empty or was not found>
 # BAD-STRTAB-LLVM: 0x0000000000000001  NEEDED   Shared library: [<String table is empty or was not found>]
 # BAD-STRTAB-GNU:  0x0000000000000001 (NEEDED)  Shared library: [<String table is empty or was not found>]
 # BAD-STRTAB:      NeededLibraries [
 # BAD-STRTAB:        <String table is empty or was not found>
Sections:
       - Section: .dynamic
   - Type: PT_DYNAMIC
     VAddr: 0x1000
     Sections:
       - Section: .dynamic
 
 ## Test handling of other d_ptr tags pointing outside the file's address space.
 # RUN: yaml2obj %s --docnum=5 -o %t.bad-rela
-# RUN: llvm-readobj --dynamic-table %t.bad-rela 2>&1 | FileCheck %s --check-prefixes=CHECK,BAD-RELA
-# RUN: llvm-readelf --dynamic-table %t.bad-rela 2>&1 | FileCheck %s --check-prefixes=CHECK,BAD-RELA-GNU
+# RUN: llvm-readobj --dynamic-table %t.bad-rela 2>&1 | FileCheck -DFILE=%t.bad-rela %s --check-prefixes=CHECK,BAD-RELA
+# RUN: llvm-readelf --dynamic-table %t.bad-rela 2>&1 | FileCheck -DFILE=%t.bad-rela %s --check-prefixes=CHECK,BAD-RELA-GNU
 
-# CHECK: warning: Unable to parse DT_RELA: virtual address is not in any segment: 0x1000000
+# CHECK: warning: '[[FILE]]': Unable to parse DT_RELA: virtual address is not in any segment: 0x1000000
 
 # BAD-RELA:      DynamicSection [ (2 entries)
 # BAD-RELA-NEXT:   Tag                Type Name/Value
 # BAD-RELA-NEXT:   0x0000000000000007 RELA 0x1000000
 # BAD-RELA-NEXT:   0x0000000000000000 NULL 0x0
 # BAD-RELA-NEXT: ]
 # BAD-RELA-GNU:      Dynamic section at offset 0x1f0 contains 2 entries:
 # BAD-RELA-GNU-NEXT: Tag                Type   Name/Value

llvm/trunk/test/tools/llvm-readobj/elf-dynamic-not-in-pt-dynamic.test

 ## Show that llvm-readobj/llvm-readelf tools can dump the .dynamic
 ## section when it is not in a PT_DYNAMIC segment.
 
 # RUN: yaml2obj %s -o %t.o
 # RUN: llvm-readobj --dynamic-table %t.o 2>&1 \
-# RUN:   | FileCheck --check-prefixes=WARNING,LLVM %s
+# RUN:   | FileCheck -DFILE=%t.o --check-prefixes=WARNING,LLVM %s
 # RUN: llvm-readelf --dynamic-table %t.o 2>&1 \
-# RUN:   | FileCheck --check-prefixes=WARNING,GNU %s
+# RUN:   | FileCheck -DFILE=%t.o --check-prefixes=WARNING,GNU %s
 
-# WARNING:   warning: The SHT_DYNAMIC section '.dynamic' is not contained within the PT_DYNAMIC segment
+# WARNING:   warning: '[[FILE]]': The SHT_DYNAMIC section '.dynamic' is not contained within the PT_DYNAMIC segment
 
 # LLVM:      DynamicSection [ (2 entries)
 # LLVM-NEXT:   Tag                Type     Name/Value
 # LLVM-NEXT:   0x0000000000000018 BIND_NOW 0x1
 # LLVM-NEXT:   0x0000000000000000 NULL     0x0
 # LLVM-NEXT: ]
 
 # GNU:      Dynamic section at offset 0x{{.*}} contains 2 entries:

llvm/trunk/test/tools/llvm-readobj/elf-malformed-pt-dynamic.test

 # If the offset and/or size fields of the PT_DYNAMIC field become corrupted,
 # we should report a sensible message.
 
 # Creating such a malformed file is hard. The easiest way to simulate it is to
 # truncate the file. Note that the section headers must first be stripped or
 # llvm-readobj will fail to parse the file due to the section header table
 # offset pointing outside the file.
 
 # RUN: yaml2obj %s -o %t.base
 # RUN: llvm-objcopy --strip-sections %t.base %t.stripped
 
 # Test case where the size is too large to fit in the file, but the start is
 # within the file.
 # RUN: cp %t.stripped %t.truncated1
 # RUN: %python -c "with open(r'%t.truncated1', 'r+') as f: f.truncate(0x1001)"
-# RUN: llvm-readobj %t.truncated1 --dynamic-table 2>&1 | FileCheck %s
+# RUN: llvm-readobj %t.truncated1 --dynamic-table 2>&1 | FileCheck -DFILE=%t.truncated1 %s
 
 # Test case where the offset is too large to be in the file.
 # RUN: cp %t.stripped %t.truncated2
 # RUN: %python -c "with open(r'%t.truncated2', 'r+') as f: f.truncate(0xFFF)"
-# RUN: llvm-readobj %t.truncated2 --dynamic-table 2>&1 | FileCheck %s
+# RUN: llvm-readobj %t.truncated2 --dynamic-table 2>&1 | FileCheck -DFILE=%t.truncated2 %s
 
-# CHECK: warning: PT_DYNAMIC segment offset + size exceeds the size of the file
+# CHECK: warning: '[[FILE]]': PT_DYNAMIC segment offset + size exceeds the size of the file
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:

llvm/trunk/test/tools/llvm-readobj/elf-non-dynamic-in-pt-dynamic.test

 ## Show that llvm-readobj/llvm-readelf tools can dump the .dynamic section which
 ## is not alone in PT_DYNAMIC segment.
 
 ## In the first case .text is placed before .dynamic.
 ## We check that we warn about this case.
 
 # RUN: yaml2obj --docnum=1 %s -o %t.o
 # RUN: llvm-readobj --dynamic-table %t.o 2>&1 \
-# RUN:   | FileCheck %s --check-prefixes=WARNING,LLVM
+# RUN:   | FileCheck %s --DFILE=%t.o --check-prefixes=WARNING,LLVM
 # RUN: llvm-readelf --dynamic-table %t.o 2>&1 \
-# RUN:   | FileCheck %s --check-prefixes=WARNING,GNU
+# RUN:   | FileCheck %s --DFILE=%t.o --check-prefixes=WARNING,GNU
 
-# WARNING:    warning: The SHT_DYNAMIC section '.dynamic' is not at the start of PT_DYNAMIC segment
+# WARNING:    warning: '[[FILE]]': The SHT_DYNAMIC section '.dynamic' is not at the start of PT_DYNAMIC segment
 
 # LLVM:      DynamicSection [ (2 entries)
 # LLVM-NEXT:   Tag                Type     Name/Value
 # LLVM-NEXT:   0x0000000000000018 BIND_NOW 0x1
 # LLVM-NEXT:   0x0000000000000000 NULL     0x0
 # LLVM-NEXT: ]
 
 # GNU:      Dynamic section at offset 0x{{.*}} contains 2 entries:

llvm/trunk/test/tools/llvm-readobj/hex-dump.test

 # RUN: cmp %t.hexdump.out %t.hexdump.7
 
 # RUN: llvm-readelf -S %p/Inputs/trivial.obj.elf-x86-64 | FileCheck %s --check-prefix=ELF-SEC
 
 ## Both 9 and .strtab refer to .strtab. Test we dump the section only once.
 # RUN: llvm-readobj -x 9 -x 9 -x .strtab -x .strtab %p/Inputs/trivial.obj.elf-x86-64 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=ELF
 # RUN: llvm-readobj -x 9 -x .strtab -x 10 -x not_exist \
-# RUN:   %p/Inputs/trivial.obj.elf-x86-64 2>&1 | FileCheck %s --check-prefixes=ELF-WARN,ELF
+# RUN:   %p/Inputs/trivial.obj.elf-x86-64 2>&1 | FileCheck %s -DFILE=%p/Inputs/trivial.obj.elf-x86-64 --check-prefixes=ELF-WARN,ELF
 
 # ELF-SEC: [ 9] .strtab
 
-# ELF-WARN: warning: could not find section 'not_exist'
-# ELF-WARN: warning: could not find section 10
+# ELF-WARN: warning: '[[FILE]]': could not find section 'not_exist'
+# ELF-WARN: warning: '[[FILE]]': could not find section 10
 # ELF:      Hex dump of section '.strtab':
 # ELF-NEXT: 0x00000000 00747269 7669616c 2e6c6c00 6d61696e .trivial.ll.main
 # ELF-NEXT: 0x00000010 002e4c2e 73747200 70757473 00536f6d ..L.str.puts.Som
 # ELF-NEXT: 0x00000020 654f7468 65724675 6e637469 6f6e005f eOtherFunction._
 # ELF-NEXT: 0x00000030 474c4f42 414c5f4f 46465345 545f5441 GLOBAL_OFFSET_TA
 # ELF-NEXT: 0x00000040 424c455f 00                         BLE_.
 # ELF-NOT:  {{.}}
 

llvm/trunk/test/tools/llvm-readobj/mips-got.test

 RUN: not llvm-readobj --mips-plt-got %p/Inputs/relocs.obj.elf-mips 2>&1 | \
-RUN:   FileCheck %s -check-prefix GOT-OBJ
+RUN:   FileCheck %s -DFILE=%p/Inputs/relocs.obj.elf-mips -check-prefix GOT-OBJ
 RUN: llvm-readobj --mips-plt-got %p/Inputs/dynamic-table-exe.mips | \
 RUN:   FileCheck %s -check-prefix GOT-EXE
 RUN: llvm-readobj --mips-plt-got %p/Inputs/dynamic-table-so.mips | \
 RUN:   FileCheck %s -check-prefix GOT-SO
 RUN: llvm-readobj --mips-plt-got %p/Inputs/got-tls.so.elf-mips64el | \
 RUN:   FileCheck %s -check-prefix GOT-TLS
 RUN: llvm-readobj --mips-plt-got %p/Inputs/got-empty.exe.mipsel | \
 RUN:   FileCheck %s -check-prefix GOT-EMPTY
 RUN: llvm-readobj --mips-plt-got %p/Inputs/got-static.exe.mips | \
 RUN:   FileCheck %s -check-prefix GOT-STATIC
 
 RUN: not llvm-readelf --mips-plt-got %p/Inputs/relocs.obj.elf-mips 2>&1 | \
-RUN:   FileCheck %s -check-prefix GNU-GOT-OBJ
+RUN:   FileCheck %s -DFILE=%p/Inputs/relocs.obj.elf-mips -check-prefix GNU-GOT-OBJ
 RUN: llvm-readelf --mips-plt-got %p/Inputs/dynamic-table-exe.mips | \
 RUN:   FileCheck %s --strict-whitespace -check-prefix GNU-GOT-EXE
 RUN: llvm-readelf --mips-plt-got %p/Inputs/dynamic-table-so.mips | \
 RUN:   FileCheck %s --strict-whitespace -check-prefix GNU-GOT-SO
 RUN: llvm-readelf --mips-plt-got %p/Inputs/got-tls.so.elf-mips64el | \
 RUN:   FileCheck %s --strict-whitespace -check-prefix GNU-GOT-TLS
 RUN: llvm-readelf --mips-plt-got %p/Inputs/got-empty.exe.mipsel | \
 RUN:   FileCheck %s --strict-whitespace -check-prefix GNU-GOT-EMPTY
 RUN: llvm-readelf --mips-plt-got %p/Inputs/got-static.exe.mips | \
 RUN:   FileCheck %s --strict-whitespace -check-prefix GNU-GOT-STATIC
 
-GOT-OBJ: error: Cannot find .got section
+GOT-OBJ: error: '[[FILE]]': Cannot find .got section
 
 GOT-EXE:      Primary GOT {
 GOT-EXE-NEXT:   Canonical gp value: 0x418880
 GOT-EXE-NEXT:   Reserved entries [
 GOT-EXE-NEXT:     Entry {
 GOT-EXE-NEXT:       Address: 0x410890
 GOT-EXE-NEXT:       Access: -32752
 GOT-EXE-NEXT:       Initial: 0x0

 GOT-STATIC-NEXT:     Entry {
 GOT-STATIC-NEXT:       Address: 0x410120
 GOT-STATIC-NEXT:       Access: -32736
 GOT-STATIC-NEXT:       Initial: 0x400104
 GOT-STATIC-NEXT:     }
 GOT-STATIC-NEXT:   ]
 GOT-STATIC-NEXT: }
 
-GNU-GOT-OBJ: error: Cannot find .got section
+GNU-GOT-OBJ: error: '[[FILE]]': Cannot find .got section
 
 GNU-GOT-EXE:      Primary GOT:
 GNU-GOT-EXE-NEXT:  Canonical gp value: 00418880
 
 GNU-GOT-EXE:       Reserved entries:
 GNU-GOT-EXE-NEXT:    Address     Access  Initial Purpose
 GNU-GOT-EXE-NEXT:   00410890 -32752(gp) 00000000 Lazy resolver
 GNU-GOT-EXE-NEXT:   00410894 -32748(gp) 80000000 Module pointer (GNU extension)

llvm/trunk/test/tools/llvm-readobj/note-core-ntfile-bad.test

 ## Test that malformed NT_FILE sections in core files are gracefully ignored.
 
 ## llvm-mc doesn't support generating ET_CORE files; the 'Content' field in
 ## each of the following test cases were generated with the following steps:
 # $ llvm-mc -filetype=obj -triple x86_64-pc-linux-gnu tmp.s -o tmp.o
 # $ bin/llvm-objcopy --dump-section=.note.foo=tmp.txt tmp.o /dev/null
 # $ xxd -p tmp.txt | tr -d '\n'; echo
 # using the assembly shown with each test case.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1.o
-# RUN: llvm-readelf -n %t1.o 2>&1 | FileCheck %s --check-prefix=ERR-HEADER-SHORT
-# ERR-HEADER-SHORT: warning: malformed note: header too short
+# RUN: llvm-readelf -n %t1.o 2>&1 | FileCheck -DFILE=%t1.o %s --check-prefix=ERR-HEADER-SHORT
+# ERR-HEADER-SHORT: warning: '[[FILE]]': malformed note: header too short
 
 # .section ".note.foo", "a"
 #       .align 4
 #       .long 5 /* namesz */
 #       .long end - begin /* descsz */
 #       .long 0x46494c45 /* type = NT_FILE */
 #       .asciz "CORE"
 #       .align 4
- Name:    .note.foo
     Type:    SHT_NOTE
     Content: 0500000008000000454C4946434F5245000000000000000000000000
 ProgramHeaders:
   - Type:        PT_NOTE
     Sections:
       - Section: .note.foo
 
 # RUN: yaml2obj --docnum=2 %s -o %t2.o
-# RUN: llvm-readelf -n %t2.o 2>&1 | FileCheck %s --check-prefix=ERR-NULL-TERM
-# ERR-NULL-TERM: warning: malformed note: not NUL terminated
+# RUN: llvm-readelf -n %t2.o 2>&1 | FileCheck -DFILE=%t2.o %s --check-prefix=ERR-NULL-TERM
+# ERR-NULL-TERM: warning: '[[FILE]]': malformed note: not NUL terminated
 
 # .section ".note.foo", "a"
 #       .align 4
 #       .long 5 /* namesz */
 #       .long end - begin /* descsz */
 #       .long 0x46494c45 /* type = NT_FILE */
 #       .asciz "CORE"
 #       .align 4
- Name:    .note.foo
     Type:    SHT_NOTE
     Content: 050000002C000000454C4946434F5245000000000100000000000000001000000000000000100000000000000020000000000000003000000000000078787878
 ProgramHeaders:
   - Type:        PT_NOTE
     Sections:
       - Section: .note.foo
 
 # RUN: yaml2obj --docnum=3 %s -o %t3.o
-# RUN: llvm-readelf -n %t3.o 2>&1 | FileCheck %s --check-prefix=ERR-FILE-COUNT
-# ERR-FILE-COUNT: warning: malformed note: too short for number of files
+# RUN: llvm-readelf -n %t3.o 2>&1 | FileCheck -DFILE=%t3.o %s --check-prefix=ERR-FILE-COUNT
+# ERR-FILE-COUNT: warning: '[[FILE]]': malformed note: too short for number of files
 
 # .section ".note.foo", "a"
 #       .align 4
 #       .long 5 /* namesz */
 #       .long end - begin /* descsz */
 #       .long 0x46494c45 /* type = NT_FILE */
 #       .asciz "CORE"
 #       .align 4
- Name:    .note.foo
     Type:    SHT_NOTE
     Content: 050000002C000000454C4946434F5245000000000200000000000000001000000000000000100000000000000020000000000000003000000000000078797A00
 ProgramHeaders:
   - Type:        PT_NOTE
     Sections:
       - Section: .note.foo
 
 # RUN: yaml2obj --docnum=4 %s -o %t4.o
-# RUN: llvm-readelf -n %t4.o 2>&1 | FileCheck %s --check-prefix=ERR-FILE-END-EARLY
-# ERR-FILE-END-EARLY: warning: malformed note: too few filenames
+# RUN: llvm-readelf -n %t4.o 2>&1 | FileCheck -DFILE=%t4.o %s --check-prefix=ERR-FILE-END-EARLY
+# ERR-FILE-END-EARLY: warning: '[[FILE]]': malformed note: too few filenames
 
 # .section ".note.foo", "a"
 #       .align 4
 #       .long 5 /* namesz */
 #       .long end - begin /* descsz */
 #       .long 0x46494c45 /* type = NT_FILE */
 #       .asciz "CORE"
 #       .align 4

llvm/trunk/test/tools/llvm-readobj/string-dump.test

 # CHECK-NEXT: [ 9] some
 # CHECK-NEXT: [ e] strings
 # CHECK-EMPTY:
 # CHECK-NEXT: String dump of section '.not_null_terminated':
 # CHECK-NEXT: [ 0] no
 # CHECK-NEXT: [ 3] null{{$}}
 # CHECK-NOT:  {{.}}
 
-# RUN: llvm-readobj --string-dump=does_not_exist %t 2>&1 | FileCheck %s --check-prefix=WARN1
-# RUN: llvm-readobj --string-dump=42 %t 2>&1 | FileCheck %s --check-prefix=WARN2
+# RUN: llvm-readobj --string-dump=does_not_exist %t 2>&1 | FileCheck -DFILE=%t %s --check-prefix=WARN1
+# RUN: llvm-readobj --string-dump=42 %t 2>&1 | FileCheck %s  -DFILE=%t --check-prefix=WARN2
 
-# RUN: llvm-readelf --string-dump=does_not_exist %t 2>&1 | FileCheck %s --check-prefix=WARN1
-# RUN: llvm-readelf --string-dump=42 %t 2>&1 | FileCheck %s --check-prefix=WARN2
+# RUN: llvm-readelf --string-dump=does_not_exist %t 2>&1 | FileCheck -DFILE=%t %s --check-prefix=WARN1
+# RUN: llvm-readelf --string-dump=42 %t 2>&1 | FileCheck %s  -DFILE=%t --check-prefix=WARN2
 
-# WARN1: warning: could not find section 'does_not_exist'
-# WARN2: warning: could not find section 42
+# WARN1: warning: '[[FILE]]': could not find section 'does_not_exist'
+# WARN2: warning: '[[FILE]]': could not find section 42
 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_REL
   Machine:         EM_X86_64
 Sections:
   - Name: .strings
     Type: SHT_PROGBITS
     Content: 686572650061726500736f6d6500737472696e677300
   - Name: .not_null_terminated
     Type: SHT_PROGBITS
     Content: 6e6f006e756c6c

llvm/trunk/tools/llvm-readobj/COFFDumper.cpp

strftime(FormattedTime, 20, "%Y-%m-%d %H:%M:%S", gmtime(&TDS));
     W.printNumber("OptionalHeaderSize", Obj->getSizeOfOptionalHeader());
     W.printFlags ("Characteristics", Obj->getCharacteristics(),
                     makeArrayRef(ImageFileCharacteristics));
   }
 
   // Print PE header. This header does not exist if this is an object file and
   // not an executable.
   const pe32_header *PEHeader = nullptr;
-  error(Obj->getPE32Header(PEHeader));
+  if (std::error_code EC = Obj->getPE32Header(PEHeader))
+    reportError(EC, Obj->getFileName());
   if (PEHeader)
     printPEHeader<pe32_header>(PEHeader);
 
   const pe32plus_header *PEPlusHeader = nullptr;
-  error(Obj->getPE32PlusHeader(PEPlusHeader));
+  if (std::error_code EC = Obj->getPE32PlusHeader(PEPlusHeader))
+    reportError(EC, Obj->getFileName());
   if (PEPlusHeader)
     printPEHeader<pe32plus_header>(PEPlusHeader);
 
   if (const dos_header *DH = Obj->getDOSHeader())
     printDOSHeader(DH);
 }
 
 void COFFDumper::printDOSHeader(const dos_header *DH) {
for (const debug_directory &D : Obj->debug_directories()) {
     W.printHex("MinorVersion", D.MinorVersion);
     W.printEnum("Type", D.Type, makeArrayRef(ImageDebugType));
     W.printHex("SizeOfData", D.SizeOfData);
     W.printHex("AddressOfRawData", D.AddressOfRawData);
     W.printHex("PointerToRawData", D.PointerToRawData);
     if (D.Type == COFF::IMAGE_DEBUG_TYPE_CODEVIEW) {
       const codeview::DebugInfo *DebugInfo;
       StringRef PDBFileName;
-      error(Obj->getDebugPDBInfo(&D, DebugInfo, PDBFileName));
+      if (std::error_code EC = Obj->getDebugPDBInfo(&D, DebugInfo, PDBFileName))
+        reportError(EC, Obj->getFileName());
+
       DictScope PDBScope(W, "PDBInfo");
       W.printHex("PDBSignature", DebugInfo->Signature.CVSignature);
       if (DebugInfo->Signature.CVSignature == OMF::Signature::PDB70) {
         W.printBinary("PDBGUID", makeArrayRef(DebugInfo->PDB70.Signature));
         W.printNumber("PDBAge", DebugInfo->PDB70.Age);
         W.printString("PDBFileName", PDBFileName);
       }
     } else if (D.SizeOfData != 0) {
       // FIXME: Type values of 12 and 13 are commonly observed but are not in
       // the documented type enum.  Figure out what they mean.
       ArrayRef<uint8_t> RawData;
-      error(
-          Obj->getRvaAndSizeAsBytes(D.AddressOfRawData, D.SizeOfData, RawData));
+      if (std::error_code EC = Obj->getRvaAndSizeAsBytes(D.AddressOfRawData,
+                                                         D.SizeOfData, RawData))
+        reportError(EC, Obj->getFileName());
       W.printBinaryBlock("RawData", RawData);
     }
   }
 }
 
 void COFFDumper::printRVATable(uint64_t TableVA, uint64_t Count,
                                uint64_t EntrySize, PrintExtraCB PrintExtra) {
   uintptr_t TableStart, TableEnd;
-  error(Obj->getVaPtr(TableVA, TableStart));
-  error(Obj->getVaPtr(TableVA + Count * EntrySize - 1, TableEnd));
+  if (std::error_code EC = Obj->getVaPtr(TableVA, TableStart))
+    reportError(EC, Obj->getFileName());
+  if (std::error_code EC =
+          Obj->getVaPtr(TableVA + Count * EntrySize - 1, TableEnd))
+    reportError(EC, Obj->getFileName());
   TableEnd++;
   for (uintptr_t I = TableStart; I < TableEnd; I += EntrySize) {
     uint32_t RVA = *reinterpret_cast<const ulittle32_t *>(I);
     raw_ostream &OS = W.startLine();
     OS << W.hex(Obj->getImageBase() + RVA);
     if (PrintExtra)
       PrintExtra(OS, reinterpret_cast<const uint8_t *>(I));
     OS << '\n';
void COFFDumper::printCodeViewSymbolSection(StringRef SectionName,
   W.printNumber("Section", SectionName, Obj->getSectionID(Section));
 
   uint32_t Magic;
   if (Error E = consume(Data, Magic))
     reportError(std::move(E), Obj->getFileName());
 
   W.printHex("Magic", Magic);
   if (Magic != COFF::DEBUG_SECTION_MAGIC)
-    return error(object_error::parse_failed);
+    reportError(object_error::parse_failed, Obj->getFileName());
 
   BinaryStreamReader FSReader(Data, support::little);
   initializeFileAndStringTables(FSReader);
 
   // TODO: Convert this over to using ModuleSubstreamVisitor.
   while (!Data.empty()) {
     // The section consists of a number of subsection in the following format:
     // |SubSectionType|SubSectionSize|Contents...|
if (SubType & SubsectionIgnoreFlag) {
       W.printHex("IgnoredSubsectionKind", SubType);
       SubType &= ~SubsectionIgnoreFlag;
     }
     W.printEnum("SubSectionType", SubType, makeArrayRef(SubSectionTypes));
     W.printHex("SubSectionSize", SubSectionSize);
 
     // Get the contents of the subsection.
     if (SubSectionSize > Data.size())
-      return error(object_error::parse_failed);
+      return reportError(object_error::parse_failed, Obj->getFileName());
     StringRef Contents = Data.substr(0, SubSectionSize);
 
     // Add SubSectionSize to the current offset and align that offset to find
     // the next subsection.
     size_t SectionOffset = Data.data() - SectionContents.data();
     size_t NextOffset = SectionOffset + SubSectionSize;
     NextOffset = alignTo(NextOffset, 4);
     if (NextOffset > SectionContents.size())
-      return error(object_error::parse_failed);
+      return reportError(object_error::parse_failed, Obj->getFileName());
     Data = SectionContents.drop_front(NextOffset);
 
     // Optionally print the subsection bytes in case our parsing gets confused
     // later.
     if (opts::CodeViewSubsectionBytes)
       printBinaryBlockWithRelocs("SubSectionContents", Section, SectionContents,
                                  Contents);
 
while (!Data.empty()) {
     case DebugSubsectionKind::Lines: {
       // Holds a PC to file:line table.  Some data to parse this subsection is
       // stored in the other subsections, so just check sanity and store the
       // pointers for deferred processing.
 
       if (SubSectionSize < 12) {
         // There should be at least three words to store two function
         // relocations and size of the code.
-        error(object_error::parse_failed);
+        reportError(object_error::parse_failed, Obj->getFileName());
         return;
       }
 
       StringRef LinkageName;
-      error(resolveSymbolName(Obj->getCOFFSection(Section), SectionOffset,
-                              LinkageName));
+      if (std::error_code EC = resolveSymbolName(Obj->getCOFFSection(Section),
+                                                 SectionOffset, LinkageName))
+        reportError(EC, Obj->getFileName());
+
       W.printString("LinkageName", LinkageName);
       if (FunctionLineTables.count(LinkageName) != 0) {
         // Saw debug info for this function already?
-        error(object_error::parse_failed);
+        reportError(object_error::parse_failed, Obj->getFileName());
         return;
       }
 
       FunctionLineTables[LinkageName] = Contents;
       FunctionNames.push_back(LinkageName);
       break;
     }
     case DebugSubsectionKind::FrameData: {
       // First four bytes is a relocation against the function.
       BinaryStreamReader SR(Contents, llvm::support::little);
 
       DebugFrameDataSubsectionRef FrameData;
       if (Error E = FrameData.initialize(SR))
         reportError(std::move(E), Obj->getFileName());
 
       StringRef LinkageName;
-      error(resolveSymbolName(Obj->getCOFFSection(Section), SectionContents,
-                              FrameData.getRelocPtr(), LinkageName));
+      if (std::error_code EC =
+              resolveSymbolName(Obj->getCOFFSection(Section), SectionContents,
+                                FrameData.getRelocPtr(), LinkageName))
+        reportError(EC, Obj->getFileName());
       W.printString("LinkageName", LinkageName);
 
       // To find the active frame description, search this array for the
       // smallest PC range that includes the current PC.
       for (const auto &FD : FrameData) {
         StringRef FrameFunc = unwrapOrError(
             Obj->getFileName(), CVStringTable.getString(FD.FrameFunc));
 
for (unsigned I = 0, E = FunctionNames.size(); I != E; ++I) {
     W.printHex("CodeSize", LineInfo.header()->CodeSize);
     for (const auto &Entry : LineInfo) {
 
       ListScope S(W, "FilenameSegment");
       printFileNameForOffset("Filename", Entry.NameIndex);
       uint32_t ColumnIndex = 0;
       for (const auto &Line : Entry.LineNumbers) {
         if (Line.Offset >= LineInfo.header()->CodeSize) {
-          error(object_error::parse_failed);
+          reportError(object_error::parse_failed, Obj->getFileName());
           return;
         }
 
         std::string PC = formatv("+{0:X}", uint32_t(Line.Offset));
         ListScope PCScope(W, PC);
         codeview::LineInfo LI(Line.Flags);
 
         if (LI.isAlwaysStepInto())
void COFFDumper::printCodeViewSymbolsSubsection(StringRef Subsection,
   ArrayRef<uint8_t> BinaryData(Subsection.bytes_begin(),
                                Subsection.bytes_end());
   auto CODD = std::make_unique<COFFObjectDumpDelegate>(*this, Section, Obj,
                                                         SectionContents);
   CVSymbolDumper CVSD(W, Types, CodeViewContainer::ObjectFile, std::move(CODD),
                       CompilationCPUType, opts::CodeViewSubsectionBytes);
   CVSymbolArray Symbols;
   BinaryStreamReader Reader(BinaryData, llvm::support::little);
-  if (auto EC = Reader.readArray(Symbols, Reader.getLength())) {
-    consumeError(std::move(EC));
+  if (Error E = Reader.readArray(Symbols, Reader.getLength())) {
     W.flush();
-    error(object_error::parse_failed);
+    reportError(std::move(E), Obj->getFileName());
   }
 
   if (Error E = CVSD.dump(Symbols)) {
     W.flush();
     reportError(std::move(E), Obj->getFileName());
   }
   CompilationCPUType = CVSD.getCompilationCPUType();
   W.flush();
if (Lines.hasExtraFiles()) {
       }
     }
   }
 }
 
 StringRef COFFDumper::getFileNameForFileOffset(uint32_t FileOffset) {
   // The file checksum subsection should precede all references to it.
   if (!CVFileChecksumTable.valid() || !CVStringTable.valid())
-    error(object_error::parse_failed);
+    reportError(object_error::parse_failed, Obj->getFileName());
 
   auto Iter = CVFileChecksumTable.getArray().at(FileOffset);
 
   // Check if the file checksum table offset is valid.
   if (Iter == CVFileChecksumTable.end())
-    error(object_error::parse_failed);
+    reportError(object_error::parse_failed, Obj->getFileName());
 
   return unwrapOrError(Obj->getFileName(),
                        CVStringTable.getString(Iter->FileNameOffset));
 }
 
 void COFFDumper::printFileNameForOffset(StringRef Label, uint32_t FileOffset) {
   W.printHex(Label, getFileNameForFileOffset(FileOffset), FileOffset);
 }
 
 void COFFDumper::mergeCodeViewTypes(MergingTypeTableBuilder &CVIDs,
                                     MergingTypeTableBuilder &CVTypes,
                                     GlobalTypeTableBuilder &GlobalCVIDs,
                                     GlobalTypeTableBuilder &GlobalCVTypes,
                                     bool GHash) {
   for (const SectionRef &S : Obj->sections()) {
     StringRef SectionName = unwrapOrError(Obj->getFileName(), S.getName());
     if (SectionName == ".debug$T") {
       StringRef Data = unwrapOrError(Obj->getFileName(), S.getContents());
       uint32_t Magic;
       if (Error E = consume(Data, Magic))
         reportError(std::move(E), Obj->getFileName());
 
       if (Magic != 4)
-        error(object_error::parse_failed);
+        reportError(object_error::parse_failed, Obj->getFileName());
 
       CVTypeArray Types;
       BinaryStreamReader Reader(Data, llvm::support::little);
       if (auto EC = Reader.readArray(Types, Reader.getLength())) {
         consumeError(std::move(EC));
         W.flush();
-        error(object_error::parse_failed);
+        reportError(object_error::parse_failed, Obj->getFileName());
       }
       SmallVector<TypeIndex, 128> SourceToDest;
       Optional<uint32_t> PCHSignature;
       if (GHash) {
         std::vector<GloballyHashedType> Hashes =
             GloballyHashedType::hashTypes(Types);
         if (Error E =
                 mergeTypeAndIdRecords(GlobalCVIDs, GlobalCVTypes, SourceToDest,
if (opts::CodeViewSubsectionBytes)
     W.printBinaryBlock("Data", Data);
 
   uint32_t Magic;
   if (Error E = consume(Data, Magic))
     reportError(std::move(E), Obj->getFileName());
 
   W.printHex("Magic", Magic);
   if (Magic != COFF::DEBUG_SECTION_MAGIC)
-    return error(object_error::parse_failed);
+    reportError(object_error::parse_failed, Obj->getFileName());
 
   Types.reset(Data, 100);
 
   TypeDumpVisitor TDV(Types, &W, opts::CodeViewSubsectionBytes);
   if (Error E = codeview::visitTypeStream(Types, TDV))
     reportError(std::move(E), Obj->getFileName());
 
   W.flush();
void COFFDumper::printRelocation(const SectionRef &Section,
   uint64_t RelocType = Reloc.getType();
   SmallString<32> RelocName;
   StringRef SymbolName;
   Reloc.getTypeName(RelocName);
   symbol_iterator Symbol = Reloc.getSymbol();
   int64_t SymbolIndex = -1;
   if (Symbol != Obj->symbol_end()) {
     Expected<StringRef> SymbolNameOrErr = Symbol->getName();
-    error(errorToErrorCode(SymbolNameOrErr.takeError()));
+    if (!SymbolNameOrErr)
+      reportError(SymbolNameOrErr.takeError(), Obj->getFileName());
+
     SymbolName = *SymbolNameOrErr;
     SymbolIndex = Obj->getSymbolIndex(Obj->getCOFFSymbol(*Symbol));
   }
 
   if (opts::ExpandRelocs) {
     DictScope Group(W, "Relocation");
     W.printHex("Offset", Offset);
     W.printNumber("Type", RelocName, RelocType);
W.printEnum  ("ComplexType", Symbol.getComplexType(),
                                                    makeArrayRef(ImageSymDType));
   W.printEnum  ("StorageClass", Symbol.getStorageClass(),
                                                    makeArrayRef(ImageSymClass));
   W.printNumber("AuxSymbolCount", Symbol.getNumberOfAuxSymbols());
 
   for (uint8_t I = 0; I < Symbol.getNumberOfAuxSymbols(); ++I) {
     if (Symbol.isFunctionDefinition()) {
       const coff_aux_function_definition *Aux;
-      error(getSymbolAuxData(Obj, Symbol, I, Aux));
+      if (std::error_code EC = getSymbolAuxData(Obj, Symbol, I, Aux))
+        reportError(EC, Obj->getFileName());
 
       DictScope AS(W, "AuxFunctionDef");
       W.printNumber("TagIndex", Aux->TagIndex);
       W.printNumber("TotalSize", Aux->TotalSize);
       W.printHex("PointerToLineNumber", Aux->PointerToLinenumber);
       W.printHex("PointerToNextFunction", Aux->PointerToNextFunction);
 
     } else if (Symbol.isAnyUndefined()) {
       const coff_aux_weak_external *Aux;
-      error(getSymbolAuxData(Obj, Symbol, I, Aux));
+      if (std::error_code EC = getSymbolAuxData(Obj, Symbol, I, Aux))
+        reportError(EC, Obj->getFileName());
 
       Expected<COFFSymbolRef> Linked = Obj->getSymbol(Aux->TagIndex);
       StringRef LinkedName;
       std::error_code EC = errorToErrorCode(Linked.takeError());
       if (EC || (EC = Obj->getSymbolName(*Linked, LinkedName))) {
         LinkedName = "";
-        error(EC);
+        reportError(EC, Obj->getFileName());
       }
 
       DictScope AS(W, "AuxWeakExternal");
       W.printNumber("Linked", LinkedName, Aux->TagIndex);
       W.printEnum  ("Search", Aux->Characteristics,
                     makeArrayRef(WeakExternalCharacteristics));
 
     } else if (Symbol.isFileRecord()) {
       const char *FileName;
-      error(getSymbolAuxData(Obj, Symbol, I, FileName));
-
+      if (std::error_code EC = getSymbolAuxData(Obj, Symbol, I, FileName))
+        reportError(EC, Obj->getFileName());
       DictScope AS(W, "AuxFileRecord");
 
       StringRef Name(FileName, Symbol.getNumberOfAuxSymbols() *
                                    Obj->getSymbolTableEntrySize());
       W.printString("FileName", Name.rtrim(StringRef("\0", 1)));
       break;
     } else if (Symbol.isSectionDefinition()) {
       const coff_aux_section_definition *Aux;
-      error(getSymbolAuxData(Obj, Symbol, I, Aux));
+      if (std::error_code EC = getSymbolAuxData(Obj, Symbol, I, Aux))
+        reportError(EC, Obj->getFileName());
 
       int32_t AuxNumber = Aux->getNumber(Symbol.isBigObj());
 
       DictScope AS(W, "AuxSectionDef");
       W.printNumber("Length", Aux->Length);
       W.printNumber("RelocationCount", Aux->NumberOfRelocations);
       W.printNumber("LineNumberCount", Aux->NumberOfLinenumbers);
       W.printHex("Checksum", Aux->CheckSum);
       W.printNumber("Number", AuxNumber);
       W.printEnum("Selection", Aux->Selection, makeArrayRef(ImageCOMDATSelect));
 
       if (Section && Section->Characteristics & COFF::IMAGE_SCN_LNK_COMDAT
           && Aux->Selection == COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE) {
         const coff_section *Assoc;
         StringRef AssocName = "";
         if (std::error_code EC = Obj->getSection(AuxNumber, Assoc))
-          error(EC);
+          reportError(EC, Obj->getFileName());
         Expected<StringRef> Res = getSectionName(Obj, AuxNumber, Assoc);
         if (!Res)
           reportError(Res.takeError(), Obj->getFileName());
         AssocName = *Res;
 
         W.printNumber("AssocSection", AssocName, AuxNumber);
       }
     } else if (Symbol.isCLRToken()) {
       const coff_aux_clr_token *Aux;
-      error(getSymbolAuxData(Obj, Symbol, I, Aux));
+      if (std::error_code EC = getSymbolAuxData(Obj, Symbol, I, Aux))
+        reportError(EC, Obj->getFileName());
 
       Expected<COFFSymbolRef> ReferredSym =
           Obj->getSymbol(Aux->SymbolTableIndex);
       StringRef ReferredName;
       std::error_code EC = errorToErrorCode(ReferredSym.takeError());
       if (EC || (EC = Obj->getSymbolName(*ReferredSym, ReferredName))) {
         ReferredName = "";
-        error(EC);
+        reportError(EC, Obj->getFileName());
       }
 
       DictScope AS(W, "AuxCLRToken");
       W.printNumber("AuxType", Aux->AuxType);
       W.printNumber("Reserved", Aux->Reserved);
       W.printNumber("SymbolTableIndex", ReferredName, Aux->SymbolTableIndex);
 
     } else {
for (const auto &L : Libs) {
     W.startLine() << L << "\n";
   }
 }
 
 void COFFDumper::printImportedSymbols(
     iterator_range<imported_symbol_iterator> Range) {
   for (const ImportedSymbolRef &I : Range) {
     StringRef Sym;
-    error(I.getSymbolName(Sym));
+    if (std::error_code EC = I.getSymbolName(Sym))
+      reportError(EC, Obj->getFileName());
     uint16_t Ordinal;
-    error(I.getOrdinal(Ordinal));
+    if (std::error_code EC = I.getOrdinal(Ordinal))
+      reportError(EC, Obj->getFileName());
     W.printNumber("Symbol", Sym, Ordinal);
   }
 }
 
 void COFFDumper::printDelayImportedSymbols(
     const DelayImportDirectoryEntryRef &I,
     iterator_range<imported_symbol_iterator> Range) {
   int Index = 0;
   for (const ImportedSymbolRef &S : Range) {
     DictScope Import(W, "Import");
     StringRef Sym;
-    error(S.getSymbolName(Sym));
+    if (std::error_code EC = S.getSymbolName(Sym))
+      reportError(EC, Obj->getFileName());
+
     uint16_t Ordinal;
-    error(S.getOrdinal(Ordinal));
+    if (std::error_code EC = S.getOrdinal(Ordinal))
+      reportError(EC, Obj->getFileName());
     W.printNumber("Symbol", Sym, Ordinal);
+
     uint64_t Addr;
-    error(I.getImportAddress(Index++, Addr));
+    if (std::error_code EC = I.getImportAddress(Index++, Addr))
+      reportError(EC, Obj->getFileName());
     W.printHex("Address", Addr);
   }
 }
 
 void COFFDumper::printCOFFImports() {
   // Regular imports
   for (const ImportDirectoryEntryRef &I : Obj->import_directories()) {
     DictScope Import(W, "Import");
     StringRef Name;
-    error(I.getName(Name));
+    if (std::error_code EC = I.getName(Name))
+      reportError(EC, Obj->getFileName());
     W.printString("Name", Name);
     uint32_t ILTAddr;
-    error(I.getImportLookupTableRVA(ILTAddr));
+    if (std::error_code EC = I.getImportLookupTableRVA(ILTAddr))
+      reportError(EC, Obj->getFileName());
     W.printHex("ImportLookupTableRVA", ILTAddr);
     uint32_t IATAddr;
-    error(I.getImportAddressTableRVA(IATAddr));
+    if (std::error_code EC = I.getImportAddressTableRVA(IATAddr))
+      reportError(EC, Obj->getFileName());
     W.printHex("ImportAddressTableRVA", IATAddr);
     // The import lookup table can be missing with certain older linkers, so
     // fall back to the import address table in that case.
     if (ILTAddr)
       printImportedSymbols(I.lookup_table_symbols());
     else
       printImportedSymbols(I.imported_symbols());
   }
 
   // Delay imports
   for (const DelayImportDirectoryEntryRef &I : Obj->delay_import_directories()) {
     DictScope Import(W, "DelayImport");
     StringRef Name;
-    error(I.getName(Name));
+    if (std::error_code EC = I.getName(Name))
+      reportError(EC, Obj->getFileName());
     W.printString("Name", Name);
     const delay_import_directory_table_entry *Table;
-    error(I.getDelayImportTable(Table));
+    if (std::error_code EC = I.getDelayImportTable(Table))
+      reportError(EC, Obj->getFileName());
     W.printHex("Attributes", Table->Attributes);
     W.printHex("ModuleHandle", Table->ModuleHandle);
     W.printHex("ImportAddressTable", Table->DelayImportAddressTable);
     W.printHex("ImportNameTable", Table->DelayImportNameTable);
     W.printHex("BoundDelayImportTable", Table->BoundDelayImportTable);
     W.printHex("UnloadDelayImportTable", Table->UnloadDelayImportTable);
     printDelayImportedSymbols(I, I.imported_symbols());
   }
 }
 
 void COFFDumper::printCOFFExports() {
   for (const ExportDirectoryEntryRef &E : Obj->export_directories()) {
     DictScope Export(W, "Export");
 
     StringRef Name;
     uint32_t Ordinal, RVA;
 
-    error(E.getSymbolName(Name));
-    error(E.getOrdinal(Ordinal));
-    error(E.getExportRVA(RVA));
+    if (std::error_code EC = E.getSymbolName(Name))
+      reportError(EC, Obj->getFileName());
+    if (std::error_code EC = E.getOrdinal(Ordinal))
+      reportError(EC, Obj->getFileName());
+    if (std::error_code EC = E.getExportRVA(RVA))
+      reportError(EC, Obj->getFileName());
 
     W.printNumber("Ordinal", Ordinal);
     W.printString("Name", Name);
     W.printHex("RVA", RVA);
   }
 }
 
 void COFFDumper::printCOFFDirectives() {
static std::string getBaseRelocTypeName(uint8_t Type) {
   }
 }
 
 void COFFDumper::printCOFFBaseReloc() {
   ListScope D(W, "BaseReloc");
   for (const BaseRelocRef &I : Obj->base_relocs()) {
     uint8_t Type;
     uint32_t RVA;
-    error(I.getRVA(RVA));
-    error(I.getType(Type));
+    if (std::error_code EC = I.getRVA(RVA))
+      reportError(EC, Obj->getFileName());
+    if (std::error_code EC = I.getType(Type))
+      reportError(EC, Obj->getFileName());
     DictScope Import(W, "Entry");
     W.printString("Type", getBaseRelocTypeName(Type));
     W.printHex("Address", RVA);
   }
 }
 
 void COFFDumper::printCOFFResources() {
   ListScope ResourcesD(W, "Resources");
if (i < Table.NumberOfNameEntries) {
         EndianCorrectedNameString.resize(RawEntryNameString.size() + 1);
         std::copy(RawEntryNameString.begin(), RawEntryNameString.end(),
                   EndianCorrectedNameString.begin() + 1);
         EndianCorrectedNameString[0] = UNI_UTF16_BYTE_ORDER_MARK_SWAPPED;
         RawEntryNameString = makeArrayRef(EndianCorrectedNameString);
       }
       std::string EntryNameString;
       if (!llvm::convertUTF16ToUTF8String(RawEntryNameString, EntryNameString))
-        error(object_error::parse_failed);
+        reportError(object_error::parse_failed, Obj->getFileName());
       OS << ": ";
       OS << EntryNameString;
     } else {
       if (Level == "Type") {
         OS << ": ";
         printResourceTypeName(Entry.Identifier.ID, OS);
         IDStr = IDStr.slice(0, IDStr.find_first_of(")", 0) + 1);
       } else {
void COFFDumper::printAddrsig() {
   ListScope L(W, "Addrsig");
   const uint8_t *Cur = AddrsigContents.bytes_begin();
   const uint8_t *End = AddrsigContents.bytes_end();
   while (Cur != End) {
     unsigned Size;
     const char *Err;
     uint64_t SymIndex = decodeULEB128(Cur, &Size, End, &Err);
     if (Err)
-      reportError(Err);
+      reportError(createError(Err), Obj->getFileName());
 
     Expected<COFFSymbolRef> Sym = Obj->getSymbol(SymIndex);
     StringRef SymName;
     std::error_code EC = errorToErrorCode(Sym.takeError());
     if (EC || (EC = Obj->getSymbolName(*Sym, SymName))) {
       SymName = "";
-      error(EC);
+      reportError(EC, Obj->getFileName());
     }
 
     W.printNumber("Sym", SymName, SymIndex);
     Cur += Size;
   }
 }
 
 void llvm::dumpCodeViewMergedTypes(ScopedPrinter &Writer,

llvm/trunk/tools/llvm-readobj/DwarfCFIEHPrinter.h

 
 public:
   PrinterContext(ScopedPrinter &W, const object::ELFObjectFile<ELFT> *ObjF)
       : W(W), ObjF(ObjF) {}
 
   void printUnwindInformation() const;
 };
 
-template <class ELFO>
-static const typename ELFO::Elf_Shdr *findSectionByAddress(const ELFO *Obj,
-                                                           uint64_t Addr) {
-  auto Sections = Obj->sections();
+template <class ELFT>
+static const typename object::ELFObjectFile<ELFT>::Elf_Shdr *
+findSectionByAddress(const object::ELFObjectFile<ELFT> *ObjF, uint64_t Addr) {
+  auto Sections = ObjF->getELFFile()->sections();
   if (Error E = Sections.takeError())
-    reportError(toString(std::move(E)));
+    reportError(std::move(E), ObjF->getFileName());
 
   for (const auto &Shdr : *Sections)
     if (Shdr.sh_addr == Addr)
       return &Shdr;
   return nullptr;
 }
 
 template <typename ELFT>
 void PrinterContext<ELFT>::printUnwindInformation() const {
   const object::ELFFile<ELFT> *Obj = ObjF->getELFFile();
   const typename ELFT::Phdr *EHFramePhdr = nullptr;
 
   auto PHs = Obj->program_headers();
   if (Error E = PHs.takeError())
-    reportError(toString(std::move(E)));
+    reportError(std::move(E), ObjF->getFileName());
 
   for (const auto &Phdr : *PHs) {
     if (Phdr.p_type == ELF::PT_GNU_EH_FRAME) {
       EHFramePhdr = &Phdr;
       if (Phdr.p_memsz != Phdr.p_filesz)
-        reportError("p_memsz does not match p_filesz for GNU_EH_FRAME");
+        reportError(object::createError(
+                        "p_memsz does not match p_filesz for GNU_EH_FRAME"),
+                    ObjF->getFileName());
       break;
     }
   }
 
   if (EHFramePhdr)
     printEHFrameHdr(EHFramePhdr->p_offset, EHFramePhdr->p_vaddr,
                     EHFramePhdr->p_memsz);
 
   auto Sections = Obj->sections();
   if (Error E = Sections.takeError())
-    reportError(toString(std::move(E)));
+    reportError(std::move(E), ObjF->getFileName());
 
   for (const auto &Shdr : *Sections) {
     auto SectionName = Obj->getSectionName(&Shdr);
     if (Error E = SectionName.takeError())
-      reportError(toString(std::move(E)));
+      reportError(std::move(E), ObjF->getFileName());
 
     if (*SectionName == ".eh_frame")
       printEHFrame(&Shdr);
   }
 }
 
 template <typename ELFT>
 void PrinterContext<ELFT>::printEHFrameHdr(uint64_t EHFrameHdrOffset,
                                            uint64_t EHFrameHdrAddress,
                                            uint64_t EHFrameHdrSize) const {
   ListScope L(W, "EH_FRAME Header");
   W.startLine() << format("Address: 0x%" PRIx64 "\n", EHFrameHdrAddress);
   W.startLine() << format("Offset: 0x%" PRIx64 "\n", EHFrameHdrOffset);
   W.startLine() << format("Size: 0x%" PRIx64 "\n", EHFrameHdrSize);
 
   const object::ELFFile<ELFT> *Obj = ObjF->getELFFile();
-  const auto *EHFrameHdrShdr = findSectionByAddress(Obj, EHFrameHdrAddress);
+  const auto *EHFrameHdrShdr = findSectionByAddress(ObjF, EHFrameHdrAddress);
   if (EHFrameHdrShdr) {
     auto SectionName = Obj->getSectionName(EHFrameHdrShdr);
     if (Error E = SectionName.takeError())
-      reportError(toString(std::move(E)));
+      reportError(std::move(E), ObjF->getFileName());
 
     W.printString("Corresponding Section", *SectionName);
   }
 
   DataExtractor DE(
       StringRef(reinterpret_cast<const char *>(Obj->base()) + EHFrameHdrOffset,
                 EHFrameHdrSize),
       ELFT::TargetEndianness == support::endianness::little,
       ELFT::Is64Bits ? 8 : 4);
 
   DictScope D(W, "Header");
   uint64_t Offset = 0;
 
   auto Version = DE.getU8(&Offset);
   W.printNumber("version", Version);
   if (Version != 1)
-    reportError("only version 1 of .eh_frame_hdr is supported");
+    reportError(
+        object::createError("only version 1 of .eh_frame_hdr is supported"),
+        ObjF->getFileName());
 
   uint64_t EHFramePtrEnc = DE.getU8(&Offset);
   W.startLine() << format("eh_frame_ptr_enc: 0x%" PRIx64 "\n", EHFramePtrEnc);
   if (EHFramePtrEnc != (dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4))
-    reportError("unexpected encoding eh_frame_ptr_enc");
+    reportError(object::createError("unexpected encoding eh_frame_ptr_enc"),
+                ObjF->getFileName());
 
   uint64_t FDECountEnc = DE.getU8(&Offset);
   W.startLine() << format("fde_count_enc: 0x%" PRIx64 "\n", FDECountEnc);
   if (FDECountEnc != dwarf::DW_EH_PE_udata4)
-    reportError("unexpected encoding fde_count_enc");
+    reportError(object::createError("unexpected encoding fde_count_enc"),
+                ObjF->getFileName());
 
   uint64_t TableEnc = DE.getU8(&Offset);
   W.startLine() << format("table_enc: 0x%" PRIx64 "\n", TableEnc);
   if (TableEnc != (dwarf::DW_EH_PE_datarel | dwarf::DW_EH_PE_sdata4))
-    reportError("unexpected encoding table_enc");
+    reportError(object::createError("unexpected encoding table_enc"),
+                ObjF->getFileName());
 
   auto EHFramePtr = DE.getSigned(&Offset, 4) + EHFrameHdrAddress + 4;
   W.startLine() << format("eh_frame_ptr: 0x%" PRIx64 "\n", EHFramePtr);
 
   auto FDECount = DE.getUnsigned(&Offset, 4);
   W.printNumber("fde_count", FDECount);
 
   unsigned NumEntries = 0;
   uint64_t PrevPC = 0;
   while (Offset + 8 <= EHFrameHdrSize && NumEntries < FDECount) {
     DictScope D(W, std::string("entry ")  + std::to_string(NumEntries));
 
     auto InitialPC = DE.getSigned(&Offset, 4) + EHFrameHdrAddress;
     W.startLine() << format("initial_location: 0x%" PRIx64 "\n", InitialPC);
     auto Address = DE.getSigned(&Offset, 4) + EHFrameHdrAddress;
     W.startLine() << format("address: 0x%" PRIx64 "\n", Address);
 
     if (InitialPC < PrevPC)
-      reportError("initial_location is out of order");
+      reportError(object::createError("initial_location is out of order"),
+                  ObjF->getFileName());
 
     PrevPC = InitialPC;
     ++NumEntries;
   }
 }
 
 template <typename ELFT>
 void PrinterContext<ELFT>::printEHFrame(
     const typename ELFT::Shdr *EHFrameShdr) const {
   uint64_t Address = EHFrameShdr->sh_addr;
   uint64_t ShOffset = EHFrameShdr->sh_offset;
   W.startLine() << format(".eh_frame section at offset 0x%" PRIx64
                           " address 0x%" PRIx64 ":\n",
                           ShOffset, Address);
   W.indent();
 
   const object::ELFFile<ELFT> *Obj = ObjF->getELFFile();
   auto Result = Obj->getSectionContents(EHFrameShdr);
   if (Error E = Result.takeError())
-    reportError(toString(std::move(E)));
+    reportError(std::move(E), ObjF->getFileName());
 
   auto Contents = Result.get();
   DWARFDataExtractor DE(
       StringRef(reinterpret_cast<const char *>(Contents.data()),
                 Contents.size()),
       ELFT::TargetEndianness == support::endianness::little,
       ELFT::Is64Bits ? 8 : 4);
   DWARFDebugFrame EHFrame(Triple::ArchType(ObjF->getArch()), /*IsEH=*/true,

llvm/trunk/tools/llvm-readobj/ELFDumper.cpp

 
 template <class ELFT> class DumpStyle;
 
 /// Represents a contiguous uniform range in the file. We cannot just create a
 /// range directly because when creating one of these from the .dynamic table
 /// the size, entity size and virtual address are different entries in arbitrary
 /// order (DT_REL, DT_RELSZ, DT_RELENT for example).
 struct DynRegionInfo {
-  DynRegionInfo() = default;
-  DynRegionInfo(const void *A, uint64_t S, uint64_t ES)
-      : Addr(A), Size(S), EntSize(ES) {}
+  DynRegionInfo(StringRef ObjName) : FileName(ObjName) {}
+  DynRegionInfo(const void *A, uint64_t S, uint64_t ES, StringRef ObjName)
+      : Addr(A), Size(S), EntSize(ES), FileName(ObjName) {}
 
   /// Address in current address space.
   const void *Addr = nullptr;
   /// Size in bytes of the region.
   uint64_t Size = 0;
   /// Size of each entity in the region.
   uint64_t EntSize = 0;
 
+  /// Name of the file. Used for error reporting.
+  StringRef FileName;
+
   template <typename Type> ArrayRef<Type> getAsArrayRef() const {
     const Type *Start = reinterpret_cast<const Type *>(Addr);
     if (!Start)
       return {Start, Start};
     if (EntSize != sizeof(Type) || Size % EntSize) {
       // TODO: Add a section index to this warning.
-      reportWarning("invalid section size (" + Twine(Size) +
-                    ") or entity size (" + Twine(EntSize) + ")");
+      reportWarning(createError("invalid section size (" + Twine(Size) +
+                                ") or entity size (" + Twine(EntSize) + ")"),
+                    FileName);
       return {Start, Start};
     }
     return {Start, Start + (Size / EntSize)};
   }
 };
 
 template <typename ELFT> class ELFDumper : public ObjDumper {
 public:
private:
 
   TYPEDEF_ELF_TYPES(ELFT)
 
   DynRegionInfo checkDRI(DynRegionInfo DRI) {
     const ELFFile<ELFT> *Obj = ObjF->getELFFile();
     if (DRI.Addr < Obj->base() ||
         reinterpret_cast<const uint8_t *>(DRI.Addr) + DRI.Size >
             Obj->base() + Obj->getBufSize())
-      error(llvm::object::object_error::parse_failed);
+      reportError(llvm::object::object_error::parse_failed,
+                  ObjF->getFileName());
     return DRI;
   }
 
   DynRegionInfo createDRIFrom(const Elf_Phdr *P, uintX_t EntSize) {
-    return checkDRI(
-        {ObjF->getELFFile()->base() + P->p_offset, P->p_filesz, EntSize});
+    return checkDRI({ObjF->getELFFile()->base() + P->p_offset, P->p_filesz,
+                     EntSize, ObjF->getFileName()});
   }
 
   DynRegionInfo createDRIFrom(const Elf_Shdr *S) {
-    return checkDRI(
-        {ObjF->getELFFile()->base() + S->sh_offset, S->sh_size, S->sh_entsize});
+    return checkDRI({ObjF->getELFFile()->base() + S->sh_offset, S->sh_size,
+                     S->sh_entsize, ObjF->getFileName()});
   }
 
   void loadDynamicTable(const ELFFile<ELFT> *Obj);
   void parseDynamicTable();
 
   StringRef getSymbolVersion(StringRef StrTab, const Elf_Sym *symb,
                              bool &IsDefault) const;
   void LoadVersionMap() const;
public:
 
   DumpStyle(ELFDumper<ELFT> *Dumper) : Dumper(Dumper) {
     FileName = this->Dumper->getElfObject()->getFileName();
 
     // Dumper reports all non-critical errors as warnings.
     // It does not print the same warning more than once.
     WarningHandler = [this](const Twine &Msg) {
       if (Warnings.insert(Msg.str()).second)
-        reportWarning(FileName, createError(Msg));
+        reportWarning(createError(Msg), FileName);
       return Error::success();
     };
   }
 
   virtual ~DumpStyle() = default;
 
   virtual void printFileHeaders(const ELFFile<ELFT> *Obj) = 0;
   virtual void printGroupSections(const ELFFile<ELFT> *Obj) = 0;

 template <typename ELFT>
 std::string ELFDumper<ELFT>::getStaticSymbolName(uint32_t Index) const {
   const ELFFile<ELFT> *Obj = ObjF->getELFFile();
   StringRef StrTable = unwrapOrError(
       ObjF->getFileName(), Obj->getStringTableForSymtab(*DotSymtabSec));
   Elf_Sym_Range Syms =
       unwrapOrError(ObjF->getFileName(), Obj->symbols(DotSymtabSec));
   if (Index >= Syms.size())
-    reportError("Invalid symbol index");
+    reportError(createError("Invalid symbol index"), ObjF->getFileName());
   const Elf_Sym *Sym = &Syms[Index];
   return maybeDemangle(
       unwrapOrError(ObjF->getFileName(), Sym->getName(StrTable)));
 }
 
 template <typename ELFT>
 StringRef ELFDumper<ELFT>::getSymbolVersionByIndex(StringRef StrTab,
                                                    uint32_t SymbolVersionIndex,
                                                    bool &IsDefault) const {
   size_t VersionIndex = SymbolVersionIndex & VERSYM_VERSION;
 
   // Special markers for unversioned symbols.
   if (VersionIndex == VER_NDX_LOCAL || VersionIndex == VER_NDX_GLOBAL) {
     IsDefault = false;
     return "";
   }
 
   // Lookup this symbol in the version table.
   LoadVersionMap();
   if (VersionIndex >= VersionMap.size() || VersionMap[VersionIndex].isNull())
-    reportError("Invalid version entry");
+    reportError(createError("Invalid version entry"), ObjF->getFileName());
   const VersionMapEntry &Entry = VersionMap[VersionIndex];
 
   // Get the version name string.
   size_t NameOffset;
   if (Entry.isVerdef()) {
     // The first Verdaux entry holds the name.
     NameOffset = Entry.getVerdef()->getAux()->vda_name;
     IsDefault = !(SymbolVersionIndex & VERSYM_HIDDEN);
   } else {
     NameOffset = Entry.getVernaux()->vna_name;
     IsDefault = false;
   }
   if (NameOffset >= StrTab.size())
-    reportError("Invalid string offset");
+    reportError(createError("Invalid string offset"), ObjF->getFileName());
   return StrTab.data() + NameOffset;
 }
 
 template <typename ELFT>
 std::string ELFDumper<ELFT>::getFullSymbolName(const Elf_Sym *Symbol,
                                                StringRef StrTable,
                                                bool IsDynamic) const {
   std::string SymbolName = maybeDemangle(
void ELFDumper<ELFT>::loadDynamicTable(const ELFFile<ELFT> *Obj) {
   }
 
   // Information in the section header has priority over the information
   // in a PT_DYNAMIC header.
   // Ignore sh_entsize and use the expected value for entry size explicitly.
   // This allows us to dump the dynamic sections with a broken sh_entsize
   // field.
   if (DynamicSec) {
-    DynamicTable = checkDRI({ObjF->getELFFile()->base() + DynamicSec->sh_offset,
-                             DynamicSec->sh_size, sizeof(Elf_Dyn)});
+    DynamicTable =
+        checkDRI({ObjF->getELFFile()->base() + DynamicSec->sh_offset,
+                  DynamicSec->sh_size, sizeof(Elf_Dyn), ObjF->getFileName()});
     parseDynamicTable();
   }
 
   // If we have a PT_DYNAMIC header, we will either check the found dynamic
   // section or take the dynamic table data directly from the header.
   if (!DynamicPhdr)
     return;
 
   if (DynamicPhdr->p_offset + DynamicPhdr->p_filesz >
       ObjF->getMemoryBufferRef().getBufferSize()) {
     reportWarning(
-        "PT_DYNAMIC segment offset + size exceeds the size of the file");
+        createError(
+            "PT_DYNAMIC segment offset + size exceeds the size of the file"),
+        ObjF->getFileName());
     return;
   }
 
   if (!DynamicSec) {
     DynamicTable = createDRIFrom(DynamicPhdr, sizeof(Elf_Dyn));
     parseDynamicTable();
     return;
   }
 
   StringRef Name =
       unwrapOrError(ObjF->getFileName(), Obj->getSectionName(DynamicSec));
   if (DynamicSec->sh_addr + DynamicSec->sh_size >
           DynamicPhdr->p_vaddr + DynamicPhdr->p_memsz ||
       DynamicSec->sh_addr < DynamicPhdr->p_vaddr)
-    reportWarning("The SHT_DYNAMIC section '" + Name +
+    reportWarning(createError("The SHT_DYNAMIC section '" + Name +
                               "' is not contained within the "
-                  "PT_DYNAMIC segment");
+                              "PT_DYNAMIC segment"),
+                  ObjF->getFileName());
 
   if (DynamicSec->sh_addr != DynamicPhdr->p_vaddr)
-    reportWarning("The SHT_DYNAMIC section '" + Name +
+    reportWarning(createError("The SHT_DYNAMIC section '" + Name +
                               "' is not at the start of "
-                  "PT_DYNAMIC segment");
+                              "PT_DYNAMIC segment"),
+                  ObjF->getFileName());
 }
 
 template <typename ELFT>
 ELFDumper<ELFT>::ELFDumper(const object::ELFObjectFile<ELFT> *ObjF,
                            ScopedPrinter &Writer)
-    : ObjDumper(Writer), ObjF(ObjF) {
+    : ObjDumper(Writer), ObjF(ObjF), DynRelRegion(ObjF->getFileName()),
+      DynRelaRegion(ObjF->getFileName()), DynRelrRegion(ObjF->getFileName()),
+      DynPLTRelRegion(ObjF->getFileName()), DynSymRegion(ObjF->getFileName()),
+      DynamicTable(ObjF->getFileName()) {
   const ELFFile<ELFT> *Obj = ObjF->getELFFile();
-
   for (const Elf_Shdr &Sec :
        unwrapOrError(ObjF->getFileName(), Obj->sections())) {
     switch (Sec.sh_type) {
     case ELF::SHT_SYMTAB:
       if (!DotSymtabSec)
         DotSymtabSec = &Sec;
       break;
     case ELF::SHT_DYNSYM:
       if (!DynSymRegion.Size) {
         DynSymRegion = createDRIFrom(&Sec);
         // This is only used (if Elf_Shdr present)for naming section in GNU
         // style
         DynSymtabName =
             unwrapOrError(ObjF->getFileName(), Obj->getSectionName(&Sec));
 
         if (Expected<StringRef> E = Obj->getStringTableForSymtab(Sec))
           DynamicStringTable = *E;
         else
-          warn(E.takeError());
+          reportWarning(E.takeError(), ObjF->getFileName());
       }
       break;
     case ELF::SHT_SYMTAB_SHNDX:
       ShndxTable = unwrapOrError(ObjF->getFileName(), Obj->getSHNDXTable(Sec));
       break;
     case ELF::SHT_GNU_versym:
       if (!SymbolVersionSection)
         SymbolVersionSection = &Sec;
default:
     return "unknown";
   }
 }
 
 template <typename ELFT> void ELFDumper<ELFT>::parseDynamicTable() {
   auto toMappedAddr = [&](uint64_t Tag, uint64_t VAddr) -> const uint8_t * {
     auto MappedAddrOrError = ObjF->getELFFile()->toMappedAddr(VAddr);
     if (!MappedAddrOrError) {
-      reportWarning("Unable to parse DT_" +
+      Error Err =
+          createError("Unable to parse DT_" +
                       Twine(getTypeString(
                           ObjF->getELFFile()->getHeader()->e_machine, Tag)) +
                       ": " + llvm::toString(MappedAddrOrError.takeError()));
+
+      reportWarning(std::move(Err), ObjF->getFileName());
       return nullptr;
     }
     return MappedAddrOrError.get();
   };
 
   uint64_t SONameOffset = 0;
   const char *StringTableBegin = nullptr;
   uint64_t StringTableSize = 0;
case ELF::DT_ANDROID_RELRENT:
       DynRelrRegion.EntSize = Dyn.getVal();
       break;
     case ELF::DT_PLTREL:
       if (Dyn.getVal() == DT_REL)
         DynPLTRelRegion.EntSize = sizeof(Elf_Rel);
       else if (Dyn.getVal() == DT_RELA)
         DynPLTRelRegion.EntSize = sizeof(Elf_Rela);
       else
-        reportError(Twine("unknown DT_PLTREL value of ") +
-                    Twine((uint64_t)Dyn.getVal()));
+        reportError(createError(Twine("unknown DT_PLTREL value of ") +
+                                Twine((uint64_t)Dyn.getVal())),
+                    ObjF->getFileName());
       break;
     case ELF::DT_JMPREL:
       DynPLTRelRegion.Addr = toMappedAddr(Dyn.getTag(), Dyn.getPtr());
       break;
     case ELF::DT_PLTRELSZ:
       DynPLTRelRegion.Size = Dyn.getVal();
       break;
     }
template <typename ELFT> void ELFDumper<ELFT>::printGnuHashTable() {
   W.printNumber("First Hashed Symbol Index", GnuHashTable->symndx);
   W.printNumber("Num Mask Words", GnuHashTable->maskwords);
   W.printNumber("Shift Count", GnuHashTable->shift2);
   W.printHexList("Bloom Filter", GnuHashTable->filter());
   W.printList("Buckets", GnuHashTable->buckets());
   Elf_Sym_Range Syms = dynamic_symbols();
   unsigned NumSyms = std::distance(Syms.begin(), Syms.end());
   if (!NumSyms)
-    reportError("No dynamic symbol section");
+    reportError(createError("No dynamic symbol section"), ObjF->getFileName());
   W.printHexList("Values", GnuHashTable->values(NumSyms));
 }
 
 template <typename ELFT> void ELFDumper<ELFT>::printLoadName() {
   W.printString("LoadName", SOName);
 }
 
 template <class ELFT> void ELFDumper<ELFT>::printAttributes() {
MipsGOTParser<ELFT>::MipsGOTParser(const ELFO *Obj, StringRef FileName,
   // See "Global Offset Table" in Chapter 5 in the following document
   // for detailed GOT description.
   // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
 
   // Find static GOT secton.
   if (IsStatic) {
     GotSec = findSectionByName(*Obj, FileName, ".got");
     if (!GotSec)
-      reportError("Cannot find .got section");
+      reportError(createError("Cannot find .got section"), FileName);
 
     ArrayRef<uint8_t> Content =
         unwrapOrError(FileName, Obj->getSectionContents(GotSec));
     GotEntries = Entries(reinterpret_cast<const Entry *>(Content.data()),
                          Content.size() / sizeof(Entry));
     LocalNum = GotEntries.size();
     return;
   }
if (!DtPltGot)
       report_fatal_error("Cannot find PLTGOT dynamic table tag.");
     if (!DtLocalGotNum)
       report_fatal_error("Cannot find MIPS_LOCAL_GOTNO dynamic table tag.");
     if (!DtGotSym)
       report_fatal_error("Cannot find MIPS_GOTSYM dynamic table tag.");
 
     size_t DynSymTotal = DynSyms.size();
     if (*DtGotSym > DynSymTotal)
-      reportError("MIPS_GOTSYM exceeds a number of dynamic symbols");
+      reportError(
+          createError("MIPS_GOTSYM exceeds a number of dynamic symbols"),
+          FileName);
 
     GotSec = findNotEmptySectionByAddress(Obj, FileName, *DtPltGot);
     if (!GotSec)
-      reportError("There is no not empty GOT section at 0x" +
-                  Twine::utohexstr(*DtPltGot));
+      reportError(createError("There is no not empty GOT section at 0x" +
+                              Twine::utohexstr(*DtPltGot)),
+                  FileName);
 
     LocalNum = *DtLocalGotNum;
     GlobalNum = DynSymTotal - *DtGotSym;
 
     ArrayRef<uint8_t> Content =
         unwrapOrError(FileName, Obj->getSectionContents(GotSec));
     GotEntries = Entries(reinterpret_cast<const Entry *>(Content.data()),
                          Content.size() / sizeof(Entry));
if (PltRelSec->sh_type == ELF::SHT_REL) {
     return unwrapOrError(FileName,
                          Obj->getRelocationSymbol(&Rels[Offset], PltSymTable));
   }
 }
 
 template <class ELFT> void ELFDumper<ELFT>::printMipsPLTGOT() {
   const ELFFile<ELFT> *Obj = ObjF->getELFFile();
   if (Obj->getHeader()->e_machine != EM_MIPS)
-    reportError("MIPS PLT GOT is available for MIPS targets only");
+    reportError(createError("MIPS PLT GOT is available for MIPS targets only"),
+                ObjF->getFileName());
 
   MipsGOTParser<ELFT> Parser(Obj, ObjF->getFileName(), dynamic_table(),
                              dynamic_symbols());
   if (Parser.hasGot())
     ELFDumperStyle->printMipsGOT(Parser);
   if (Parser.hasPlt())
     ELFDumperStyle->printMipsPLT(Parser);
 }
if (Name == "GNU") {
         DataExtractor DescExtractor(
             StringRef(reinterpret_cast<const char *>(Descriptor.data()),
                       Descriptor.size()),
             ELFT::TargetEndianness == support::little, sizeof(Elf_Addr));
         Expected<CoreNote> Note = readCoreNote(DescExtractor);
         if (Note)
           printCoreNote<ELFT>(OS, *Note);
         else
-          warn(Note.takeError());
+          reportWarning(Note.takeError(), this->FileName);
       }
     } else if (!Descriptor.empty()) {
       OS << "   description data:";
       for (uint8_t B : Descriptor)
         OS << " " << format("%02x", B);
       OS << '\n';
     }
   };
if (Symbol.getELFType() == ELF::STT_FUNC && *SymAddrOrErr == SymValue) {
       // Check if the symbol is in the right section.
       if (FunctionSec.containsSymbol(Symbol)) {
         FuncSym = Symbol;
         break;
       }
     }
   }
 
-  StringRef FileStr = Obj->getFileName();
   std::string FuncName = "?";
   // A valid SymbolRef has a non-null object file pointer.
   if (FuncSym.BasicSymbolRef::getObject()) {
     // Extract the symbol name.
     Expected<StringRef> FuncNameOrErr = FuncSym.getName();
     if (FuncNameOrErr)
       FuncName = maybeDemangle(*FuncNameOrErr);
     else
       consumeError(FuncNameOrErr.takeError());
-  } else
-    reportWarning(" '" + FileStr +
-                  "': could not identify function symbol for stack size entry");
+  } else {
+    reportWarning(
+        createError("could not identify function symbol for stack size entry"),
+        Obj->getFileName());
+  }
 
   // Extract the size. The expectation is that Offset is pointing to the right
   // place, i.e. past the function address.
   uint64_t PrevOffset = *Offset;
   uint64_t StackSize = Data.getULEB128(Offset);
   // getULEB128() does not advance Offset if it is not able to extract a valid
   // integer.
   if (*Offset == PrevOffset)
     reportError(
         createStringError(object_error::parse_failed,
                           "could not extract a valid stack size in section %s",
                           SectionName.data()),
-        FileStr);
+        Obj->getFileName());
 
   printStackSizeEntry(StackSize, FuncName);
 }
 
 template <class ELFT>
 void GNUStyle<ELFT>::printStackSizeEntry(uint64_t Size, StringRef FuncName) {
   OS.PadToColumn(2);
   OS << format_decimal(Size, 11);
if (RelocSym != Obj->symbol_end()) {
     Expected<StringRef> NameOrErr = RelocSym->getName();
     if (NameOrErr)
       SymName = *NameOrErr;
     else
       consumeError(NameOrErr.takeError());
 
     auto SectionOrErr = RelocSym->getSection();
     if (!SectionOrErr) {
-      reportWarning(" '" + FileStr +
-                    "': cannot identify the section for relocation symbol " +
-                    SymName);
-      consumeError(SectionOrErr.takeError());
+      reportWarning(
+          createError("cannot identify the section for relocation symbol " +
+                      SymName),
+          FileStr);
     } else if (*SectionOrErr != FunctionSec) {
-      reportWarning(" '" + FileStr + "': relocation symbol " + SymName +
-                    " is not in the expected section");
+      reportWarning(createError("relocation symbol " + SymName +
+                                " is not in the expected section"),
+                    FileStr);
       // Pretend that the symbol is in the correct section and report its
       // stack size anyway.
       FunctionSec = **SectionOrErr;
     }
 
     Expected<uint64_t> RelocSymValueOrErr = RelocSym->getValue();
     if (RelocSymValueOrErr)
       RelocSymValue = *RelocSymValueOrErr;
for (const SectionRef &Sec : Obj->sections()) {
     }
   }
 }
 
 template <class ELFT>
 void DumpStyle<ELFT>::printRelocatableStackSizes(
     const ELFObjectFile<ELFT> *Obj, std::function<void()> PrintHeader) {
   const ELFFile<ELFT> *EF = Obj->getELFFile();
-  StringRef FileStr = Obj->getFileName();
+
   // Build a map between stack size sections and their corresponding relocation
   // sections.
   llvm::MapVector<SectionRef, SectionRef> StackSizeRelocMap;
   const SectionRef NullSection{};
 
   for (const SectionRef &Sec : Obj->sections()) {
     StringRef SectionName;
     if (Expected<StringRef> NameOrErr = Sec.getName())
for (const auto &StackSizeMapEntry : StackSizeRelocMap) {
     // Warn about stack size sections without a relocation section.
     StringRef StackSizeSectionName;
     if (Expected<StringRef> NameOrErr = StackSizesSec.getName())
       StackSizeSectionName = *NameOrErr;
     else
       consumeError(NameOrErr.takeError());
 
     if (RelocSec == NullSection) {
-      reportWarning(" '" + FileStr + "': section " + StackSizeSectionName +
+      reportWarning(createError("section " + StackSizeSectionName +
                                 " does not have a corresponding "
-                    "relocation section");
+                                "relocation section"),
+                    Obj->getFileName());
       continue;
     }
 
     // A .stack_sizes section header's sh_link field is supposed to point
     // to the section that contains the functions whose stack sizes are
     // described in it.
     const Elf_Shdr *StackSizesELFSec =
         Obj->getSection(StackSizesSec.getRawDataRefImpl());
for (const RelocationRef &Reloc : RelocSec.relocations()) {
         else
           consumeError(NameOrErr.takeError());
 
         StringRef RelocName = EF->getRelocationTypeName(Reloc.getType());
         reportError(
             createStringError(object_error::parse_failed,
                               "unsupported relocation type in section %s: %s",
                               RelocSectionName.data(), RelocName.data()),
-            FileStr);
+            Obj->getFileName());
       }
       this->printStackSize(Obj, Reloc, FunctionSec, StackSizeSectionName,
                            Resolver, Data);
     }
   }
 }
 
 template <class ELFT>
if (opts::SectionSymbols) {
           unwrapOrError(this->FileName, Obj->getStringTableForSymtab(*Symtab));
 
       for (const Elf_Sym &Sym :
            unwrapOrError(this->FileName, Obj->symbols(Symtab))) {
         const Elf_Shdr *SymSec = unwrapOrError(
             this->FileName,
             Obj->getSection(&Sym, Symtab, this->dumper()->getShndxTable()));
         if (SymSec == &Sec)
-          printSymbol(Obj, &Sym,
+          printSymbol(
+              Obj, &Sym,
               unwrapOrError(this->FileName, Obj->symbols(Symtab)).begin(),
-                      StrTable, false);
       }
     }
 
     if (opts::SectionData && Sec.sh_type != ELF::SHT_NOBITS) {
       ArrayRef<uint8_t> Data =
           unwrapOrError(this->FileName, Obj->getSectionContents(&Sec));
       W.printBinaryBlock(
           "SectionData",
ArrayRef<uint8_t> Contents = unwrapOrError(
       Obj->getSectionContents(this->dumper()->getDotAddrsigSec()));
   const uint8_t *Cur = Contents.begin();
   const uint8_t *End = Contents.end();
   while (Cur != End) {
     unsigned Size;
     const char *Err;
     uint64_t SymIndex = decodeULEB128(Cur, &Size, End, &Err);
     if (Err)
-      reportError(Err);
+      reportError(createError(Err), this->FileName);
+
     W.printNumber("Sym", this->dumper()->getStaticSymbolName(SymIndex),
                   SymIndex);
     Cur += Size;
   }
 }
 
 template <typename ELFT>
 static void printGNUNoteLLVMStyle(uint32_t NoteType, ArrayRef<uint8_t> Desc,
if (Name == "GNU") {
         DataExtractor DescExtractor(
             StringRef(reinterpret_cast<const char *>(Descriptor.data()),
                       Descriptor.size()),
             ELFT::TargetEndianness == support::little, sizeof(Elf_Addr));
         Expected<CoreNote> Note = readCoreNote(DescExtractor);
         if (Note)
           printCoreNoteLLVMStyle(*Note, W);
         else
-          warn(Note.takeError());
+          reportWarning(Note.takeError(), this->FileName);
       }
     } else if (!Descriptor.empty()) {
       W.printBinaryBlock("Description data", Descriptor);
     }
   };
 
   ArrayRef<Elf_Shdr> Sections = unwrapOrError(this->FileName, Obj->sections());
   if (Obj->getHeader()->e_type != ELF::ET_CORE && !Sections.empty()) {

llvm/trunk/tools/llvm-readobj/MachODumper.cpp

void MachODumper::printRelocation(const MachOObjectFile *Obj,
   bool IsExtern = !IsScattered && Obj->getPlainRelocationExternal(RE);
 
   StringRef TargetName;
   if (IsExtern) {
     symbol_iterator Symbol = Reloc.getSymbol();
     if (Symbol != Obj->symbol_end()) {
       Expected<StringRef> TargetNameOrErr = Symbol->getName();
       if (!TargetNameOrErr)
-        error(errorToErrorCode(TargetNameOrErr.takeError()));
+        reportError(TargetNameOrErr.takeError(), Obj->getFileName());
       TargetName = *TargetNameOrErr;
     }
   } else if (!IsScattered) {
     section_iterator SecI = Obj->getRelocationSection(DR);
     if (SecI != Obj->section_end())
       TargetName = unwrapOrError(Obj->getFileName(), SecI->getName());
   }
   if (TargetName.empty())
void MachODumper::printSymbol(const SymbolRef &Symbol) {
   } else
     SymbolName = *SymbolNameOrErr;
 
   MachOSymbol MOSymbol;
   getSymbol(Obj, Symbol.getRawDataRefImpl(), MOSymbol);
 
   StringRef SectionName = "";
   Expected<section_iterator> SecIOrErr = Symbol.getSection();
-  error(errorToErrorCode(SecIOrErr.takeError()));
+  if (!SecIOrErr)
+    reportError(SecIOrErr.takeError(), Obj->getFileName());
+
   section_iterator SecI = *SecIOrErr;
   if (SecI != Obj->section_end())
     SectionName = unwrapOrError(Obj->getFileName(), SecI->getName());
 
   DictScope D(W, "Symbol");
   W.printNumber("Name", SymbolName, MOSymbol.StringIndex);
   if (MOSymbol.Type & MachO::N_STAB) {
     W.printHex("Type", "SymDebugTable", MOSymbol.Type);

llvm/trunk/tools/llvm-readobj/ObjDumper.cpp

 #include "llvm/Support/Error.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/raw_ostream.h"
 #include <map>
 
 namespace llvm {
 
+static inline Error createError(const Twine &Msg) {
+  return createStringError(object::object_error::parse_failed, Msg);
+}
+
 ObjDumper::ObjDumper(ScopedPrinter &Writer) : W(Writer) {}
 
 ObjDumper::~ObjDumper() {
 }
 
 static void printAsPrintable(raw_ostream &W, const uint8_t *Start, size_t Len) {
   for (size_t i = 0; i < Len; i++)
     W << (isPrint(Start[i]) ? static_cast<char>(Start[i]) : '.');
if (IndexIt != SecIndices.end())
       IndexIt->second = true;
     if (NameIt != SecNames.end() || IndexIt != SecIndices.end())
       Ret.push_back(SecRef);
     SecIndex++;
   }
 
   for (const std::pair<std::string, bool> &S : SecNames)
     if (!S.second)
-      reportWarning(formatv("could not find section '{0}'", S.first).str());
+      reportWarning(
+          createError(formatv("could not find section '{0}'", S.first).str()),
+          Obj->getFileName());
+
   for (std::pair<unsigned, bool> S : SecIndices)
     if (!S.second)
-      reportWarning(formatv("could not find section {0}", S.first).str());
+      reportWarning(
+          createError(formatv("could not find section {0}", S.first).str()),
+          Obj->getFileName());
 
   return Ret;
 }
 
 void ObjDumper::printSectionsAsString(const object::ObjectFile *Obj,
                                       ArrayRef<std::string> Sections) {
   bool First = true;
   for (object::SectionRef Section :

llvm/trunk/tools/llvm-readobj/llvm-readobj.h

 #include <string>
 
 namespace llvm {
   namespace object {
     class RelocationRef;
   }
 
   // Various helper functions.
-  LLVM_ATTRIBUTE_NORETURN void reportError(Twine Msg);
-  void reportError(Error Err, StringRef Input); 
-  void reportWarning(Twine Msg);
-  void reportWarning(StringRef Input, Error Err);
-  void warn(llvm::Error Err);
-  void error(std::error_code EC);
+  LLVM_ATTRIBUTE_NORETURN void reportError(Error Err, StringRef Input); 
+  LLVM_ATTRIBUTE_NORETURN void reportError(std::error_code EC, StringRef Input);
+  void reportWarning(Error Err, StringRef Input);
 
   template <class T> T unwrapOrError(StringRef Input, Expected<T> EO) {
     if (EO)
       return *EO;
     reportError(EO.takeError(), Input);
     llvm_unreachable("reportError shouldn't return in this case");
   }
 } // namespace llvm

llvm/trunk/tools/llvm-readobj/llvm-readobj.cpp

cl::opt<OutputStyleTy>
              cl::init(LLVM));
 
   cl::extrahelp
       HelpResponse("\nPass @FILE as argument to read options from FILE.\n");
 } // namespace opts
 
 namespace llvm {
 
-LLVM_ATTRIBUTE_NORETURN void reportError(Twine Msg) {
+LLVM_ATTRIBUTE_NORETURN static void error(Twine Msg) {
+  // Flush the standard output to print the error at a
+  // proper place.
   fouts().flush();
   errs() << "\n";
   WithColor::error(errs()) << Msg << "\n";
   exit(1);
 }
 
-void reportError(Error Err, StringRef Input) {
+LLVM_ATTRIBUTE_NORETURN void reportError(Error Err, StringRef Input) {
   assert(Err);
   if (Input == "-")
     Input = "<stdin>";
   handleAllErrors(createFileError(Input, std::move(Err)),
-                  [&](const ErrorInfoBase &EI) { reportError(EI.message()); });
+                  [&](const ErrorInfoBase &EI) { error(EI.message()); });
+  llvm_unreachable("error() call should never return");
 }
 
-void reportWarning(Twine Msg) {
-  fouts().flush();
-  errs() << "\n";
-  WithColor::warning(errs()) << Msg << "\n";
-}
-
-void reportWarning(StringRef Input, Error Err) {
+void reportWarning(Error Err, StringRef Input) {
+  assert(Err);
   if (Input == "-")
     Input = "<stdin>";
-  warn(createFileError(Input, std::move(Err)));
-}
 
-void warn(Error Err) {
-  handleAllErrors(std::move(Err), [&](const ErrorInfoBase &EI) {
-    reportWarning(EI.message());
+  handleAllErrors(createFileError(Input, std::move(Err)),
+                  [&](const ErrorInfoBase &EI) {
+                    // Flush the standard output to print the warning at a
+                    // proper place.
+                    fouts().flush();
+                    errs() << "\n";
+                    WithColor::warning(errs()) << EI.message() << "\n";
                   });
 }
 
-void error(std::error_code EC) {
-  if (!EC)
-    return;
-  reportError(EC.message());
-}
-
-} // namespace llvm
-
-static void reportError(std::error_code EC, StringRef Input) {
+LLVM_ATTRIBUTE_NORETURN void reportError(std::error_code EC, StringRef Input) {
   assert(EC != readobj_error::success);
   reportError(errorCodeToError(EC), Input);
 }
 
+} // namespace llvm
+
 static bool isMipsArch(unsigned Arch) {
   switch (Arch) {
   case llvm::Triple::mips:
   case llvm::Triple::mipsel:
   case llvm::Triple::mips64:
   case llvm::Triple::mips64el:
     return true;
   default: