[Object/ELF.h] - Improve error reporting.

[grimar]

Summary

The errors coming from ELF.h are usually not very useful because they are
uninformative. This patch is a first step to improve the situation.

1. I tested this patch with a run of check-llvm and found that few messages are untested.

In this patch, I did not add more tests but marked all such cases with a "TODO" comment.

2. For all tested messages I extended the error text to provide more details (see test cases changed).

[grimar]

• Cosmetic change.

[grimar]

• A bit more cosmetic.

[MaskRay]

include/llvm/Object/ELF.h

62

&TableOrErr->front()

[jakehehrlich]

How important is using ErrSaver. Isn't it possible to just use std::string in these error cases?

[jhenderson]

I absolutely would love this change.

In D64014#1565714, @jakehehrlich wrote:

How important is using ErrSaver. Isn't it possible to just use std::string in these error cases?

What @jakehehrlich said. I don't think we need to worry about performance here, since we are throwing errors, so really it should be whatever's the simplest way to get the error back up the stack. I'm also not keen on introducing any form of global state if it can be avoided, especially in libraries.

include/llvm/Object/ELF.h

58

I'm not sure a static function here makes sense?

63

Why not have this return an Expected, and let the call sites handle the error rather than throwing it away here? Of course, they could throw it away there.

386

has invalid -> has an invalid

Here and in other error messages that use this phrase.

394

I think this would be better to be "... has invalid sh_size (0x1234) which is not a multiple of its sh_entsize of (..."

399

This should say WHY the sh_offset/sh_size is invalid (possibly saying something like "has a sh_offset + sh_size that cannot be represented").

487

Too small for what? Perhaps something like:

"invalid buffer: the size (Object.size()) is smaller than an ELF header (sizeof(Elf_Ehdr))".

638

Again, why is it invalid? Perhaps:

"SHT_SYMTAB_SHNDX section has sh_size (0x1234) which is not equal to the number of symbols (0x42)".

690

sections string table -> section name string table

test/Object/corrupt.test

5

Here and in other cases, I'm not sure it's clear enough to me that [5] is a section index. Perhaps it could be "[index 5]" or "a section with index [5]" or simply "a section with index 5".

38

Why has this lost its "warning: " check?

test/Object/invalid.test

155

This is an improvement, but I think the call site will need improving too to report where this section index is being referenced. Doesn't need to be in this change though.

238

Why has this gained "error: " unlike the others? FWIW, I think it should be present, and should be added to the others.

[MaskRay]

include/llvm/Object/ELF.h

58

It makes sense. If static is used, the instances will get internal linkage and defining the template function with the same name in another translation unit will not cause a conflict (ODR violation).

[grimar]

• Addressed review comments.

include/llvm/Object/ELF.h

58

I didn't want to split the definition and declaration.
(because it would require too many lines in a cpp for a template function:

template <class ELFT>
std::string getSecIndex(const ELFFile<ELFT> *Obj, ...) { 
...
}
...
template void object::getSecIndex<ELF32LE>();
template void object::getSecIndex<ELF32BE>();
template void object::getSecIndex<ELF64LE>();
template void object::getSecIndex<ELF64BE>();
)

And so there are two ways to do that correctly I think: either use
inline or static, otherwise the ODR would be violated.

It is probably can be inline (like other helpers in this file), I did that change.

63

Two reasons:

1. To simplify the implementation. With the current version it is a very convenient helper that does not need additional wrapping. It also allows to build the final string of view [index X] in one place.
2. I believe this error will *never* happen actually. Because our code always calls sections() earlier than this method is called,

so it just should succeed here.
But I still had to handle the error somehow and decided that because of all above the best way is just to return "[?]" as a section index in this
really unlikely and untestable (I believe) case.

test/Object/invalid.test

238

I added them for all tests in this file.

[grimar]

In D64014#1565714, @jakehehrlich wrote:

How important is using ErrSaver. Isn't it possible to just use std::string in these error cases?

I removed it. Honestly saying, I introduced it because for some reason was sure that Error keeps StringRef inside and not a std::string.

[jakehehrlich]

Overall I think this looks good. Others have been following the details far more closely that I've been so I'll defer to them.

include/llvm/Object/ELF.h

58

Agreed. In general if it compiles and can be static you want it to be static (pending some edge cases).

[grimar]

include/llvm/Object/ELF.h

58

I found this article about "static inline vs inline vs static in C++": https://gist.github.com/htfy96/50308afc11678d2e3766a36aa60d5f75
And it turns out my statement was not fully correct. I assumed that inline implies static, but it is actually not.

Going to change inline std::string getSecIndex to static inline std::string getSecIndex

[MaskRay]

include/llvm/Object/ELF.h

63

The use of consumeError deserves a comment (the comment of the function says it may indicate a design problem)

[grimar]

• inline -> static inline
• Addressed review comment.

[jhenderson]

There are a number of the error messages which you are updating that use upper-case for the first letter, but most others use lower-case. I think we should standardize on one, although it's not immediately obvious to me which it should be.

include/llvm/Object/ELF.h

58

I've been refreshing my memory of inline, static and template functions since making this statement, and turns out I was wrong (slightly). Typing it out to make sure I have got my understanding correct as much as anything else:

1. static means you'll get a copy of this function in every translation unit, local to that translation unit (or it might be inlined).
2. inline means there'll be a copy in every TU. If there's one or more other instances of the function, they have to be identical, and one will end up being used. If they aren't identical, it is undefined behaviour.
3. Template function definitions work the same way as inline functions: one copy is instantiated in each TU that uses it. If there's one or more other instances of the function, they have to be identical, and if so, one will be used. If they are not identical it is undefined behaviour.

