[LTO] Call the optimizer before invoking codegen

[davide]

Summary

This is the required plumbing needed to run the LTO passes.
Now the global constructor is (correctly) stripped away from the produced shared library.

[silvas]

ELF/SymbolTable.cpp

114 ↗

(On Diff #50900)

instead of bool Optimized do const char *Suffix or StringRef Suffix or something.

143 ↗

(On Diff #50900)

Can you mention the relation to the code in gold-plugin.cpp? Something like "For now, we follow what gold-plugin.cpp does" maybe?

test/ELF/lto/ctors.ll

15 ↗

(On Diff #50900)

This kind of defeats the original purpose of this test. Can you put a volatile asm in @ctor (so it is kept) and also some piece of trivially dead code. We can do -save-temps and check that the optimized output does not have the trivially dead code without having to remove the original check.

[davide]

Addressed Sean's comments.

• The original test was augmented with an asm inline statement so that the global constructor doesn't get reclaimed.
• I added another test to ensure the optimizer strips the unused global constructor (similarly to what I did before in my previous patch).

This is just sanity checking, we may want to test other stuff in the future.
Rafael, Sean, you OK with this?

[silvas]

LGTM with a nit.

test/ELF/lto/ltopasses-basic.ll

14 ↗

(On Diff #50965)

I would describe the situation more like: "@ctor doesn't do anything and so the optimizer should kill it, leaving no ctors"

[• rafael]

ELF/SymbolTable.cpp

144 ↗

(On Diff #50965)

I think we should keep doing what gold does.

What I would have a FIXME for is refactoring this to avoid code duplication.

145 ↗

(On Diff #50965)

You don't need this.

146 ↗

(On Diff #50965)

Start variables with an upper case letter.

147 ↗

(On Diff #50965)

This line is too long. Please run git-clang-format.

test/ELF/lto/ltopasses-basic.ll

3 ↗

(On Diff #50965)

Please use -save-temps.

That way you test it and it is a more direct check aynway.

15 ↗

(On Diff #50965)

I agree with silvas' wording.

[davide]

Update after Rafael's comments.

[• rafael]

LGTM with a nit.

ELF/SymbolTable.cpp

156 ↗

(On Diff #50983)

Why do you need *&?

lld/trunk/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;
 

 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);
+}
+
 // 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));
 
+  // 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");
+
   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)
if (!DB)
       continue;
     Keep.push_back(GV);
   }
 
   Mover.move(Obj->takeModule(), Keep,
              [](GlobalValue &, IRMover::ValueAdder) {});
 }
 
-// This is for use when debugging LTO.
-static void saveBCFile(Module &M) {
-  std::error_code EC;
-  raw_fd_ostream OS(Config->OutputFile.str() + ".lto.bc", EC,
-                    sys::fs::OpenFlags::F_None);
-  check(EC);
-  WriteBitcodeToFile(&M, OS, /* ShouldPreserveUseListOrder */ true);
-}
-
 // 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);
+    saveBCFile(Combined, ".lto.bc");
   std::unique_ptr<InputFile> F = codegen(Combined);
   ObjectFiles.emplace_back(cast<ObjectFile<ELFT>>(F.release()));
   return &*ObjectFiles.back();
 }
 
 template <class ELFT> void SymbolTable<ELFT>::addCombinedLtoObject() {
   if (BitcodeFiles.empty())
     return;