[lld] Support size levels with (Thin)LTO

[phosek]

Summary

Currently the size levels aren't supported at all and attempt to use
these with (Thin)LTO results in failure because lld doesn't support
anything other than optimization levels. This change extends the option
handling to properly handle the size level and pass it to the LTO
backend.

[ychen]

FYI D72404. @pcc 's opinion is this is changing direction.

[MaskRay]

Add @mehdi_amini because of https://reviews.llvm.org/D63976#1617371

[mehdi_amini]

Thanks for linking my previous comment from last summer, I don't understand why we thread this through while it is intended to be carried by function attributes?

[MaskRay]

@mehdi_amini @pcc @tejohnson

I just saw another issue saying that clang -Os -flto=thin a.c does not work https://bugs.llvm.org/show_bug.cgi?id=45913 (+ @manojgupta)
I marked it as yet another duplicate of PR42445

For -Os, clang driver passes -plugin-opt=Os (https://github.com/llvm/llvm-project/blob/master/clang/lib/Driver/ToolChains/CommonArgs.cpp#L402) but neither LLVMgold.so nor LLD recognizes -plugin-opt=Os.
-Oz is similar. What is the concrete suggestion here? For quick reference, the -plugin-opt=O logic was added by rL256146.

[phosek]

In D79818#2035232, @MaskRay wrote:

@mehdi_amini @pcc @tejohnson

I just saw another issue saying that clang -Os -flto=thin a.c does not work https://bugs.llvm.org/show_bug.cgi?id=45913 (+ @manojgupta)
I marked it as yet another duplicate of PR42445

For -Os, clang driver passes -plugin-opt=Os (https://github.com/llvm/llvm-project/blob/master/clang/lib/Driver/ToolChains/CommonArgs.cpp#L402) but neither LLVMgold.so nor LLD recognizes -plugin-opt=Os.
-Oz is similar. What is the concrete suggestion here? For quick reference, the -plugin-opt=O logic was added by rL256146.

The issue form my perspective is the inconsistency. Today, lld accepts -plugin-opt=O<number> but it doesn't accept -plugin-opt=O<letter>, but Clang automatically translates -O<anything> to -plugin-opt=O<anything> which results in a failure when your try to use -Os, -Oz or -Og with (Thin)LTO.

If the official stance of LTO maintainers is that we should be relying on function attributes and avoid overriding the optimization level via flags, then I'd argue that we should remove -plugin-opt=O<number> from lld altogether. The partial support just leads to confusion as demonstrated by some of the issues others have already referenced. In fact this change was motivated by several internal bugs from developers who tried to use ThinLTO with -Oz and hit the error even though -O2 worked fine.

[pcc]

In D79818#2035301, @phosek wrote:

In D79818#2035232, @MaskRay wrote:

@mehdi_amini @pcc @tejohnson

I just saw another issue saying that clang -Os -flto=thin a.c does not work https://bugs.llvm.org/show_bug.cgi?id=45913 (+ @manojgupta)
I marked it as yet another duplicate of PR42445

For -Os, clang driver passes -plugin-opt=Os (https://github.com/llvm/llvm-project/blob/master/clang/lib/Driver/ToolChains/CommonArgs.cpp#L402) but neither LLVMgold.so nor LLD recognizes -plugin-opt=Os.
-Oz is similar. What is the concrete suggestion here? For quick reference, the -plugin-opt=O logic was added by rL256146.

The issue form my perspective is the inconsistency. Today, lld accepts -plugin-opt=O<number> but it doesn't accept -plugin-opt=O<letter>, but Clang automatically translates -O<anything> to -plugin-opt=O<anything> which results in a failure when your try to use -Os, -Oz or -Og with (Thin)LTO.

This is where the bug is then. The clang driver should be translating these arguments to -plugin-opt O2.

[MaskRay]

In D79818#2035448, @pcc wrote:

In D79818#2035301, @phosek wrote:

In D79818#2035232, @MaskRay wrote:

@mehdi_amini @pcc @tejohnson

I just saw another issue saying that clang -Os -flto=thin a.c does not work https://bugs.llvm.org/show_bug.cgi?id=45913 (+ @manojgupta)
I marked it as yet another duplicate of PR42445

For -Os, clang driver passes -plugin-opt=Os (https://github.com/llvm/llvm-project/blob/master/clang/lib/Driver/ToolChains/CommonArgs.cpp#L402) but neither LLVMgold.so nor LLD recognizes -plugin-opt=Os.
-Oz is similar. What is the concrete suggestion here? For quick reference, the -plugin-opt=O logic was added by rL256146.

The issue form my perspective is the inconsistency. Today, lld accepts -plugin-opt=O<number> but it doesn't accept -plugin-opt=O<letter>, but Clang automatically translates -O<anything> to -plugin-opt=O<anything> which results in a failure when your try to use -Os, -Oz or -Og with (Thin)LTO.

This is where the bug is then. The clang driver should be translating these arguments to -plugin-opt O2.

Thanks. Preparing a patch to address -Os -Oz -Og -O.

edit: Created D79919

[mehdi_amini]

In D79818#2035301, @phosek wrote:

In D79818#2035232, @MaskRay wrote:

@mehdi_amini @pcc @tejohnson

I just saw another issue saying that clang -Os -flto=thin a.c does not work https://bugs.llvm.org/show_bug.cgi?id=45913 (+ @manojgupta)
I marked it as yet another duplicate of PR42445

For -Os, clang driver passes -plugin-opt=Os (https://github.com/llvm/llvm-project/blob/master/clang/lib/Driver/ToolChains/CommonArgs.cpp#L402) but neither LLVMgold.so nor LLD recognizes -plugin-opt=Os.
-Oz is similar. What is the concrete suggestion here? For quick reference, the -plugin-opt=O logic was added by rL256146.

The issue form my perspective is the inconsistency. Today, lld accepts -plugin-opt=O<number> but it doesn't accept -plugin-opt=O<letter>, but Clang automatically translates -O<anything> to -plugin-opt=O<anything> which results in a failure when your try to use -Os, -Oz or -Og with (Thin)LTO.

If the official stance of LTO maintainers is that we should be relying on function attributes and avoid overriding the optimization level via flags, then I'd argue that we should remove -plugin-opt=O<number> from lld altogether. The partial support just leads to confusion as demonstrated by some of the issues others have already referenced. In fact this change was motivated by several internal bugs from developers who tried to use ThinLTO with -Oz and hit the error even though -O2 worked fine.

The underlying issue is that O<number> vs O<letter> are somehow-but-not-really orthogonal options. Internally also, O<number> impacts the pass pipeline which isn't setup to be handled per-function, while the O<letter> is mostly communicated by adding a function attribute and does not fundamentally need to impact the optimizer pass pipeline.
Adding LTO into the mix makes it harder to reconcile: should we override the compile-time function attribute based on the link-time flag? On the other hand O<number> does not have the same problem with LTO.

[MaskRay]

In D79818#2035652, @mehdi_amini wrote:

In D79818#2035301, @phosek wrote:

In D79818#2035232, @MaskRay wrote:

@mehdi_amini @pcc @tejohnson

I just saw another issue saying that clang -Os -flto=thin a.c does not work https://bugs.llvm.org/show_bug.cgi?id=45913 (+ @manojgupta)
I marked it as yet another duplicate of PR42445

For -Os, clang driver passes -plugin-opt=Os (https://github.com/llvm/llvm-project/blob/master/clang/lib/Driver/ToolChains/CommonArgs.cpp#L402) but neither LLVMgold.so nor LLD recognizes -plugin-opt=Os.
-Oz is similar. What is the concrete suggestion here? For quick reference, the -plugin-opt=O logic was added by rL256146.

The issue form my perspective is the inconsistency. Today, lld accepts -plugin-opt=O<number> but it doesn't accept -plugin-opt=O<letter>, but Clang automatically translates -O<anything> to -plugin-opt=O<anything> which results in a failure when your try to use -Os, -Oz or -Og with (Thin)LTO.

If the official stance of LTO maintainers is that we should be relying on function attributes and avoid overriding the optimization level via flags, then I'd argue that we should remove -plugin-opt=O<number> from lld altogether. The partial support just leads to confusion as demonstrated by some of the issues others have already referenced. In fact this change was motivated by several internal bugs from developers who tried to use ThinLTO with -Oz and hit the error even though -O2 worked fine.

The underlying issue is that O<number> vs O<letter> are somehow-but-not-really orthogonal options. Internally also, O<number> impacts the pass pipeline which isn't setup to be handled per-function, while the O<letter> is mostly communicated by adding a function attribute and does not fundamentally need to impact the optimizer pass pipeline.
Adding LTO into the mix makes it harder to reconcile: should we override the compile-time function attribute based on the link-time flag? On the other hand O<number> does not have the same problem with LTO.

I see that -O<number> can affect regular LTO/ThinLTO pass manager passes (populate*PassManager (legacy PM) and build*Pipeline (new PM) called by LTOBackend.cpp:opt). Mapping -Os and -Oz to SpeedLevel 2 may be the most user convenient thing.

[phosek]

No longer needed after D79919 landed.

lld/ELF/Config.h

struct Configuration {
   ELFKind ekind = ELFNoneKind;
   uint16_t emachine = llvm::ELF::EM_NONE;
   llvm::Optional<uint64_t> imageBase;
   uint64_t commonPageSize;
   uint64_t maxPageSize;
   uint64_t mipsGotSize;
   uint64_t zStackSize;
   unsigned ltoPartitions;
-  unsigned ltoo;
+  unsigned ltoOptLevel;
+  unsigned ltoSizeLevel;
   unsigned optimize;
   StringRef thinLTOJobs;
   unsigned timeTraceGranularity;
   int32_t splitStackAdjustSize;
 
   // The following config options do not directly correspond to any
   // particular command line options.
 

lld/ELF/Driver.cpp

static std::pair<StringRef, StringRef> getOldNewOptions(opt::InputArgList &args,
 
   StringRef s = arg->getValue();
   std::pair<StringRef, StringRef> ret = s.split(';');
   if (ret.second.empty())
     error(getAliasSpelling(arg) + " expects 'old;new' format, but got " + s);
   return ret;
 }
 
+static unsigned getOptLevel(opt::InputArgList &Args) {
+  if (opt::Arg *A = Args.getLastArg(OPT_lto_O)) {
+    StringRef S = A->getValue();
+    if (S == "s" || S == "z" || S.empty())
+      return 2;
+    if (S == "g")
+      return 1;
+    int V;
+    if (!to_integer(A->getValue(), V)) {
+      StringRef Spelling = Args.getArgString(A->getIndex());
+      error(Spelling + ": number expected, but got '" + S + "'");
+      return 0;
+    }
+    return V;
+  }
+  return 2;
+}
+
+static unsigned getSizeLevel(opt::InputArgList &Args) {
+  if (opt::Arg *A = Args.getLastArg(OPT_lto_O)) {
+    switch (A->getValue()[0]) {
+    default:
+      return 0;
+    case 's':
+      return 1;
+    case 'z':
+      return 2;
+    }
+  }
+  return 0;
+}
+
 // Parse the symbol ordering file and warn for any duplicate entries.
 static std::vector<StringRef> getSymbolOrderingFile(MemoryBufferRef mb) {
   SetVector<StringRef> names;
   for (StringRef s : args::getLines(mb))
     if (!names.insert(s) && config->warnSymbolOrdering)
       warn(mb.getBufferIdentifier() + ": duplicate ordered symbol: " + s);
 
   return names.takeVector();
static void readConfigs(opt::InputArgList &args) {
   config->ltoCSProfileGenerate = args.hasArg(OPT_lto_cs_profile_generate);
   config->ltoCSProfileFile = args.getLastArgValue(OPT_lto_cs_profile_file);
   config->ltoDebugPassManager = args.hasArg(OPT_lto_debug_pass_manager);
   config->ltoEmitAsm = args.hasArg(OPT_lto_emit_asm);
   config->ltoNewPassManager = args.hasArg(OPT_lto_new_pass_manager);
   config->ltoNewPmPasses = args.getLastArgValue(OPT_lto_newpm_passes);
   config->ltoWholeProgramVisibility =
       args.hasArg(OPT_lto_whole_program_visibility);
-  config->ltoo = args::getInteger(args, OPT_lto_O, 2);
+  config->ltoOptLevel = getOptLevel(args);
+  config->ltoSizeLevel = getSizeLevel(args);
   config->ltoObjPath = args.getLastArgValue(OPT_lto_obj_path_eq);
   config->ltoPartitions = args::getInteger(args, OPT_lto_partitions, 1);
   config->ltoSampleProfile = args.getLastArgValue(OPT_lto_sample_profile);
   config->ltoBasicBlockSections =
       args.getLastArgValue(OPT_lto_basicblock_sections);
   config->ltoUniqueBBSectionNames =
       args.hasFlag(OPT_lto_unique_bb_section_names,
                    OPT_no_lto_unique_bb_section_names, false);
if (!llvm::to_integer(v, threads, 0) || threads == 0)
       error(arg->getSpelling() + ": expected a positive integer, but got '" +
             arg->getValue() + "'");
     parallel::strategy = hardware_concurrency(threads);
     config->thinLTOJobs = v;
   }
   if (auto *arg = args.getLastArg(OPT_thinlto_jobs))
     config->thinLTOJobs = arg->getValue();
 
-  if (config->ltoo > 3)
-    error("invalid optimization level for LTO: " + Twine(config->ltoo));
+  if (config->ltoOptLevel > 3)
+    error("invalid optimization level for LTO: " + Twine(config->ltoOptLevel));
+  if (config->ltoSizeLevel > 2)
+    error("invalid size level for LTO: " + Twine(config->ltoSizeLevel));
   if (config->ltoPartitions == 0)
     error("--lto-partitions: number of threads must be > 0");
   if (!get_threadpool_strategy(config->thinLTOJobs))
     error("--thinlto-jobs: invalid job count: " + config->thinLTOJobs);
 
   if (config->splitStackAdjustSize < 0)
     error("--split-stack-adjust-size: size must be >= 0");
 

lld/ELF/LTO.cpp

static lto::Config createConfig() {
   else if (config->isPic)
     c.RelocModel = Reloc::PIC_;
   else
     c.RelocModel = Reloc::Static;
 
   c.CodeModel = getCodeModelFromCMModel();
   c.DisableVerify = config->disableVerify;
   c.DiagHandler = diagnosticHandler;
-  c.OptLevel = config->ltoo;
+  c.OptLevel = config->ltoOptLevel;
+  c.SizeLevel = config->ltoSizeLevel;
   c.CPU = getCPUStr();
   c.MAttrs = getMAttrs();
-  c.CGOptLevel = args::getCGOptLevel(config->ltoo);
+  c.CGOptLevel = args::getCGOptLevel(config->ltoOptLevel);
 
   c.PTO.LoopVectorization = c.OptLevel > 1;
   c.PTO.SLPVectorization = c.OptLevel > 1;
 
   // Set up a custom pipeline if we've been asked to.
   c.OptPipeline = std::string(config->ltoNewPmPasses);
   c.AAPipeline = std::string(config->ltoAAPipeline);
 

lld/test/ELF/lto/opt-level.ll

 ; REQUIRES: x86
 ; RUN: llvm-as -o %t.o %s
 ; RUN: ld.lld -o %t0 -e main --lto-O0 %t.o
 ; RUN: llvm-nm %t0 | FileCheck --check-prefix=CHECK-O0 %s
 ; RUN: ld.lld -o %t0 -e main --plugin-opt=O0 %t.o
 ; RUN: llvm-nm %t0 | FileCheck --check-prefix=CHECK-O0 %s
 ; RUN: ld.lld -o %t2 -e main --lto-O2 %t.o
 ; RUN: llvm-nm %t2 | FileCheck --check-prefix=CHECK-O2 %s
 ; RUN: ld.lld -o %t2a -e main %t.o
 ; RUN: llvm-nm %t2a | FileCheck --check-prefix=CHECK-O2 %s
-; RUN: ld.lld -o %t2 -e main %t.o --plugin-opt O2
+; RUN: ld.lld -o %t2 -e main %t.o --plugin-opt=O2
 ; RUN: llvm-nm %t2 | FileCheck --check-prefix=CHECK-O2 %s
+; RUN: ld.lld -o %t0 -e main --lto-Oz %t.o
+; RUN: llvm-nm %t0 | FileCheck --check-prefix=CHECK-OZ %s
+; RUN: ld.lld -o %tz -e main %t.o --plugin-opt=Oz
+; RUN: llvm-nm %tz | FileCheck --check-prefix=CHECK-OZ %s
+; RUN: ld.lld -o %t0 -e main --lto-Os %t.o
+; RUN: llvm-nm %t0 | FileCheck --check-prefix=CHECK-OS %s
+; RUN: ld.lld -o %tz -e main %t.o --plugin-opt=Os
+; RUN: llvm-nm %tz | FileCheck --check-prefix=CHECK-OS %s
 
 ; Reject invalid optimization levels.
 ; RUN: not ld.lld -o /dev/null -e main --lto-O6 %t.o 2>&1 | \
 ; RUN:   FileCheck --check-prefix=INVALID1 %s
 ; INVALID1: invalid optimization level for LTO: 6
 ; RUN: not ld.lld -o /dev/null -e main --plugin-opt=O6 %t.o 2>&1 | \
 ; RUN:   FileCheck --check-prefix=INVALID1 %s
 ; RUN: not ld.lld -o /dev/null -e main --plugin-opt=Ofoo %t.o 2>&1 | \
 ; RUN:   FileCheck --check-prefix=INVALID2 %s
 ; INVALID2: --plugin-opt=Ofoo: number expected, but got 'foo'
 
 ; RUN: not ld.lld -o /dev/null -e main --lto-O-1 %t.o 2>&1 | \
 ; RUN:   FileCheck --check-prefix=INVALIDNEGATIVE1 %s
 ; INVALIDNEGATIVE1: invalid optimization level for LTO: 4294967295
 ; RUN: not ld.lld -o /dev/null -e main --plugin-opt=O-1 %t.o 2>&1 | \
 ; RUN:   FileCheck --check-prefix=INVALIDNEGATIVE2 %s
 ; INVALIDNEGATIVE2: invalid optimization level for LTO: 4294967295
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; CHECK-O0: foo
 ; CHECK-O2-NOT: foo
+; CHECK-OZ-NOT: foo
+; CHECK-OS-NOT: foo
 define internal void @foo() {
   ret void
 }
 
 define void @main() {
   call void @foo()
   ret void
 }

llvm/include/llvm/LTO/Config.h

struct Config {
   TargetOptions Options;
   std::vector<std::string> MAttrs;
   std::vector<std::string> PassPlugins;
   Optional<Reloc::Model> RelocModel = Reloc::PIC_;
   Optional<CodeModel::Model> CodeModel = None;
   CodeGenOpt::Level CGOptLevel = CodeGenOpt::Default;
   CodeGenFileType CGFileType = CGFT_ObjectFile;
   unsigned OptLevel = 2;
+  unsigned SizeLevel = 0;
   bool DisableVerify = false;
 
   /// Use the new pass manager
   bool UseNewPM = false;
 
   /// Flag to indicate that the optimizer should not assume builtins are present
   /// on the target.
   bool Freestanding = false;

llvm/lib/LTO/LTOBackend.cpp

else
     CodeModel = M.getCodeModel();
 
   return std::unique_ptr<TargetMachine>(TheTarget->createTargetMachine(
       TheTriple, Conf.CPU, Features.getString(), Conf.Options, RelocModel,
       CodeModel, Conf.CGOptLevel));
 }
 
 static void runNewPMPasses(const Config &Conf, Module &Mod, TargetMachine *TM,
-                           unsigned OptLevel, bool IsThinLTO,
-                           ModuleSummaryIndex *ExportSummary,
+                           bool IsThinLTO, ModuleSummaryIndex *ExportSummary,
                            const ModuleSummaryIndex *ImportSummary) {
   Optional<PGOOptions> PGOOpt;
   if (!Conf.SampleProfile.empty())
     PGOOpt = PGOOptions(Conf.SampleProfile, "", Conf.ProfileRemapping,
                         PGOOptions::SampleUse, PGOOptions::NoCSAction, true);
   else if (Conf.RunCSIRInstr) {
     PGOOpt = PGOOptions("", Conf.CSIRProfile, Conf.ProfileRemapping,
                         PGOOptions::IRUse, PGOOptions::CSIRInstr);
static void runNewPMPasses(const Config &Conf, Module &Mod, TargetMachine *TM,
   PB.registerLoopAnalyses(LAM);
   PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
 
   ModulePassManager MPM(Conf.DebugPassManager);
   // FIXME (davide): verify the input.
 
   PassBuilder::OptimizationLevel OL;
 
-  switch (OptLevel) {
+  switch (Conf.OptLevel) {
   default:
     llvm_unreachable("Invalid optimization level");
   case 0:
     OL = PassBuilder::OptimizationLevel::O0;
     break;
   case 1:
     OL = PassBuilder::OptimizationLevel::O1;
     break;
   case 2:
     OL = PassBuilder::OptimizationLevel::O2;
+    switch (Conf.SizeLevel) {
+    default:
+      llvm_unreachable("Invalid optimization level for size");
+    case 0:
+      OL = PassBuilder::OptimizationLevel::O2;
+      break;
+    case 1:
+      OL = PassBuilder::OptimizationLevel::Os;
+      break;
+    case 2:
+      OL = PassBuilder::OptimizationLevel::Oz;
+      break;
+    }
     break;
   case 3:
     OL = PassBuilder::OptimizationLevel::O3;
     break;
   }
 
   if (IsThinLTO)
     MPM = PB.buildThinLTODefaultPipeline(OL, Conf.DebugPassManager,
static void runOldPMPasses(const Config &Conf, Module &Mod, TargetMachine *TM,
   PMB.ImportSummary = ImportSummary;
   // Unconditionally verify input since it is not verified before this
   // point and has unknown origin.
   PMB.VerifyInput = true;
   PMB.VerifyOutput = !Conf.DisableVerify;
   PMB.LoopVectorize = true;
   PMB.SLPVectorize = true;
   PMB.OptLevel = Conf.OptLevel;
+  PMB.SizeLevel = Conf.SizeLevel;
   PMB.PGOSampleUse = Conf.SampleProfile;
   PMB.EnablePGOCSInstrGen = Conf.RunCSIRInstr;
   if (!Conf.RunCSIRInstr && !Conf.CSIRProfile.empty()) {
     PMB.EnablePGOCSInstrUse = true;
     PMB.PGOInstrUse = Conf.CSIRProfile;
   }
   if (IsThinLTO)
     PMB.populateThinLTOPassManager(passes);
   else
     PMB.populateLTOPassManager(passes);
   passes.run(Mod);
 }
 
 bool opt(const Config &Conf, TargetMachine *TM, unsigned Task, Module &Mod,
          bool IsThinLTO, ModuleSummaryIndex *ExportSummary,
          const ModuleSummaryIndex *ImportSummary) {
   // FIXME: Plumb the combined index into the new pass manager.
   if (!Conf.OptPipeline.empty())
     runNewPMCustomPasses(Conf, Mod, TM, Conf.OptPipeline, Conf.AAPipeline,
                          Conf.DisableVerify);
   else if (Conf.UseNewPM)
-    runNewPMPasses(Conf, Mod, TM, Conf.OptLevel, IsThinLTO, ExportSummary,
-                   ImportSummary);
+    runNewPMPasses(Conf, Mod, TM, IsThinLTO, ExportSummary, ImportSummary);
   else
     runOldPMPasses(Conf, Mod, TM, IsThinLTO, ExportSummary, ImportSummary);
   return !Conf.PostOptModuleHook || Conf.PostOptModuleHook(Task, Mod);
 }
 
 static cl::opt<bool> EmbedBitcode(
     "lto-embed-bitcode", cl::init(false),
     cl::desc("Embed LLVM bitcode in object files produced by LTO"));