Demo

ELF/InputFiles.cpp

if (ComdatGroups.insert(N).second)
       KeptComdats.insert(&P.second);
   }
 
   for (const BasicSymbolRef &Sym : Obj->symbols())
     if (!shouldSkip(Sym.getFlags()))
       Symbols.push_back(createSymbol<ELFT>(KeptComdats, *Obj, Sym));
 }
 
-template <typename T>
+// All input object files must be for the same architecture
+// (e.g. it does not make sense to link x86 object files with
+// MIPS object files.) This function checks for that error.
+template <class ELFT> static void checkCompatibility(InputFile *FileP) {
+  auto *F = dyn_cast<ELFFileBase<ELFT>>(FileP);
+  assert(F && "file compatibility check for zero pointer is performed");
+  if (F->getELFKind() == Config->EKind && F->getEMachine() == Config->EMachine)
+    return;
+  StringRef A = F->getName();
+  StringRef B = Config->Emulation;
+  if (B.empty())
+    B = Config->FirstElf->getName();
+  error(A + " is incompatible with " + B);
+}
+
+template <template <class> class T, class ELFT>
 static std::unique_ptr<InputFile> createELFFileAux(MemoryBufferRef MB) {
-  std::unique_ptr<T> Ret = llvm::make_unique<T>(MB);
+  std::unique_ptr<T<ELFT>> Ret = llvm::make_unique<T<ELFT>>(MB);
 
   if (!Config->FirstElf)
     Config->FirstElf = Ret.get();
 
-  if (Config->EKind == ELFNoneKind) {
+  if (Config->EKind != ELFNoneKind)
+    checkCompatibility<ELFT>(Ret.get());
+  else {
     Config->EKind = Ret->getELFKind();
     Config->EMachine = Ret->getEMachine();
     if (Config->EMachine == EM_MIPS && Config->EKind == ELF64LEKind)
       Config->Mips64EL = true;
   }
 
   return std::move(Ret);
 }
 
 template <template <class> class T>
 static std::unique_ptr<InputFile> createELFFile(MemoryBufferRef MB) {
   unsigned char Size;
   unsigned char Endian;
   std::tie(Size, Endian) = getElfArchType(MB.getBuffer());
   if (Endian != ELFDATA2LSB && Endian != ELFDATA2MSB)
     fatal("invalid data encoding: " + MB.getBufferIdentifier());
 
   if (Size == ELFCLASS32) {
     if (Endian == ELFDATA2LSB)
-      return createELFFileAux<T<ELF32LE>>(MB);
-    return createELFFileAux<T<ELF32BE>>(MB);
+      return createELFFileAux<T, ELF32LE>(MB);
+    return createELFFileAux<T, ELF32BE>(MB);
   }
   if (Size == ELFCLASS64) {
     if (Endian == ELFDATA2LSB)
-      return createELFFileAux<T<ELF64LE>>(MB);
-    return createELFFileAux<T<ELF64BE>>(MB);
+      return createELFFileAux<T, ELF64LE>(MB);
+    return createELFFileAux<T, ELF64BE>(MB);
   }
   fatal("invalid file class: " + MB.getBufferIdentifier());
 }
 
 static bool isBitcode(MemoryBufferRef MB) {
   using namespace sys::fs;
   return identify_magic(MB.getBuffer()) == file_magic::bitcode;
 }

ELF/SymbolTable.cpp

 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::ELF;
 
 using namespace lld;
 using namespace lld::elf;
 
-// All input object files must be for the same architecture
-// (e.g. it does not make sense to link x86 object files with
-// MIPS object files.) This function checks for that error.
-template <class ELFT> static bool isCompatible(InputFile *FileP) {
-  auto *F = dyn_cast<ELFFileBase<ELFT>>(FileP);
-  if (!F)
-    return true;
-  if (F->getELFKind() == Config->EKind && F->getEMachine() == Config->EMachine)
-    return true;
-  StringRef A = F->getName();
-  StringRef B = Config->Emulation;
-  if (B.empty())
-    B = Config->FirstElf->getName();
-  error(A + " is incompatible with " + B);
-  return false;
-}
-
 // Add symbols in File to the symbol table.
 template <class ELFT>
 void SymbolTable<ELFT>::addFile(std::unique_ptr<InputFile> File) {
   InputFile *FileP = File.get();
-  if (!isCompatible<ELFT>(FileP))
-    return;
 
   // .a file
   if (auto *F = dyn_cast<ArchiveFile>(FileP)) {
     ArchiveFiles.emplace_back(cast<ArchiveFile>(File.release()));
     F->parse<ELFT>();
     return;
   }
 
if (BitcodeFiles.empty())
     return;
 
   // Compile bitcode files.
   Lto.reset(new BitcodeCompiler);
   for (const std::unique_ptr<BitcodeFile> &F : BitcodeFiles)
     Lto->add(*F);
   std::vector<std::unique_ptr<InputFile>> IFs = Lto->compile();
 
+  if (HasError)
+    return;
+
   // Replace bitcode symbols.
   for (auto &IF : IFs) {
     ObjectFile<ELFT> *Obj = cast<ObjectFile<ELFT>>(IF.release());
 
     llvm::DenseSet<StringRef> DummyGroups;
     Obj->parse(DummyGroups);
     ObjectFiles.emplace_back(Obj);
   }

test/ELF/lto/mix-platforms.ll

+; REQUIRES: x86
+; RUN: llvm-mc %p/Inputs/shared.s -o %t386.o -filetype=obj -triple=i386-pc-linux
+; RUN: ld.lld %t386.o -o %t386.so -shared
+; RUN: llvm-as %s -o %tx64.o
+; RUN: not ld.lld %t386.so %tx64.o -o %t 2>&1 | FileCheck %s
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+; CHECK: LLD-INTERNAL-combined-lto-object is incompatible with {{.*}}386.so