From this I conclude that there's no point in using inline in this context. There is a point in using static if we think somewhere else in the code-base there's a TU that doesn't reference this header file, where somebody creates an identical copy of the function signature, but with different contents. If we don't care about that situation, then I'd argue that static is bad because it will increase executable size (assuming it isn't inlined) more than a template function definition otherwise would. It's not obvious to me that this function would be inlined (I expect it would, but it might not be), and I don't believe any other instances of this function are likely to be defined elsewhere in the object namespace, so personally I don't believe either static or inline should be used in this case. The same may not be true in other cases though, and I don't care that much about it.

Don't forget, inline may or may not have an impact on inlining of the function. The compiler will make the decision regardless of its presence or not.

63

Whilst what you're saying is fine for now, I can imagine in the future that people will want to call this function in other contexts beyond error handling. As such, it needs future proofing. At least a comment at the signature level saying that any unknown indexes are ignored would be good or changing the function name to something like "getSecIndexForError" would be good.

test/Object/invalid.test

48

Not to be fixed now, but it would be great if this didn't use report_fatal_error, since it's not really an internal error in most cases.

309

This should check the value too.

309

Report/check the invalid size?

[grimar]

In D64014#1567992, @jhenderson wrote:

There are a number of the error messages which you are updating that use upper-case for the first letter, but most others use lower-case. I think we should standardize on one, although it's not immediately obvious to me which it should be.

lower-case for sure :) Because this is what we use in the linker. Would be strange to get a errors of a different styles from it.

include/llvm/Object/ELF.h

58

Ok. After reading more about using inline with template functions, I agree with the part of your summary saying that "there's no point in using inline in this context". I am not sure about omitting the static, as makes possible to violate ODR and ELF.h is a global header, though I agree that having one more function with the same name is indeed very unlikely. Having that, I am OK to remove both inline and static.

[jhenderson]

include/llvm/Object/ELF.h

58

Subtle ODR issues only come into play when people write a non-identical version of this function somewhere else (in the same namespace etc) not using ELF.h (if they are using ELF.h, they'll get a compiler error about duplicate definitions or something, I expect, and I think that's fine). I don't think it matters that much either way, and I don't care strongly whether we should have static here or not, so I'm happy to defer to others opinions.

[grimar]

• Addressed review comments.

include/llvm/Object/ELF.h

63

I renamed it.

test/Object/invalid.test

48

Yes, I noticed this place. There are many things I am planning to improve in the follow-ups for error-reporting, and this is one of them.

309

No :) Because I am not changing this error message in this patch. (I only added a error: prefix to this test case).

[grimar]

test/Object/invalid.test

309

(I am only touching ELF.h/ELF.cpp)

[jhenderson]

include/llvm/Object/ELF.h

63

"for error"

64

anyways actually -> really
Up to this place -> Before this point

65

should already have called 'sections()' earlier -> should have called 'sections()'

66

report -> reported

[grimar]

• Addressed review comments.

[grimar]

So, can I land it, James?

[jhenderson]

Yes, sorry. Somehow missed your last update.

include/llvm/Object/ELF.h

 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/Object/ELFTypes.h"
 #include "llvm/Object/Error.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
