[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

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

142

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

17

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

15

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

I think we should keep doing what gold does.

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

145

You don't need this.

146

Start variables with an upper case letter.

147

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

test/ELF/lto/ltopasses-basic.ll

4

Please use -save-temps.

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

16

I agree with silvas' wording.

[davide]

Update after Rafael's comments.

[• rafael]

LGTM with a nit.

ELF/SymbolTable.cpp

156

Why do you need *&?

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;

test/ELF/lto/ctors.ll

 ; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
 ; RUN: ld.lld -m elf_x86_64 %t.o -o %t.so -shared
 ; RUN: llvm-readobj -sections %t.so | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @ctor, i8* null }]
 define void @ctor() {
+  call void asm "nop", ""()
   ret void
 }
 
 ; The llvm.global_ctors should end up producing constructors.
 ; CHECK: Name: .ctors

test/ELF/lto/ltopasses-basic.ll

+; REQUIRES: x86
+; RUN: rm -f %t %t.lto.bc %t.lto.opt.bc %t.lto.o
+; RUN: llvm-as %s -o %t.o
+; RUN: ld.lld -m elf_x86_64 %t.o -o %t.so -save-temps -shared
+; RUN: llvm-dis %t.so.lto.opt.bc -o - | FileCheck %s
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
[e-mail]_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @ctor, i8* null }]
+define void @ctor() {
+  ret void
+}
+
+; @ctor` doesn't do anything and so the optimizer should kill it, leaving no ctors
+; CHECK: @llvm.global_ctors = appending global [0 x { i32, void ()*, i8* }] zeroinitializer