ELF: Add flag for controlling LTO optimization level.

[ruiu]

ELF/Config.h

93–94

Sort.

LTOOptLevel -> LtoO because the members of Config are named after their corresponding command line options.

ELF/LTO.cpp

65

Directly set Config->LtoOptLevel instead of passing it as a parameter.

ELF/Options.td

78

I don't know if -lto-O is a good name. Does the gold LTO plugin have a simliar option? If so, what's the name of the option?

[pcc]

• Address review comments

ELF/Options.td

78

It's -plugin-opt=O. I guess we don't want to use any plugin flags here.

[ruiu]

I think I slightly prefer -lto-opt over -lto-O, but I'd like to hear others opinions too.

[mehdi_amini]

Slightly off-topic: ld64 does not have this option, and we're not willing to add it. We have been discussing internally about how to communicate the "opt level" to the linker plugin, and we were thinking about some kind of metadata that would carry the configuration (including things like "fast-math" or other codegen related options).
I'm interested in your opinion :)

[ruiu]

So the metadata would be carried on from the compiler to the linker? It feels a bit counter intuitive to me because actual LTO happens in the linker instead of the compiler. Also, if two metadata conflicts (for example, if one file has O3 and other is O1), what should we do?

[ruiu]

Looks like everybody's fine with this. LGTM.

ELF/Config.h

struct Configuration {
   bool ZExecStack;
   bool ZNodelete;
   bool ZNow;
   bool ZOrigin;
   bool ZRelro;
   ELFKind EKind = ELFNoneKind;
   uint16_t EMachine = llvm::ELF::EM_NONE;
   uint64_t EntryAddr = -1;
   unsigned Optimize = 0;
+  unsigned LTOOptLevel = 2;
 };
 
 // The only instance of Configuration struct.
 extern Configuration *Config;
 
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/Driver.cpp

if (Config->Relocatable)
     Config->StripAll = false;
 
   if (auto *Arg = Args.getLastArg(OPT_O)) {
     StringRef Val = Arg->getValue();
     if (Val.getAsInteger(10, Config->Optimize))
       error("invalid optimization level");
   }
 
+  if (auto *Arg = Args.getLastArg(OPT_lto_O)) {
+    StringRef Val = Arg->getValue();
+    if (Val.getAsInteger(10, Config->LTOOptLevel))
+      error("invalid optimization level");
+  }
+
   if (auto *Arg = Args.getLastArg(OPT_hash_style)) {
     StringRef S = Arg->getValue();
     if (S == "gnu") {
       Config->GnuHash = true;
       Config->SysvHash = false;
     } else if (S == "both") {
       Config->GnuHash = true;
     } else if (S != "sysv")

ELF/LTO.cpp

raw_fd_ostream OS(Config->OutputFile.str() + Suffix.str(), EC,
                     sys::fs::OpenFlags::F_None);
   check(EC);
   WriteBitcodeToFile(&M, OS, /* ShouldPreserveUseListOrder */ true);
 }
 
 // Run LTO passes.
 // Note that the gold plugin has a similar piece of code, so
 // it is probably better to move this code to a common place.
-static void runLTOPasses(Module &M, TargetMachine &TM) {
+static void runLTOPasses(Module &M, TargetMachine &TM, unsigned OptLevel) {
   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.OptLevel = OptLevel;
   PMB.populateLTOPassManager(LtoPasses);
   LtoPasses.run(M);
 
   if (Config->SaveTemps)
     saveBCFile(M, ".lto.opt.bc");
 }
 
 void BitcodeCompiler::add(BitcodeFile &F) {
for (const auto &Name : InternalizedSyms) {
     assert(GV);
     internalize(*GV);
   }
 
   if (Config->SaveTemps)
     saveBCFile(Combined, ".lto.bc");
 
   std::unique_ptr<TargetMachine> TM(getTargetMachine());
-  runLTOPasses(Combined, *TM);
+  runLTOPasses(Combined, *TM, Config->LTOOptLevel);
 
   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,

ELF/Options.td

def gc_sections : Flag<["--"], "gc-sections">,
   HelpText<"Enable garbage collection of unused sections">;
 
 def init : Separate<["-"], "init">, MetaVarName<"<symbol>">,
   HelpText<"Specify an initializer function">;
 
 def l : JoinedOrSeparate<["-"], "l">, MetaVarName<"<libName>">,
   HelpText<"Root name of library to use">;
 
+def lto_O : Joined<["--"], "lto-O">, MetaVarName<"<opt-level>">,
+  HelpText<"Optimization level for LTO">;
+
 def m : JoinedOrSeparate<["-"], "m">,
   HelpText<"Set target emulation">;
 
 def no_allow_shlib_undefined : Flag<["--"], "no-allow-shlib-undefined">;
 
 def no_as_needed : Flag<["--"], "no-as-needed">;
 
 def no_demangle: Flag<["--"], "no-demangle">,

test/ELF/lto/opt-level.ll

+; RUN: llvm-as -o %t.o %s
+; RUN: ld.lld -o %t0 -m elf_x86_64 -e main --lto-O0 %t.o
+; RUN: llvm-nm %t0 | FileCheck --check-prefix=CHECK-O0 %s
+; RUN: ld.lld -o %t2 -m elf_x86_64 -e main --lto-O2 %t.o
+; RUN: llvm-nm %t2 | FileCheck --check-prefix=CHECK-O2 %s
+; RUN: ld.lld -o %t2a -m elf_x86_64 -e main %t.o
+; RUN: llvm-nm %t2a | FileCheck --check-prefix=CHECK-O2 %s
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+; CHECK-O0: foo
+; CHECK-O2-NOT: foo
+define internal void @foo() {
+  ret void
+}
+
+define void @main() {
+  call void @foo()
+  ret void
+}