Handle bitcode files in archive files with --whole-archive.

[ruiu]

Summary

This patch moves BitcodeFile instantiation into createObjectFile.
Previously, we handle bitcode files outside that function and did
not handle for --whole-archive.

[• rafael]

ELF/InputFiles.cpp

459

I would prefer to keep this as std::unique_ptr and use std::move on the caller.

[ruiu]

• address Rafael's comment

[• rafael]

LGTM with nits.

ELF/InputFiles.cpp

460

Why remove the llvm::make_unique?

464

unrelated white space change.

ELF/Driver.cpp

if (WholeArchive) {
         Files.push_back(createObjectFile(MB, S));
       return;
     }
     Files.push_back(make_unique<ArchiveFile>(MBRef));
     return;
   case file_magic::elf_shared_object:
     Files.push_back(createSharedFile(MBRef));
     return;
-  case sys::fs::file_magic::bitcode:
-    Files.push_back(make_unique<BitcodeFile>(MBRef));
-    return;
   default:
     Files.push_back(createObjectFile(MBRef));
   }
 }
 
 // Add a given library by searching it from input search paths.
 void LinkerDriver::addLibrary(StringRef Name) {
   std::string Path = searchLibrary(Name);

ELF/InputFiles.cpp

if (Sym.getFlags() & object::BasicSymbolRef::SF_Undefined)
       Body = new (Alloc) Undefined(NameRef, false, STV_DEFAULT, false);
     else
       Body = new (Alloc) DefinedBitcode(NameRef);
     SymbolBodies.push_back(Body);
   }
 }
 
 template <typename T>
 static std::unique_ptr<InputFile> createELFFileAux(MemoryBufferRef MB) {
-  std::unique_ptr<T> Ret = llvm::make_unique<T>(MB);
-
+  std::unique_ptr<T> Ret(new T(MB));
   if (!Config->FirstElf)
     Config->FirstElf = Ret.get();
-
   if (Config->EKind == ELFNoneKind) {
     Config->EKind = Ret->getELFKind();
     Config->EMachine = Ret->getEMachine();
   }
-
   return std::move(Ret);
 }
 
 template <template <class> class T>
 static std::unique_ptr<InputFile> createELFFile(MemoryBufferRef MB) {
   std::pair<unsigned char, unsigned char> Type = getElfArchType(MB.getBuffer());
   if (Type.second != ELF::ELFDATA2LSB && Type.second != ELF::ELFDATA2MSB)
     fatal("Invalid data encoding: " + MB.getBufferIdentifier());
 
   if (Type.first == ELF::ELFCLASS32) {
     if (Type.second == ELF::ELFDATA2LSB)
       return createELFFileAux<T<ELF32LE>>(MB);
     return createELFFileAux<T<ELF32BE>>(MB);
   }
   if (Type.first == ELF::ELFCLASS64) {
     if (Type.second == ELF::ELFDATA2LSB)
       return createELFFileAux<T<ELF64LE>>(MB);
     return createELFFileAux<T<ELF64BE>>(MB);
   }
   fatal("Invalid file class: " + MB.getBufferIdentifier());
 }
 
 std::unique_ptr<InputFile> elf2::createObjectFile(MemoryBufferRef MB,
                                                   StringRef ArchiveName) {
-  std::unique_ptr<InputFile> F = createELFFile<ObjectFile>(MB);
+  using namespace sys::fs;
+  std::unique_ptr<InputFile> F;
+  if (identify_magic(MB.getBuffer()) == file_magic::bitcode)
+    F.reset(new BitcodeFile(MB));
+  else
+    F = createELFFile<ObjectFile>(MB);
   F->ArchiveName = ArchiveName;
   return F;
 }
 
 std::unique_ptr<InputFile> elf2::createSharedFile(MemoryBufferRef MB) {
   return createELFFile<SharedFile>(MB);
 }
 

ELF/Symbols.cpp

 
 std::unique_ptr<InputFile> Lazy::getMember() {
   MemoryBufferRef MBRef = File->getMember(&Sym);
 
   // getMember returns an empty buffer if the member was already
   // read from the library.
   if (MBRef.getBuffer().empty())
     return std::unique_ptr<InputFile>(nullptr);
-
-  if (sys::fs::identify_magic(MBRef.getBuffer()) ==
-      sys::fs::file_magic::bitcode) {
-    auto Ret = make_unique<BitcodeFile>(MBRef);
-    Ret->ArchiveName = File->getName();
-    return std::move(Ret);
-  }
   return createObjectFile(MBRef, File->getName());
 }
 
 template <class ELFT> static void doInitSymbols() {
   ElfSym<ELFT>::End.setBinding(STB_GLOBAL);
   ElfSym<ELFT>::Ignored.setBinding(STB_WEAK);
   ElfSym<ELFT>::Ignored.setVisibility(STV_HIDDEN);
 }

test/ELF/lto/archive.ll

 ; REQUIRES: x86
 ; RUN: llvm-as %S/Inputs/archive.ll -o %t1.o
 ; RUN: rm -f %t.a
 ; RUN: llvm-ar rcs %t.a %t1.o
 ; RUN: llvm-as %s -o %t2.o
 ; RUN: ld.lld -m elf_x86_64 %t2.o %t.a -o %t3 -shared
 ; RUN: llvm-readobj -t %t3 | FileCheck %s
+; RUN: ld.lld -m elf_x86_64 %t2.o --whole-archive %t.a -o %t3 -shared
+; RUN: llvm-readobj -t %t3 | FileCheck %s
 
 
 ; CHECK:      Name: g (
 ; CHECK-NEXT: Value:
 ; CHECK-NEXT: Size:
 ; CHECK-NEXT: Binding: Global
 ; CHECK-NEXT: Type: Function
 ; CHECK-NEXT: Other: 0