[LLD][ELF] - Check the architecture of lazy objects earlier.

[grimar]

Summary

Our code in LazyObjFile::parse() has an ELFT switch and
adds a lazy object by its ELFT kind.
Though it might be possible to add a file using a different architecture
and make LLD to silently accept it (if the file is empty or contains only week symbols).
That itself, not a huge issue perhaps (because the error would be reported later if the file is fetched),
but still does not look clean and correct.

It is possible to report an error earlier and clean up the
code. That is what the patch does.

Ideally, we might want to reuse isCompatible from SymbolTable.cpp,
but it is static and accepts a file as an argument, what is not convenient.
Since such a situation should be rare, I think it should be OK to go with the
way chosen in this patch.

[ruiu]

ELF/InputFiles.cpp

1265 ↗

(On Diff #161238)

"incompatible file: " + this->MB.getBufferIdentifier() is perhaps better.

1267 ↗

(On Diff #161238)

You can inline this function now.

[grimar]

• Addressed review comments.

[ruiu]

LGTM

ELF/InputFiles.h

275 ↗

(On Diff #161451)

Remove the blank line.

lld/trunk/ELF/InputFiles.h

public:
   static bool classof(const InputFile *F) { return F->kind() == LazyObjKind; }
 
   template <class ELFT> void parse();
   MemoryBufferRef getBuffer();
   InputFile *fetch();
   bool AddedToLink = false;
 
 private:
-  template <class ELFT> void addElfSymbols();
-
   uint64_t OffsetInArchive;
 };
 
 // An ArchiveFile object represents a .a file.
 class ArchiveFile : public InputFile {
 public:
   explicit ArchiveFile(std::unique_ptr<Archive> &&File);
   static bool classof(const InputFile *F) { return F->kind() == ArchiveKind; }

lld/trunk/ELF/InputFiles.cpp

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;
   }
 
-  switch (getELFKind(this->MB)) {
-  case ELF32LEKind:
-    addElfSymbols<ELF32LE>();
-    return;
-  case ELF32BEKind:
-    addElfSymbols<ELF32BE>();
-    return;
-  case ELF64LEKind:
-    addElfSymbols<ELF64LE>();
+  if (getELFKind(this->MB) != Config->EKind) {
+    error("incompatible file: " + this->MB.getBufferIdentifier());
     return;
-  case ELF64BEKind:
-    addElfSymbols<ELF64BE>();
-    return;
-  default:
-    llvm_unreachable("getELFKind");
-  }
   }
 
-template <class ELFT> void LazyObjFile::addElfSymbols() {
   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) {
     if (Sec.sh_type != SHT_SYMTAB)
       continue;
 
     typename ELFT::SymRange Syms = CHECK(Obj.symbols(&Sec), this);

lld/trunk/test/ELF/lazy-arch-conflict.s

+# REQUIRES: x86
+
+# RUN: echo '.globl foo; .weak foo; .quad foo;' | llvm-mc -filetype=obj -triple=x86_64-unknown-linux - -o %t64.o
+# RUN: echo '.globl foo; foo:' | llvm-mc -filetype=obj -triple=i686-pc-linux - -o %t32.o
+# RUN: not ld.lld %t64.o --start-lib %t32.o --end-lib -o /dev/null 2>&1 | Filecheck %s
+
+# CHECK: error: incompatible file: {{.*}}32.o