+#include "llvm/Support/StringSaver.h"
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <limits>
 #include <utility>
 
 namespace llvm {
 namespace object {
 
+extern llvm::BumpPtrAllocator ErrAlloc;
+extern llvm::StringSaver ErrSaver;
+
 StringRef getELFRelocationTypeName(uint32_t Machine, uint32_t Type);
 uint32_t getELFRelativeRelocationType(uint32_t Machine);
 StringRef getELFSectionTypeName(uint32_t Machine, uint32_t Type);
 
 // Subclasses of ELFFile may need this for template instantiation
 inline std::pair<unsigned char, unsigned char>
 getElfArchType(StringRef Object) {
   if (Object.size() < ELF::EI_NIDENT)
     return std::make_pair((uint8_t)ELF::ELFCLASSNONE,
                           (uint8_t)ELF::ELFDATANONE);
   return std::make_pair((uint8_t)Object[ELF::EI_CLASS],
                         (uint8_t)Object[ELF::EI_DATA]);
 }
 
 static inline Error createError(StringRef Err) {
   return make_error<StringError>(Err, object_error::parse_failed);
 }
 
+template <class ELFT> class ELFFile;
+
+template <class ELFT>
+static std::string getSecIndex(const ELFFile<ELFT> *Obj,
+                               const typename ELFT::Shdr *Sec) {
+  auto TableOrErr = Obj->sections();
+  if (TableOrErr)
+    return "[" + std::to_string(Sec - &(*TableOrErr).front()) + "]";
+  llvm::consumeError(TableOrErr.takeError());
+  return "[?]";
+}
+
 template <class ELFT>
 class ELFFile {
 public:
   LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
   using uintX_t = typename ELFT::uint;
   using Elf_Ehdr = typename ELFT::Ehdr;
   using Elf_Shdr = typename ELFT::Shdr;
   using Elf_Sym = typename ELFT::Sym;
public:
 
   Expected<std::vector<Elf_Rela>> decode_relrs(Elf_Relr_Range relrs) const;
 
   Expected<std::vector<Elf_Rela>> android_relas(const Elf_Shdr *Sec) const;
 
   /// Iterate over program header table.
   Expected<Elf_Phdr_Range> program_headers() const {
     if (getHeader()->e_phnum && getHeader()->e_phentsize != sizeof(Elf_Phdr))
-      return createError("invalid e_phentsize");
+      return createError(ErrSaver.save("invalid e_phentsize: " +
+                                       Twine(getHeader()->e_phentsize)));
     if (getHeader()->e_phoff +
             (getHeader()->e_phnum * getHeader()->e_phentsize) >
         getBufSize())
-      return createError("program headers longer than binary");
+      return createError(
+          ErrSaver.save("program headers are longer than binary of size " +
+                        Twine(getBufSize()) + ": e_phoff = 0x" +
+                        Twine::utohexstr(getHeader()->e_phoff) +
+                        ", e_phnum = " + Twine(getHeader()->e_phnum) +
+                        ", e_phentsize = " + Twine(getHeader()->e_phentsize)));
     auto *Begin =
         reinterpret_cast<const Elf_Phdr *>(base() + getHeader()->e_phoff);
     return makeArrayRef(Begin, Begin + getHeader()->e_phnum);
   }
 
   /// Get an iterator over notes in a program header.
   ///
   /// The program header must be of type \c PT_NOTE.
   ///
   /// \param Phdr the program header to iterate over.
   /// \param Err [out] an error to support fallible iteration, which should
   ///  be checked after iteration ends.
   Elf_Note_Iterator notes_begin(const Elf_Phdr &Phdr, Error &Err) const {
     if (Phdr.p_type != ELF::PT_NOTE) {
+      // TODO: this error is untested.
       Err = createError("attempt to iterate notes of non-note program header");
       return Elf_Note_Iterator(Err);
     }
     if (Phdr.p_offset + Phdr.p_filesz > getBufSize()) {
+      // TODO: this error is untested.
       Err = createError("invalid program header offset/size");
       return Elf_Note_Iterator(Err);
     }
     return Elf_Note_Iterator(base() + Phdr.p_offset, Phdr.p_filesz, Err);
   }
 
   /// Get an iterator over notes in a section.
   ///
   /// The section must be of type \c SHT_NOTE.
   ///
   /// \param Shdr the section to iterate over.
   /// \param Err [out] an error to support fallible iteration, which should
   ///  be checked after iteration ends.
   Elf_Note_Iterator notes_begin(const Elf_Shdr &Shdr, Error &Err) const {
     if (Shdr.sh_type != ELF::SHT_NOTE) {
+      // TODO: this error is untested.
       Err = createError("attempt to iterate notes of non-note section");
       return Elf_Note_Iterator(Err);
     }
     if (Shdr.sh_offset + Shdr.sh_size > getBufSize()) {
+      // TODO: this error is untested.
       Err = createError("invalid section offset/size");
       return Elf_Note_Iterator(Err);
     }
     return Elf_Note_Iterator(base() + Shdr.sh_offset, Shdr.sh_size, Err);
   }
 
   /// Get the end iterator for notes.
   Elf_Note_Iterator notes_end() const {

 using ELF64LEFile = ELFFile<ELF64LE>;
 using ELF32BEFile = ELFFile<ELF32BE>;
 using ELF64BEFile = ELFFile<ELF64BE>;
 
 template <class ELFT>
 inline Expected<const typename ELFT::Shdr *>
 getSection(typename ELFT::ShdrRange Sections, uint32_t Index) {
   if (Index >= Sections.size())
-    return createError("invalid section index");
+    return createError(ErrSaver.save("invalid section index: " + Twine(Index)));
   return &Sections[Index];
 }
 
 template <class ELFT>
 inline Expected<uint32_t>
 getExtendedSymbolTableIndex(const typename ELFT::Sym *Sym,
                             const typename ELFT::Sym *FirstSym,
                             ArrayRef<typename ELFT::Word> ShndxTable) {
   assert(Sym->st_shndx == ELF::SHN_XINDEX);
   unsigned Index = Sym - FirstSym;
   if (Index >= ShndxTable.size())
-    return createError("index past the end of the symbol table");
+    return createError(ErrSaver.save(
+        "extended symbol index (" + Twine(Index) +
+        ") is past the end of the SHT_SYMTAB_SHNDX section of size " +
+        Twine(ShndxTable.size())));
 
   // The size of the table was checked in getSHNDXTable.
   return ShndxTable[Index];
 }
 
 template <class ELFT>
 Expected<uint32_t>
 ELFFile<ELFT>::getSectionIndex(const Elf_Sym *Sym, Elf_Sym_Range Syms,
if (Index == 0)
     return nullptr;
   return getSection(Index);
 }
 
 template <class ELFT>
 inline Expected<const typename ELFT::Sym *>
 getSymbol(typename ELFT::SymRange Symbols, uint32_t Index) {
   if (Index >= Symbols.size())
+    // TODO: this error is untested.
     return createError("invalid symbol index");
   return &Symbols[Index];
 }
 
 template <class ELFT>
 Expected<const typename ELFT::Sym *>
 ELFFile<ELFT>::getSymbol(const Elf_Shdr *Sec, uint32_t Index) const {
   auto SymtabOrErr = symbols(Sec);
   if (!SymtabOrErr)
     return SymtabOrErr.takeError();
   return object::getSymbol<ELFT>(*SymtabOrErr, Index);
 }
 
 template <class ELFT>
 template <typename T>
 Expected<ArrayRef<T>>
 ELFFile<ELFT>::getSectionContentsAsArray(const Elf_Shdr *Sec) const {
   if (Sec->sh_entsize != sizeof(T) && sizeof(T) != 1)
-    return createError("invalid sh_entsize");
+    return createError(
+        ErrSaver.save("section " + getSecIndex(this, Sec) +
+                      " has invalid sh_entsize: " + Twine(Sec->sh_entsize)));
 
   uintX_t Offset = Sec->sh_offset;
   uintX_t Size = Sec->sh_size;
 
   if (Size % sizeof(T))
-    return createError("size is not a multiple of sh_entsize");
+    return createError(ErrSaver.save("section " + getSecIndex(this, Sec) +
+                                     " has invalid sh_size (" + Twine(Size) +
+                                     "): is not a multiple of sh_entsize (" +
+                                     Twine(Sec->sh_entsize) + ")"));
   if ((std::numeric_limits<uintX_t>::max() - Offset < Size) ||
       Offset + Size > Buf.size())
-    return createError("invalid section offset");
+    return createError(ErrSaver.save(
+        "section " + getSecIndex(this, Sec) + " has invalid sh_offset (0x" +
+        Twine::utohexstr(Offset) + ") or sh_size (" + Twine(Size) + ")"));
 
   if (Offset % alignof(T))
+    // TODO: this error is untested.
     return createError("unaligned data");
 
   const T *Start = reinterpret_cast<const T *>(base() + Offset);
   return makeArrayRef(Start, Size / sizeof(T));
 }
 
 template <class ELFT>
 Expected<ArrayRef<uint8_t>>

 ELFFile<ELFT>::getSectionStringTable(Elf_Shdr_Range Sections) const {
   uint32_t Index = getHeader()->e_shstrndx;
   if (Index == ELF::SHN_XINDEX)
     Index = Sections[0].sh_link;
 
   if (!Index) // no section string table.
     return "";
   if (Index >= Sections.size())
+    // TODO: this error is untested.
     return createError("invalid section index");
   return getStringTable(&Sections[Index]);
 }
 
 template <class ELFT> ELFFile<ELFT>::ELFFile(StringRef Object) : Buf(Object) {}
 
 template <class ELFT>
 Expected<ELFFile<ELFT>> ELFFile<ELFT>::create(StringRef Object) {
   if (sizeof(Elf_Ehdr) > Object.size())
-    return createError("Invalid buffer");
+    return createError(ErrSaver.save("invalid buffer, size is too small: " +
+                                     Twine(Object.size())));
   return ELFFile(Object);
 }
 
 template <class ELFT>
 Expected<typename ELFT::ShdrRange> ELFFile<ELFT>::sections() const {
   const uintX_t SectionTableOffset = getHeader()->e_shoff;
   if (SectionTableOffset == 0)
     return ArrayRef<Elf_Shdr>();
 
   if (getHeader()->e_shentsize != sizeof(Elf_Shdr))
-    return createError(
-        "invalid section header entry size (e_shentsize) in ELF header");
+    return createError(ErrSaver.save("invalid e_shentsize in ELF header: " +
+                                     Twine(getHeader()->e_shentsize)));
 
   const uint64_t FileSize = Buf.size();
-
   if (SectionTableOffset + sizeof(Elf_Shdr) > FileSize)
-    return createError("section header table goes past the end of the file");
+    return createError(ErrSaver.save(
+        "section header table goes past the end of the file: e_shoff = 0x" +
+        Twine::utohexstr(SectionTableOffset)));
 
   // Invalid address alignment of section headers
   if (SectionTableOffset & (alignof(Elf_Shdr) - 1))
+    // TODO: this error is untested.
     return createError("invalid alignment of section headers");
 
   const Elf_Shdr *First =
       reinterpret_cast<const Elf_Shdr *>(base() + SectionTableOffset);
 
   uintX_t NumSections = getHeader()->e_shnum;
   if (NumSections == 0)
     NumSections = First->sh_size;
 
   if (NumSections > UINT64_MAX / sizeof(Elf_Shdr))
+    // TODO: this error is untested.
     return createError("section table goes past the end of file");
 
   const uint64_t SectionTableSize = NumSections * sizeof(Elf_Shdr);
 
   // Section table goes past end of file!
   if (SectionTableOffset + SectionTableSize > FileSize)
     return createError("section table goes past the end of file");
 
Expected<const T *> ELFFile<ELFT>::getEntry(uint32_t Section,
   return getEntry<T>(*SecOrErr, Entry);
 }
 
 template <class ELFT>
 template <typename T>
 Expected<const T *> ELFFile<ELFT>::getEntry(const Elf_Shdr *Section,
                                             uint32_t Entry) const {
   if (sizeof(T) != Section->sh_entsize)
+    // TODO: this error is untested.
     return createError("invalid sh_entsize");
   size_t Pos = Section->sh_offset + Entry * sizeof(T);
   if (Pos + sizeof(T) > Buf.size())
-    return createError("invalid section offset");
+    return createError(ErrSaver.save("unable to access section " +
+                                     getSecIndex(this, Section) +
+                                     " data at 0x" + Twine::utohexstr(Pos) +
+                                     ": offset goes past the end of file"));
   return reinterpret_cast<const T *>(base() + Pos);
 }
 
 template <class ELFT>
 Expected<const typename ELFT::Shdr *>
 ELFFile<ELFT>::getSection(uint32_t Index) const {
   auto TableOrErr = sections();
   if (!TableOrErr)
if (!TableOrErr)
     return TableOrErr.takeError();
   for (auto &Sec : *TableOrErr) {
     auto SecNameOrErr = getSectionName(&Sec);
     if (!SecNameOrErr)
       return SecNameOrErr.takeError();
     if (*SecNameOrErr == SectionName)
       return &Sec;
   }
+  // TODO: this error is untested.
   return createError("invalid section name");
 }
 
 template <class ELFT>
 Expected<StringRef>
 ELFFile<ELFT>::getStringTable(const Elf_Shdr *Section) const {
   if (Section->sh_type != ELF::SHT_STRTAB)
-    return createError("invalid sh_type for string table, expected SHT_STRTAB");
+    return createError(ErrSaver.save(
+        "invalid sh_type for string table section " +
+        getSecIndex(this, Section) + ": expected SHT_STRTAB, but got " +
+        object::getELFSectionTypeName(getHeader()->e_machine,
+                                      Section->sh_type)));
   auto V = getSectionContentsAsArray<char>(Section);
   if (!V)
     return V.takeError();
   ArrayRef<char> Data = *V;
   if (Data.empty())
+    // TODO: this error is untested.
     return createError("empty string table");
   if (Data.back() != '\0')
-    return createError("string table non-null terminated");
+    return createError(
+        ErrSaver.save(object::getELFSectionTypeName(getHeader()->e_machine,
+                                                    Section->sh_type) +
+                      " string table section " + getSecIndex(this, Section) +
+                      " is non-null terminated"));
   return StringRef(Data.begin(), Data.size());
 }
 
 template <class ELFT>
 Expected<ArrayRef<typename ELFT::Word>>
 ELFFile<ELFT>::getSHNDXTable(const Elf_Shdr &Section) const {
   auto SectionsOrErr = sections();
   if (!SectionsOrErr)
if (!VOrErr)
     return VOrErr.takeError();
   ArrayRef<Elf_Word> V = *VOrErr;
   auto SymTableOrErr = object::getSection<ELFT>(Sections, Section.sh_link);
   if (!SymTableOrErr)
     return SymTableOrErr.takeError();
   const Elf_Shdr &SymTable = **SymTableOrErr;
   if (SymTable.sh_type != ELF::SHT_SYMTAB &&
       SymTable.sh_type != ELF::SHT_DYNSYM)
+    // TODO: this error is untested.
     return createError("invalid sh_type");
   if (V.size() != (SymTable.sh_size / sizeof(Elf_Sym)))
-    return createError("invalid section contents size");
+    return createError(
+        ErrSaver.save("SHT_SYMTAB_SHNDX section has invalid sh_size: " +
+                      Twine(SymTable.sh_size)));
   return V;
 }
 
 template <class ELFT>
 Expected<StringRef>
 ELFFile<ELFT>::getStringTableForSymtab(const Elf_Shdr &Sec) const {
   auto SectionsOrErr = sections();
   if (!SectionsOrErr)
     return SectionsOrErr.takeError();
   return getStringTableForSymtab(Sec, *SectionsOrErr);
 }
 
 template <class ELFT>
 Expected<StringRef>
 ELFFile<ELFT>::getStringTableForSymtab(const Elf_Shdr &Sec,
                                        Elf_Shdr_Range Sections) const {
 
   if (Sec.sh_type != ELF::SHT_SYMTAB && Sec.sh_type != ELF::SHT_DYNSYM)
+    // TODO: this error is untested.
     return createError(
         "invalid sh_type for symbol table, expected SHT_SYMTAB or SHT_DYNSYM");
   auto SectionOrErr = object::getSection<ELFT>(Sections, Sec.sh_link);
   if (!SectionOrErr)
     return SectionOrErr.takeError();
   return getStringTable(*SectionOrErr);
 }
 

 
 template <class ELFT>
 Expected<StringRef> ELFFile<ELFT>::getSectionName(const Elf_Shdr *Section,
                                                   StringRef DotShstrtab) const {
   uint32_t Offset = Section->sh_name;
   if (Offset == 0)
     return StringRef();
   if (Offset >= DotShstrtab.size())
-    return createError("invalid string offset");
+    return createError(ErrSaver.save("a section " + getSecIndex(this, Section) +
+                                     " has invalid sh_name (0x" +
+                                     Twine::utohexstr(Offset) +
+                                     ") offset which goes past the end of the "
+                                     "sections string table"));
   return StringRef(DotShstrtab.data() + Offset);
 }
 
 /// This function returns the hash value for a symbol in the .dynsym section
 /// Name of the API remains consistent as specified in the libelf
 /// REF : http://www.sco.com/developers/gabi/latest/ch5.dynamic.html#hash
 inline unsigned hashSysV(StringRef SymbolName) {
   unsigned h = 0, g;

lib/Object/ELF.cpp

 //===- ELF.cpp - ELF object file implementation ---------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Object/ELF.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/Support/LEB128.h"
 
 using namespace llvm;
 using namespace object;
 
+BumpPtrAllocator object::ErrAlloc;
+StringSaver object::ErrSaver{ErrAlloc};
+
 #define STRINGIFY_ENUM_CASE(ns, name)                                          \
   case ns::name:                                                               \
     return #name;
 
 #define ELF_RELOC(name, value) STRINGIFY_ENUM_CASE(ELF, name)
 
 StringRef llvm::object::getELFRelocationTypeName(uint32_t Machine,
                                                  uint32_t Type) {
for (const Elf_Shdr &Sec : *SectionsOrError) {
       }
     }
 
     if (!Dyn.data())
       return ArrayRef<Elf_Dyn>();
   }
 
   if (Dyn.empty())
+    // TODO: this error is untested.
     return createError("invalid empty dynamic section");
 
   if (DynSecSize % sizeof(Elf_Dyn) != 0)
+    // TODO: this error is untested.
     return createError("malformed dynamic section");
 
   if (Dyn.back().d_tag != ELF::DT_NULL)
+    // TODO: this error is untested.
     return createError("dynamic sections must be DT_NULL terminated");
 
   return Dyn;
 }
 
 template <class ELFT>
 Expected<const uint8_t *> ELFFile<ELFT>::toMappedAddr(uint64_t VAddr) const {
   auto ProgramHeadersOrError = program_headers();
   if (!ProgramHeadersOrError)
     return ProgramHeadersOrError.takeError();
 
   llvm::SmallVector<Elf_Phdr *, 4> LoadSegments;
 
   for (const Elf_Phdr &Phdr : *ProgramHeadersOrError)
     if (Phdr.p_type == ELF::PT_LOAD)
       LoadSegments.push_back(const_cast<Elf_Phdr *>(&Phdr));
 
   const Elf_Phdr *const *I =
       std::upper_bound(LoadSegments.begin(), LoadSegments.end(), VAddr,
                        [](uint64_t VAddr, const Elf_Phdr_Impl<ELFT> *Phdr) {
                          return VAddr < Phdr->p_vaddr;
                        });
 
   if (I == LoadSegments.begin())
-    return createError("Virtual address is not in any segment");
+    return createError(ErrSaver.save(
+        "virtual address is not in any segment: 0x" + Twine::utohexstr(VAddr)));
   --I;
   const Elf_Phdr &Phdr = **I;
   uint64_t Delta = VAddr - Phdr.p_vaddr;
   if (Delta >= Phdr.p_filesz)
-    return createError("Virtual address is not in any segment");
+    return createError(ErrSaver.save(
+        "virtual address is not in any segment: 0x" + Twine::utohexstr(VAddr)));
   return base() + Phdr.p_offset + Delta;
 }
 
 template class llvm::object::ELFFile<ELF32LE>;
 template class llvm::object::ELFFile<ELF32BE>;
 template class llvm::object::ELFFile<ELF64LE>;
 template class llvm::object::ELFFile<ELF64BE>;

test/Object/corrupt.test

 // Section name offset overflows section name string table.
 RUN: not llvm-readobj %p/Inputs/corrupt.elf-x86-64 -sections \
 RUN:     2>&1 | FileCheck --check-prefix=SECNAME %s
 
-SECNAME: invalid string offset
+SECNAME: a section [5] has invalid sh_name (0x100031) offset which goes past the end of the sections string table
 
 
 // Section data offset past end of file.
 RUN: not llvm-readobj %p/Inputs/corrupt.elf-x86-64 -sections -section-data \
 RUN:     2>&1 | FileCheck --check-prefix=SECDATA %s
 
-SECDATA: invalid section offset
+SECDATA: section [1] has invalid sh_offset (0x100001) or sh_size (38)
 
 
 // Symbol name offset overflows string table.
 RUN: not llvm-readobj %p/Inputs/corrupt.elf-x86-64 -symbols \
 RUN:     2>&1 | FileCheck --check-prefix=SYMNAME %s
 
-SYMNAME: invalid string offset
+SYMNAME: a section [5] has invalid sh_name (0x100031) offset which goes past the end of the sections string table
 
 
 // Version index in .gnu.version overflows the version map.
 RUN: not llvm-readobj %p/Inputs/corrupt-version.elf-x86_64 -dt \
 RUN:     2>&1 | FileCheck --check-prefix=VER %s
 
 VER: error: Invalid version entry
 
 RUN: not llvm-readobj -l \
 RUN:   %p/Inputs/corrupt-invalid-phentsize.elf.x86-64 2>&1 | \
 RUN:   FileCheck --check-prefix=PHENTSIZE %s
 
 PHENTSIZE: invalid e_phentsize
 
 RUN: llvm-readobj --dynamic-table \
 RUN:   %p/Inputs/corrupt-invalid-virtual-addr.elf.x86-64 2>&1 | \
 RUN:   FileCheck --check-prefix=VIRTADDR %s
 
-VIRTADDR: warning: Unable to parse DT_STRTAB: Virtual address is not in any segment
+VIRTADDR: Unable to parse DT_STRTAB: virtual address is not in any segment: 0xffff
 
 
 RUN: not llvm-readobj --dyn-relocations \
 RUN:   %p/Inputs/corrupt-invalid-relocation-size.elf.x86-64 2>&1 | \
 RUN:   FileCheck --check-prefix=RELOC %s
 
 RELOC:  Invalid entity size
 

test/Object/elf-invalid-phdr.test

 #     PAddr: 0xFFFF1000
 #     Sections:
 #       - Section: .text
 #
 # Then editing the e_phoff in with a hexeditor to set it to 0xffffff
 RUN: not llvm-objdump -private-headers %p/Inputs/invalid-phdr.elf 2>&1 \
 RUN:         | FileCheck %s
 
-CHECK: LLVM ERROR: program headers longer than binary
+CHECK: LLVM ERROR: program headers are longer than binary of size 4162: e_phoff = 0xffffff, e_phnum = 1, e_phentsize = 56
 No newline at end of file

test/Object/invalid.test

 # RUN:   | FileCheck %s --check-prefix=INVALIDERR
 
 ## Check that llvm-dwarfdump reports an error during relocation resolution
 ## when instead of expected SHT_RELA section it locates a section of a different type.
 
 # RUN: yaml2obj %s --docnum=3 -o %t3
 # RUN: not llvm-dwarfdump -debug-line %t3 2>&1 | FileCheck --check-prefix=RELA %s
 
 # RELA: Section is not SHT_RELA
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
- Name: .shstrtab
     Content: "11"
 
 ## Check that llvm-objdump reports an error when it tries to dump a symbol name and
 ## .strtab is not null-terminated.
 
 # RUN: yaml2obj %s --docnum=5 -o %t5
 # RUN: not llvm-objdump -syms %t5 2>&1 | FileCheck --check-prefix=NONULL %s
 
-# NONULL: string table non-null terminated
+# NONULL: SHT_STRTAB string table section [1] is non-null terminated
  
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .strtab
DynamicSymbols:
   - Name: foo
 
 ## Check that llvm-readobj reports an error if .symtab has an invalid sh_link value,
 ## which is greater than number of sections.
 
 # RUN: yaml2obj %s --docnum=8 -o %t8
 # RUN: not llvm-readobj --symbols %t8 2>&1 | FileCheck --check-prefix=INVALID-SYMTAB-LINK %s
 
-# INVALID-SYMTAB-LINK: invalid section index
+# INVALID-SYMTAB-LINK: invalid section index: 255
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Name: .symtab
     Type: SHT_SYMTAB
     Link: 0xFF
 
 ## Check that llvm-readobj reports an error when trying to dump sections
 ## when the e_shentsize field is broken.
 
 # RUN: yaml2obj %s --docnum=9 -o %t9
 # RUN: not llvm-readobj -S %t9 2>&1 | FileCheck --check-prefix=INVALID-SH-ENTSIZE %s
 
-# INVALID-SH-ENTSIZE: invalid section header entry size (e_shentsize) in ELF header
+# INVALID-SH-ENTSIZE: invalid e_shentsize in ELF header: 1
 
 --- !ELF
 FileHeader:
   Class:     ELFCLASS64
   Data:      ELFDATA2LSB
   Type:      ET_REL
   Machine:   EM_X86_64
   SHEntSize: 1
 
 ## Check that llvm-readobj reports an error if .symtab has sh_size
 ## that is not a multiple of sh_entsize.
 
 # RUN: yaml2obj %s --docnum=10 -o %t10
 # RUN: not llvm-readobj --symbols %t10 2>&1 | FileCheck --check-prefix=INVALID-SYMTAB-SIZE %s
 
-# INVALID-SYMTAB-SIZE: size is not a multiple of sh_entsize
+# INVALID-SYMTAB-SIZE: section [1] has invalid sh_size (1): is not a multiple of sh_entsize (24)
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .symtab
     Type: SHT_SYMTAB
     Size: 1
 
 ## Test that llvm-readobj reports an error if SHT_SYMTAB_SHNDX section has
 ## invalid sh_size which should be:
 ## sizeof(.symtab_shndx) = (sizeof(.symtab) / entsize(.symtab)) * entsize(.symtab_shndx)
 
 # RUN: yaml2obj %s --docnum=11 -o %t11
 # RUN: not llvm-readobj --symbols %t11 2>&1 | FileCheck --check-prefix=INVALID-XINDEX-SIZE %s
 
-# INVALID-XINDEX-SIZE: invalid section contents size
+# INVALID-XINDEX-SIZE: SHT_SYMTAB_SHNDX section has invalid sh_size: 24
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .symtab_shndx
     Type: SHT_SYMTAB_SHNDX
     Size: 0x18
     EntSize: 4
     Link: .symtab
 
 ## Check that llvm-readobj reports an error if the e_phentsize field is broken.
 
 # RUN: not llvm-readobj --program-headers %p/Inputs/invalid-e_shnum.elf 2>&1 | \
 # RUN:  FileCheck --check-prefix=INVALID-PH-ENTSIZE %s
 
-# INVALID-PH-ENTSIZE: invalid e_phentsize
+# INVALID-PH-ENTSIZE: invalid e_phentsize: 12336
 
 ## Check that llvm-readobj reports an error when we have no SHT_SYMTAB_SHNDX section,
 ## but have a symbol referencing it.
 
 # RUN: not llvm-readobj --symbols %p/Inputs/invalid-ext-symtab-index.elf-x86-64 2>&1 | \
 # RUN:   FileCheck --check-prefix=INVALID-EXT-SYMTAB-INDEX %s
 
-# INVALID-EXT-SYMTAB-INDEX: index past the end of the symbol table
+# INVALID-EXT-SYMTAB-INDEX: error: extended symbol index (0) is past the end of the SHT_SYMTAB_SHNDX section of size 0
 
 ## Check that llvm-readobj reports an error if a relocation section
 ## has a broken sh_offset (past the end of the file).
 
 # RUN: not llvm-readobj -r %p/Inputs/invalid-relocation-sec-sh_offset.elf-i386 2>&1 | \
-# RUN:   FileCheck --check-prefix=INVALID-RELOC-SH-OFFSET %s
+# RUN:   FileCheck --check-prefix=INVALID-RELOC-SH-OFFSET1 %s
 # RUN: not llvm-readobj -r %p/Inputs/invalid-relocation-sec-sh_offset.elf-x86-64 2>&1 | \
-# RUN:   FileCheck --check-prefix=INVALID-RELOC-SH-OFFSET %s
+# RUN:   FileCheck --check-prefix=INVALID-RELOC-SH-OFFSET2 %s
 
-# INVALID-RELOC-SH-OFFSET: invalid section offset
+# INVALID-RELOC-SH-OFFSET1: section [2] has invalid sh_offset (0xffffff) or sh_size (8)
+# INVALID-RELOC-SH-OFFSET2: section [2] has invalid sh_offset (0xffffff) or sh_size (24)
  
 ## Check that llvm-objdump reports an error when .shstrtab has a broken sh_offset
 ## so large that sh_offset + sh_size overflows the platform address size type.
 
 # RUN: not llvm-readobj --symbols %p/Inputs/invalid-section-size2.elf 2>&1 | \
 # RUN:   FileCheck --check-prefix=INVALID-SECTION-SIZE2 %s
 
-# INVALID-SECTION-SIZE2: invalid section offset
+# INVALID-SECTION-SIZE2: section [5] has invalid sh_offset (0xffff0381) or sh_size (65494)
 
 ## Check that llvm-readobj reports an error when trying to dump sections
 ## when the e_shnum field is broken (is greater than the actual number of sections).
 
 # RUN: yaml2obj %s --docnum=12 -o %t12
 # RUN: not llvm-readobj -S %t12 2>&1 | FileCheck --check-prefix=INVALID-SECTION-NUM %s
 
 # INVALID-SECTION-NUM: section table goes past the end of file
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
   SHNum:   0xFF
 
 ## Check that llvm-readobj reports an error if a relocation contains an
 ## incorrect (too large) symbol index.
 
 # RUN: yaml2obj %s --docnum=13 -o %t13
 # RUN: not llvm-readobj -r %t13 2>&1 | FileCheck --check-prefix=INVALID-REL-SYM %s
 
-# INVALID-REL-SYM: invalid section offset
+# INVALID-REL-SYM: unable to access section [2] data at 0x18000180: offset goes past the end of file
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Name: .rela.text
     Type: SHT_RELA
     Info: 0
     Relocations:
       - Offset: 0x0
         Type:   R_X86_64_64
         Symbol: 0xFFFFFF
 
 ## Check llvm-readobj does not crash on a truncated ELF.
 
 ## Create a truncated ELF object with ELFCLASSNONE class using echo.
 ## 0x7f, 'E', 'L', 'F', ELFCLASS64(2), ELFDATA2LSB(1),
 ## EV_CURRENT(1), ELFOSABI_LINUX(3), <padding zero bytes>, ET_REL(1), EM_NONE(0)
 # RUN: echo -e -n "\x7f\x45\x4c\x46\x02\x01\x01\x03\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00" > %t11
 # RUN: not llvm-readobj -r %t11 2>&1 | FileCheck --check-prefix=INVALID-BUFFER %s
 
-# INVALID-BUFFER: Invalid buffer
+# INVALID-BUFFER: invalid buffer, size is too small: 18
 
 # RUN: not llvm-readobj %p/Inputs/invalid-coff-header-too-small 2>&1 | FileCheck --check-prefix=COFF-HEADER %s
 # COFF-HEADER: The file was not recognized as a valid object file

test/tools/llvm-elfabi/binary-read-bad-vaddr.test

Sections:
       - Section: .dynamic
   - Type: PT_DYNAMIC
     Flags: [ PF_X, PF_R ]
     VAddr: 0x1008
     PAddr: 0x1008
     Sections:
       - Section: .dynamic
 
-# CHECK: Virtual address is not in any segment when locating .dynstr section contents
+# CHECK: virtual address is not in any segment: 0x260 when locating .dynstr section contents

test/tools/llvm-objcopy/ELF/invalid-e_phoff.test

 ## If the e_phoff field is set to a value either past the end of the file, or
 ## such that e_phoff + e_phnum * sizeof(Elf_Phdr) is past the end of the file,
 ## we should emit an error. This test checks that the emitted error is sensible.
 
 # RUN: yaml2obj %s -o %t.o
 ## Remove the default section headers so that the section header table is not invalid.
 # RUN: llvm-objcopy --strip-sections %t.o
 # RUN: cp %t.o %t2.o
 
 ## Sanity check that the phdr table is at offset 64:
 # RUN: llvm-readobj --file-headers %t.o | FileCheck %s --check-prefix=VALIDATE
 # VALIDATE: ProgramHeaderOffset: 0x40{{$}}
 
 ## Truncate the file to end before the program header table ends.
 # RUN: %python -c "with open('%/t.o', 'r+b') as input: input.truncate(65)"
-# RUN: not llvm-objcopy %t.o 2>&1 | FileCheck %s
+# RUN: not llvm-objcopy %t.o 2>&1 | FileCheck %s --check-prefix=CASE1
+
+# CASE1: error: program headers are longer than binary of size 65: e_phoff = 0x40, e_phnum = 1, e_phentsize = 56
 
 ## Set the e_phoff field to a value much larger than the object file size.
 # RUN: %python -c "with open('%/t2.o', 'r+b') as input: import struct; bytes = struct.pack('<Q', 0x40000000); input.seek(32); input.write(bytes)"
-# RUN: not llvm-objcopy %t2.o 2>&1 | FileCheck %s
+# RUN: not llvm-objcopy %t2.o 2>&1 | FileCheck %s --check-prefix=CASE2
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 ProgramHeaders:
   - Type: PT_LOAD
 
-# CHECK: error: program headers longer than binary
+# CASE2: error: program headers are longer than binary of size 120: e_phoff = 0x40000000, e_phnum = 1, e_phentsize = 56

test/tools/llvm-objcopy/ELF/invalid-e_shoff.test

 ## If the e_shoff field is set to a value either past the end of the file, or
 ## such that e_shoff + e_shnum * sizeof(Elf_Shdr) is past the end of the file,
 ## we should emit an error. This test checks that the emitted error is sensible.
 
 # RUN: yaml2obj %s -o %t.o
 # RUN: cp %t.o %t2.o
 
 ## Sanity check that the section header table is at offset 64:
 # RUN: llvm-readobj --file-headers %t.o | FileCheck %s --check-prefix=VALIDATE
 # VALIDATE: SectionHeaderOffset: 0x40{{$}}
 
 ## Truncate the file to end before the section header table ends.
 # RUN: %python -c "with open('%/t.o', 'r+b') as input: input.truncate(65)"
-# RUN: not llvm-objcopy %t.o 2>&1 | FileCheck %s -DINPUT=%t.o
+# RUN: not llvm-objcopy %t.o 2>&1 | FileCheck %s -DINPUT=%t.o --check-prefix=CASE1
+
+# CASE1: error: '[[INPUT]]': section header table goes past the end of the file: e_shoff = 0x40
 
 ## Set the e_shoff field to a value much larger than the object file size.
 # RUN: %python -c "with open('%/t2.o', 'r+b') as input: import struct; bytes = struct.pack('<Q', 0x40000000); input.seek(40); input.write(bytes)"
-# RUN: not llvm-objcopy %t2.o 2>&1 | FileCheck %s -DINPUT=%t2.o
+# RUN: not llvm-objcopy %t2.o 2>&1 | FileCheck %s -DINPUT=%t2.o --check-prefix=CASE2
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name: .foo
     Type: SHT_PROGBITS
 
-# CHECK: error: '[[INPUT]]': section header table goes past the end of the file
+# CASE2: error: '[[INPUT]]': section header table goes past the end of the file: e_shoff = 0x40000000

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
 
-# ERR: warning: invalid sh_type for string table, expected SHT_STRTAB
+# ERR: warning: invalid sh_type for string table section [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

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

- Type: PT_DYNAMIC
     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
+# BAD-STRTAB-ERR: warning: 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: <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:        <Library name index out of range>
- Type: PT_DYNAMIC
     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
 
-# CHECK: warning: Unable to parse DT_RELA: Virtual address is not in any segment
+# CHECK: warning: 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
 # BAD-RELA-GNU-NEXT: 0x0000000000000007 (RELA) 0x1000000