ELF: Create LTO.{cpp,h} and move LTO-related code to that file.

[ruiu]

Summary

The code for LTO has been growing, so now is probably a good time to
move it to its own file. SymbolTable.cpp is for symbol table, and
because compiling bitcode files are semantically not a part of
symbol table, this is I think a good thing to do.

[• rafael]

LGTM.

[davide]

LGTM, thanks Rui.

[ruiu]

Committed as r264091.

[grimar]

Accept that just to be able to close it as "Changes Planned" status is a mistake here, because this patch was already committed.

[grimar]

I still can't close this, it gives me a error "You can not close this revision because it has not been accepted. You can only close accepted revisions.". I just accepted this though.

[grimar]

Rui, could you please try to close this ? I still can't do that as it gives me the same error message.

[ruiu]

Isn't it closed? I do not care about the status, but in case if it didn't work, I'll remove you from the reviewer list.

[emaste]

Isn't it closed?

Still marked as "changes planned" it seems. Maybe you have to abandon it (or upload the patch again, then close).

ELF/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS Options.td)
 tablegen(LLVM Options.inc -gen-opt-parser-defs)
 add_public_tablegen_target(ELFOptionsTableGen)
 
 add_lld_library(lldELF
   Driver.cpp
   DriverUtils.cpp
   Error.cpp
   ICF.cpp
   InputFiles.cpp
   InputSection.cpp
+  LTO.cpp
   LinkerScript.cpp
   MarkLive.cpp
   OutputSections.cpp
   SymbolTable.cpp
   Symbols.cpp
   Target.cpp
   Writer.cpp
 

ELF/LTO.h

+//===- LTO.h ----------------------------------------------------*- C++ -*-===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file provides a way to combine bitcode files into one ELF
+// file by compiling them using LLVM.
+//
+// If LTO is in use, your input files are not in regular ELF files
+// but instead LLVM bitcode files. In that case, the linker has to
+// convert bitcode files into the native format so that we can create
+// an ELF file that contains native code. This file provides that
+// functionality.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_ELF_LTO_H
+#define LLD_ELF_LTO_H
+
+#include "lld/Core/LLVM.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/Module.h"
+#include "llvm/Linker/IRMover.h"
+
+namespace lld {
+namespace elf {
+
+class BitcodeFile;
+template <class ELFT> class ObjectFile;
+
+class BitcodeCompiler {
+public:
+  void add(BitcodeFile &F);
+  template <class ELFT> std::unique_ptr<ObjectFile<ELFT>> compile();
+
+private:
+  llvm::LLVMContext Context;
+  llvm::Module Combined{"ld-temp.o", Context};
+  llvm::IRMover Mover{Combined};
+  SmallString<0> OwningData;
+  std::unique_ptr<MemoryBuffer> MB;
+};
+}
+}
+
+#endif

ELF/LTO.cpp

+//===- LTO.cpp ------------------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "LTO.h"
+#include "Config.h"
+#include "Error.h"
+#include "InputFiles.h"
+#include "Symbols.h"
+#include "llvm/Analysis/TargetLibraryInfo.h"
+#include "llvm/Analysis/TargetTransformInfo.h"
+#include "llvm/Bitcode/ReaderWriter.h"
+#include "llvm/IR/LegacyPassManager.h"
+#include "llvm/Linker/IRMover.h"
+#include "llvm/Support/StringSaver.h"
+#include "llvm/Support/TargetRegistry.h"
+#include "llvm/Target/TargetMachine.h"
+#include "llvm/Transforms/IPO.h"
+#include "llvm/Transforms/IPO/PassManagerBuilder.h"
+
+using namespace llvm;
+using namespace llvm::object;
+using namespace llvm::ELF;
+
+using namespace lld;
+using namespace lld::elf;
+
+// This is for use when debugging LTO.
+static void saveLtoObjectFile(StringRef Buffer) {
+  std::error_code EC;
+  raw_fd_ostream OS(Config->OutputFile.str() + ".lto.o", EC,
+                    sys::fs::OpenFlags::F_None);
+  check(EC);
+  OS << Buffer;
+}
+
+// This is for use when debugging LTO.
+static void saveBCFile(Module &M, StringRef Suffix) {
+  std::error_code EC;
+  raw_fd_ostream OS(Config->OutputFile.str() + Suffix.str(), EC,
+                    sys::fs::OpenFlags::F_None);
+  check(EC);
+  WriteBitcodeToFile(&M, OS, /* ShouldPreserveUseListOrder */ true);
+}
+
+static void runLTOPasses(Module &M, TargetMachine &TM) {
+  // Run LTO passes.
+  // FIXME: Reduce code duplication by sharing this code with the gold plugin.
+  legacy::PassManager LtoPasses;
+  LtoPasses.add(createTargetTransformInfoWrapperPass(TM.getTargetIRAnalysis()));
+  PassManagerBuilder PMB;
+  PMB.LibraryInfo = new TargetLibraryInfoImpl(Triple(TM.getTargetTriple()));
+  PMB.Inliner = createFunctionInliningPass();
+  PMB.VerifyInput = true;
+  PMB.VerifyOutput = true;
+  PMB.LoopVectorize = true;
+  PMB.SLPVectorize = true;
+  PMB.OptLevel = 2; // FIXME: This should be an option.
+  PMB.populateLTOPassManager(LtoPasses);
+  LtoPasses.run(M);
+
+  if (Config->SaveTemps)
+    saveBCFile(M, ".lto.opt.bc");
+}
+
+void BitcodeCompiler::add(BitcodeFile &F) {
+  std::unique_ptr<IRObjectFile> Obj =
+      check(IRObjectFile::create(F.MB, Context));
+  std::vector<GlobalValue *> Keep;
+  unsigned BodyIndex = 0;
+  ArrayRef<SymbolBody *> Bodies = F.getSymbols();
+
+  for (const BasicSymbolRef &Sym : Obj->symbols()) {
+    GlobalValue *GV = Obj->getSymbolGV(Sym.getRawDataRefImpl());
+    assert(GV);
+    if (GV->hasAppendingLinkage()) {
+      Keep.push_back(GV);
+      continue;
+    }
+    if (BitcodeFile::shouldSkip(Sym))
+      continue;
+    SymbolBody *B = Bodies[BodyIndex++];
+    if (!B || &B->repl() != B)
+      continue;
+    auto *DB = dyn_cast<DefinedBitcode>(B);
+    if (!DB)
+      continue;
+    Keep.push_back(GV);
+  }
+
+  Mover.move(Obj->takeModule(), Keep,
+             [](GlobalValue &, IRMover::ValueAdder) {});
+}
+
+// Merge all the bitcode files we have seen, codegen the result
+// and return the resulting ObjectFile.
+template <class ELFT>
+std::unique_ptr<elf::ObjectFile<ELFT>> BitcodeCompiler::compile() {
+  if (Config->SaveTemps)
+    saveBCFile(Combined, ".lto.bc");
+
+  StringRef TripleStr = Combined.getTargetTriple();
+  Triple TheTriple(TripleStr);
+
+  // FIXME: Should we have a default triple? The gold plugin uses
+  // sys::getDefaultTargetTriple(), but that is probably wrong given that this
+  // might be a cross linker.
+
+  std::string ErrMsg;
+  const Target *TheTarget = TargetRegistry::lookupTarget(TripleStr, ErrMsg);
+  if (!TheTarget)
+    fatal("target not found: " + ErrMsg);
+
+  TargetOptions Options;
+  Reloc::Model R = Config->Pic ? Reloc::PIC_ : Reloc::Static;
+  std::unique_ptr<TargetMachine> TM(
+      TheTarget->createTargetMachine(TripleStr, "", "", Options, R));
+
+  runLTOPasses(Combined, *TM);
+
+  raw_svector_ostream OS(OwningData);
+  legacy::PassManager CodeGenPasses;
+  if (TM->addPassesToEmitFile(CodeGenPasses, OS,
+                              TargetMachine::CGFT_ObjectFile))
+    fatal("failed to setup codegen");
+  CodeGenPasses.run(Combined);
+  MB = MemoryBuffer::getMemBuffer(OwningData, "", false);
+  if (Config->SaveTemps)
+    saveLtoObjectFile(MB->getBuffer());
+
+  std::unique_ptr<InputFile> IF = createObjectFile(*MB);
+  auto *OF = cast<ObjectFile<ELFT>>(IF.release());
+  return std::unique_ptr<ObjectFile<ELFT>>(OF);
+}
+
+template std::unique_ptr<elf::ObjectFile<ELF32LE>> BitcodeCompiler::compile();
+template std::unique_ptr<elf::ObjectFile<ELF32BE>> BitcodeCompiler::compile();
+template std::unique_ptr<elf::ObjectFile<ELF64LE>> BitcodeCompiler::compile();
+template std::unique_ptr<elf::ObjectFile<ELF64BE>> BitcodeCompiler::compile();

ELF/SymbolTable.h

 //===- SymbolTable.h --------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_SYMBOL_TABLE_H
 #define LLD_ELF_SYMBOL_TABLE_H
 
 #include "InputFiles.h"
+#include "LTO.h"
 #include "llvm/ADT/MapVector.h"
 
 namespace llvm {
 class Module;
 }
 
 namespace lld {
 namespace elf {

 private:
   Symbol *insert(SymbolBody *New);
   void addLazy(Lazy *New);
   void addMemberFile(Undefined *Undef, Lazy *L);
   void resolve(SymbolBody *Body);
   std::unique_ptr<InputFile> codegen(llvm::Module &M);
   std::string conflictMsg(SymbolBody *Old, SymbolBody *New);
 
-  SmallString<0> OwningLTOData;
-  std::unique_ptr<MemoryBuffer> LtoBuffer;
   ObjectFile<ELFT> *createCombinedLtoObject();
 
   // The order the global symbols are in is not defined. We can use an arbitrary
   // order, but it has to be reproducible. That is true even when cross linking.
   // The default hashing of StringRef produces different results on 32 and 64
   // bit systems so we use a MapVector. That is arbitrary, deterministic but
   // a bit inefficient.
   // FIXME: Experiment with passing in a custom hashing or sorting the symbols
private:
   // The symbol table owns all file objects.
   std::vector<std::unique_ptr<ArchiveFile>> ArchiveFiles;
   std::vector<std::unique_ptr<ObjectFile<ELFT>>> ObjectFiles;
   std::vector<std::unique_ptr<SharedFile<ELFT>>> SharedFiles;
   std::vector<std::unique_ptr<BitcodeFile>> BitcodeFiles;
 
   // Set of .so files to not link the same shared object file more than once.
   llvm::DenseSet<StringRef> SoNames;
+
+  std::unique_ptr<BitcodeCompiler> Lto;
 };
 
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/SymbolTable.cpp

 // the symbol types.
 //
 //===----------------------------------------------------------------------===//
 
 #include "SymbolTable.h"
 #include "Config.h"
 #include "Error.h"
 #include "Symbols.h"
-#include "llvm/Analysis/TargetLibraryInfo.h"
-#include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/Bitcode/ReaderWriter.h"
-#include "llvm/IR/LegacyPassManager.h"
-#include "llvm/Linker/IRMover.h"
 #include "llvm/Support/StringSaver.h"
-#include "llvm/Support/TargetRegistry.h"
-#include "llvm/Target/TargetMachine.h"
-#include "llvm/Transforms/IPO.h"
-#include "llvm/Transforms/IPO/PassManagerBuilder.h"
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::ELF;
 
 using namespace lld;
 using namespace lld::elf;
 
void SymbolTable<ELFT>::addFile(std::unique_ptr<InputFile> File) {
   // .o file
   auto *F = cast<ObjectFile<ELFT>>(FileP);
   ObjectFiles.emplace_back(cast<ObjectFile<ELFT>>(File.release()));
   F->parse(ComdatGroups);
   for (SymbolBody *B : F->getNonLocalSymbols())
     resolve(B);
 }
 
-// This is for use when debugging LTO.
-static void saveLtoObjectFile(StringRef Buffer) {
-  std::error_code EC;
-  raw_fd_ostream OS(Config->OutputFile.str() + ".lto.o", EC,
-                    sys::fs::OpenFlags::F_None);
-  check(EC);
-  OS << Buffer;
-}
-
-// This is for use when debugging LTO.
-static void saveBCFile(Module &M, StringRef Suffix) {
-  std::error_code EC;
-  raw_fd_ostream OS(Config->OutputFile.str() + Suffix.str(), EC,
-                    sys::fs::OpenFlags::F_None);
-  check(EC);
-  WriteBitcodeToFile(&M, OS, /* ShouldPreserveUseListOrder */ true);
-}
-
-static void runLTOPasses(Module &M, TargetMachine &TM) {
-  // Run LTO passes.
-  // FIXME: Reduce code duplication by sharing this code with the gold plugin.
-  legacy::PassManager LtoPasses;
-  LtoPasses.add(
-      createTargetTransformInfoWrapperPass(TM.getTargetIRAnalysis()));
-  PassManagerBuilder PMB;
-  PMB.LibraryInfo = new TargetLibraryInfoImpl(Triple(TM.getTargetTriple()));
-  PMB.Inliner = createFunctionInliningPass();
-  PMB.VerifyInput = true;
-  PMB.VerifyOutput = true;
-  PMB.LoopVectorize = true;
-  PMB.SLPVectorize = true;
-  PMB.OptLevel = 2; // FIXME: This should be an option.
-  PMB.populateLTOPassManager(LtoPasses);
-  LtoPasses.run(M);
-
-  if (Config->SaveTemps)
-    saveBCFile(M, ".lto.opt.bc");
-}
-
-// Codegen the module M and returns the resulting InputFile.
-template <class ELFT>
-std::unique_ptr<InputFile> SymbolTable<ELFT>::codegen(Module &M) {
-  StringRef TripleStr = M.getTargetTriple();
-  Triple TheTriple(TripleStr);
-
-  // FIXME: Should we have a default triple? The gold plugin uses
-  // sys::getDefaultTargetTriple(), but that is probably wrong given that this
-  // might be a cross linker.
-
-  std::string ErrMsg;
-  const Target *TheTarget = TargetRegistry::lookupTarget(TripleStr, ErrMsg);
-  if (!TheTarget)
-    fatal("target not found: " + ErrMsg);
-
-  TargetOptions Options;
-  Reloc::Model R = Config->Pic ? Reloc::PIC_ : Reloc::Static;
-  std::unique_ptr<TargetMachine> TM(
-      TheTarget->createTargetMachine(TripleStr, "", "", Options, R));
-
-  runLTOPasses(M, *TM);
-
-  raw_svector_ostream OS(OwningLTOData);
-  legacy::PassManager CodeGenPasses;
-  if (TM->addPassesToEmitFile(CodeGenPasses, OS,
-                              TargetMachine::CGFT_ObjectFile))
-    fatal("failed to setup codegen");
-  CodeGenPasses.run(M);
-  LtoBuffer = MemoryBuffer::getMemBuffer(OwningLTOData, "", false);
-  if (Config->SaveTemps)
-    saveLtoObjectFile(LtoBuffer->getBuffer());
-  return createObjectFile(*LtoBuffer);
-}
-
-static void addBitcodeFile(IRMover &Mover, BitcodeFile &F,
-                           LLVMContext &Context) {
-
-  std::unique_ptr<IRObjectFile> Obj =
-      check(IRObjectFile::create(F.MB, Context));
-  std::vector<GlobalValue *> Keep;
-  unsigned BodyIndex = 0;
-  ArrayRef<SymbolBody *> Bodies = F.getSymbols();
-
-  for (const BasicSymbolRef &Sym : Obj->symbols()) {
-    GlobalValue *GV = Obj->getSymbolGV(Sym.getRawDataRefImpl());
-    assert(GV);
-    if (GV->hasAppendingLinkage()) {
-      Keep.push_back(GV);
-      continue;
-    }
-    if (BitcodeFile::shouldSkip(Sym))
-      continue;
-    SymbolBody *B = Bodies[BodyIndex++];
-    if (!B || &B->repl() != B)
-      continue;
-    auto *DB = dyn_cast<DefinedBitcode>(B);
-    if (!DB)
-      continue;
-    Keep.push_back(GV);
-  }
-
-  Mover.move(Obj->takeModule(), Keep,
-             [](GlobalValue &, IRMover::ValueAdder) {});
-}
-
-// Merge all the bitcode files we have seen, codegen the result and return
-// the resulting ObjectFile.
-template <class ELFT>
-elf::ObjectFile<ELFT> *SymbolTable<ELFT>::createCombinedLtoObject() {
-  LLVMContext Context;
-  Module Combined("ld-temp.o", Context);
-  IRMover Mover(Combined);
-  for (const std::unique_ptr<BitcodeFile> &F : BitcodeFiles)
-    addBitcodeFile(Mover, *F, Context);
-  if (Config->SaveTemps)
-    saveBCFile(Combined, ".lto.bc");
-  std::unique_ptr<InputFile> F = codegen(Combined);
-  ObjectFiles.emplace_back(cast<ObjectFile<ELFT>>(F.release()));
-  return &*ObjectFiles.back();
-}
-
+// Compile bitcode files to the native ELF format and replace bitcode
+// symbols with regular ELF symbols, so that the link continues as if
+// bitcode files were in the native format from the beginning.
 template <class ELFT> void SymbolTable<ELFT>::addCombinedLtoObject() {
   if (BitcodeFiles.empty())
     return;
-  ObjectFile<ELFT> *Obj = createCombinedLtoObject();
+
+  // Compile bitcode files.
+  Lto.reset(new BitcodeCompiler);
+  for (const std::unique_ptr<BitcodeFile> &F : BitcodeFiles)
+    Lto->add(*F);
+  std::unique_ptr<ObjectFile<ELFT>> Obj = Lto->compile<ELFT>();
+
+  // Replace bitcode symbols.
   llvm::DenseSet<StringRef> DummyGroups;
   Obj->parse(DummyGroups);
   for (SymbolBody *Body : Obj->getNonLocalSymbols()) {
     Symbol *Sym = insert(Body);
     if (!Sym->Body->isUndefined() && Body->isUndefined())
       continue;
     Sym->Body = Body;
   }
+  ObjectFiles.push_back(std::move(Obj));
 }
 
 // Add an undefined symbol.
 template <class ELFT>
 SymbolBody *SymbolTable<ELFT>::addUndefined(StringRef Name) {
   auto *Sym = new (Alloc) Undefined(Name, false, STV_DEFAULT, false);
   resolve(Sym);
   return Sym;