Include an archive file name in an error message for a bad file.

[ruiu]

Summary

Include an archive file name in an error message for a bad file.

[efriedma]

LGTM

lld/ELF/InputFiles.cpp

1204

Not directly a comment on this change... but maybe we should also change the text of these error messages to indicate a general cause in addition to the specific cause, something like "corrupt ELF file (invalid data encoding)".

[ruiu]

• address review comment

lld/ELF/InputFiles.cpp

1204

Makes sense. Updated the error messages.

[efriedma]

LGTM

lld/ELF/InputFiles.cpp

void BitcodeFile::parse(DenseSet<CachedHashStringRef> &ComdatGroups) {
   std::vector<bool> KeptComdats;
   for (StringRef S : Obj->getComdatTable())
     KeptComdats.push_back(ComdatGroups.insert(CachedHashStringRef(S)).second);
 
   for (const lto::InputFile::Symbol &ObjSym : Obj->symbols())
     Symbols.push_back(createBitcodeSymbol<ELFT>(KeptComdats, ObjSym, *this));
 }
 
-static ELFKind getELFKind(MemoryBufferRef MB) {
+static ELFKind getELFKind(MemoryBufferRef MB, StringRef ArchiveName) {
   unsigned char Size;
   unsigned char Endian;
   std::tie(Size, Endian) = getElfArchType(MB.getBuffer());
 
+  auto Fatal = [&](StringRef Msg) {
+    if (ArchiveName.empty())
+      fatal(MB.getBufferIdentifier() + ": " + Msg);
+    else
+      fatal(ArchiveName + "(" + MB.getBufferIdentifier() + "): " + Msg);
+  };
+
   if (Endian != ELFDATA2LSB && Endian != ELFDATA2MSB)
-    fatal(MB.getBufferIdentifier() + ": invalid data encoding");
+    Fatal("invalid data encoding");
   if (Size != ELFCLASS32 && Size != ELFCLASS64)
-    fatal(MB.getBufferIdentifier() + ": invalid file class");
+    Fatal("invalid file class");
 
   size_t BufSize = MB.getBuffer().size();
   if ((Size == ELFCLASS32 && BufSize < sizeof(Elf32_Ehdr)) ||
       (Size == ELFCLASS64 && BufSize < sizeof(Elf64_Ehdr)))
-    fatal(MB.getBufferIdentifier() + ": file is too short");
+    Fatal("file is too short");
 
   if (Size == ELFCLASS32)
     return (Endian == ELFDATA2LSB) ? ELF32LEKind : ELF32BEKind;
   return (Endian == ELFDATA2LSB) ? ELF64LEKind : ELF64BEKind;
 }
 
 void BinaryFile::parse() {
   ArrayRef<uint8_t> Data = arrayRefFromStringRef(MB.getBuffer());
Symtab->addDefined(Saver.save(S + "_size"), STV_DEFAULT, STT_OBJECT,
                      Data.size(), 0, STB_GLOBAL, nullptr, nullptr);
 }
 
 InputFile *elf::createObjectFile(MemoryBufferRef MB, StringRef ArchiveName,
                                  uint64_t OffsetInArchive) {
   if (isBitcode(MB))
     return make<BitcodeFile>(MB, ArchiveName, OffsetInArchive);
 
-  switch (getELFKind(MB)) {
+  switch (getELFKind(MB, ArchiveName)) {
   case ELF32LEKind:
     return make<ObjFile<ELF32LE>>(MB, ArchiveName);
   case ELF32BEKind:
     return make<ObjFile<ELF32BE>>(MB, ArchiveName);
   case ELF64LEKind:
     return make<ObjFile<ELF64LE>>(MB, ArchiveName);
   case ELF64BEKind:
     return make<ObjFile<ELF64BE>>(MB, ArchiveName);
   default:
     llvm_unreachable("getELFKind");
   }
 }
 
 InputFile *elf::createSharedFile(MemoryBufferRef MB, StringRef DefaultSoName) {
-  switch (getELFKind(MB)) {
+  switch (getELFKind(MB, "")) {
   case ELF32LEKind:
     return make<SharedFile<ELF32LE>>(MB, DefaultSoName);
   case ELF32BEKind:
     return make<SharedFile<ELF32BE>>(MB, DefaultSoName);
   case ELF64LEKind:
     return make<SharedFile<ELF64LE>>(MB, DefaultSoName);
   case ELF64BEKind:
     return make<SharedFile<ELF64BE>>(MB, DefaultSoName);
if (isBitcode(this->MB)) {
     std::unique_ptr<lto::InputFile> Obj =
         CHECK(lto::InputFile::create(this->MB), this);
     for (const lto::InputFile::Symbol &Sym : Obj->symbols())
       if (!Sym.isUndefined())
         Symtab->addLazyObject<ELFT>(Saver.save(Sym.getName()), *this);
     return;
   }
 
-  if (getELFKind(this->MB) != Config->EKind) {
+  if (getELFKind(this->MB, ArchiveName) != Config->EKind) {
     error("incompatible file: " + this->MB.getBufferIdentifier());
     return;
   }
 
   ELFFile<ELFT> Obj = check(ELFFile<ELFT>::create(MB.getBuffer()));
   ArrayRef<typename ELFT::Shdr> Sections = CHECK(Obj.sections(), this);
 
   for (const typename ELFT::Shdr &Sec : Sections) {

lld/test/ELF/invalid/invalid-elf.test

 # REQUIRES: x86
 # RUN: llvm-mc %s -o %t -filetype=obj -triple x86_64-pc-linux
 
 # RUN: not ld.lld %t %p/Inputs/data-encoding.a -o %t2 2>&1 | \
 # RUN:   FileCheck --check-prefix=INVALID-DATA-ENC %s
-# INVALID-DATA-ENC: test.o: invalid data encoding
+# INVALID-DATA-ENC: data-encoding.a(test.o): invalid data encoding
 
 # RUN: not ld.lld %t %p/Inputs/file-class.a -o %t2 2>&1 | \
 # RUN:   FileCheck --check-prefix=INVALID-FILE-CLASS %s
-# INVALID-FILE-CLASS: test.o: invalid file class
+# INVALID-FILE-CLASS: file-class.a(test.o): invalid file class
 
 # RUN: not ld.lld %p/Inputs/binding.elf -o %t2 2>&1 | \
 # RUN:   FileCheck --check-prefix=INVALID-BINDING %s
 # INVALID-BINDING: unexpected binding
 
 # RUN: not ld.lld %p/Inputs/section-index.elf -o %t2 2>&1 | \
 # RUN:   FileCheck --check-prefix=INVALID-SECTION-INDEX-LLD %s
 # INVALID-SECTION-INDEX-LLD: invalid section index
 
 # RUN: not ld.lld %p/Inputs/multiple-eh-relocs.elf -o %t2 2>&1 | \
 # RUN:   FileCheck --check-prefix=INVALID-EH-RELOCS %s
 # INVALID-EH-RELOCS: multiple relocation sections to one section are not supported
 
 .long foo