[lld] A Unified LTO Bitcode Frontend

[ormris]

Summary

The unified LTO pipeline creates a single LTO bitcode structure that can
be used by Thin or Full LTO. This means that the LTO mode can be chosen
at link time and that all LTO bitcode produced by the pipeline is
compatible, from an optimization perspective. This makes the behavior of
LTO a bit more predictable by normalizing the set of LTO features
supported by each LTO bitcode file.

Example usage:

# Compile and link. Select regular LTO at link time.
clang -flto -funified-lto -fuse-ld=lld foo.c

# Compile and link. Select ThinLTO at link time.
clang -flto=thin -funified-lto -fuse-ld=lld foo.c

# Link separately, using ThinLTO.
clang -c -flto -funified-lto foo.c  # -flto={full,thin} are identical in 
terms of compilation actions 
clang -flto=thin -fuse-ld=lld foo.o # pass --lto=thin to ld.lld

# Link separately, using regular LTO. 
clang -c -flto -funified-lto foo.c clang -flto -fuse-ld=lld foo.o  # pass --lto=full to ld.lld

The RFC discussing the details and rational for this change is here:
https://discourse.llvm.org/t/rfc-a-unified-lto-bitcode-frontend/61774

[ormris]

The changes in this patch have been moved to here: https://reviews.llvm.org/D123804

[ormris]

Re-opening this

[ormris]

Update

[ormris]

ping

[MaskRay]

lld/ELF/Driver.cpp

1502

This is untested. You can find some newer options added by me to check how we test errors.

lld/ELF/Options.td

581

def lto then use OPT_lto. The variable is derived from the option name.

New options don't use _eq.

lld/test/ELF/lto/unified-lto.ll

5

%0.
In newer tests, the linked output tries to use the same stem name as the main input file (%t0.o)

6

Prefer llvm-readelf -s for new tests. The tabular output is much easier to read.

[MaskRay]

In D123805#4506651, @ormris wrote:

ping

Sorry for the belated response. This patch needs to remove [WIP]

Here's a high level summary of the changes in this patch. For more information on rational, see the RFC (https://discourse.llvm.org/t/rfc-a-unified-lto-bitcode-frontend/61774).
Add flag to enable unified LTO in the desired mode.

Like what I suggested in the Clang patch, the description probably should mention how clang passes --lto= to lld.

[ormris]

Address comments. Description update incoming...

lld/ELF/Driver.cpp

1502

Fixed

lld/ELF/Options.td

581

Fixed

lld/test/ELF/lto/unified-lto.ll

5

Fixed

6

Fixed

[MaskRay]

lld/ELF/Config.h

21

This is a bit unfortunate, as we now get a lot of transitive includes to most *.cpp files in lld/ELF...

lld/ELF/Options.td

581

For new options, we prefer JJ to disallow single dashes like -lto=

lld/test/ELF/lto/unified-lto.ll

6

--symbols is identical to -s. Just use -s

[ormris]

lld/ELF/Config.h

21

I've eliminated this include using a mapping. Is removing this header worth the extra indirection?

lld/ELF/Options.td

581

Fixed

lld/test/ELF/lto/unified-lto.ll

6

Fixed

[ormris]

Address comments

[MaskRay]

LG, with the last few nits :)

lld/ELF/Config.h

21

I was on the fence. But you came up with a solution and it should work, I think it's fine to have the indirection. Thanks!

99

Since we don't allow --lto ... (JJ)

422

LtoKind ltoKind or LtoMode ltoMode should be a better name.

lld/ELF/LTO.cpp

209–215

constexpr

213

delete blank line

[ormris]

lld/ELF/Config.h

99

Fixed

422

Fixed

lld/ELF/LTO.cpp

209–215

Fixed

213

Fixed

[ormris]

Final changes

[ormris]

Thanks!

lld/ELF/Config.h

 #include "llvm/ADT/CachedHashString.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/CachePruning.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/GlobPattern.h"
 #include "llvm/Support/PrettyStackTrace.h"

 enum class ARMVFPArgKind { Default, Base, VFP, ToolChain };
 
 // For -z noseparate-code, -z separate-code and -z separate-loadable-segments.
 enum class SeparateSegmentKind { None, Code, Loadable };
 
 // For -z *stack
 enum class GnuStackKind { None, Exec, NoExec };
 
+// For --lto=
+enum LtoKind : uint8_t {UnifiedThin, UnifiedRegular, Default};
+
 struct SymbolVersion {
   llvm::StringRef name;
   bool isExternCpp;
   bool hasWildcard;
 };
 
 // This struct contains symbols version definition that
 // can be found in version script if it is used for link.
struct Config {
   int androidMemtagMode;
   // Signal to the dynamic loader to enable heap MTE.
   bool androidMemtagHeap;
   // Signal to the dynamic loader that this binary expects stack MTE. Generally,
   // this means to map the primary and thread stacks as PROT_MTE. Note: This is
   // not supported on Android 11 & 12.
   bool androidMemtagStack;
 
+  // When using a unified pre-link LTO pipeline, specify the backend LTO mode.
+  LtoKind ltoKind = LtoKind::Default;
+
   unsigned threadCount;
 
   // If an input file equals a key, remap it to the value.
   llvm::DenseMap<llvm::StringRef, llvm::StringRef> remapInputs;
   // If an input file matches a wildcard pattern, remap it to the value.
   llvm::SmallVector<std::pair<llvm::GlobPattern, llvm::StringRef>, 0>
       remapInputsWildcards;
 };

lld/ELF/Driver.cpp

static void readConfigs(opt::InputArgList &args) {
   config->passPlugins = args::getStrings(args, OPT_load_pass_plugins);
 
   // Parse -mllvm options.
   for (const auto *arg : args.filtered(OPT_mllvm)) {
     parseClangOption(arg->getValue(), arg->getSpelling());
     config->mllvmOpts.emplace_back(arg->getValue());
   }
 
+  config->ltoKind = LtoKind::Default;
+  if (auto *arg = args.getLastArg(OPT_lto)) {
+    StringRef s = arg->getValue();
+    if (s == "thin")
+      config->ltoKind = LtoKind::UnifiedThin;
+    else if (s == "full")
+      config->ltoKind = LtoKind::UnifiedRegular;
+    else if (s == "default")
+      config->ltoKind = LtoKind::Default;
+    else
+      error("unknown LTO mode: " + s);
+  }
+
   // --threads= takes a positive integer and provides the default value for
   // --thinlto-jobs=. If unspecified, cap the number of threads since
   // overhead outweighs optimization for used parallel algorithms for the
   // non-LTO parts.
   if (auto *arg = args.getLastArg(OPT_threads)) {
     StringRef v(arg->getValue());
     unsigned threads = 0;
     if (!llvm::to_integer(v, threads, 0) || threads == 0)

lld/ELF/LTO.cpp

backend = lto::createWriteIndexesThinBackend(
         config->thinLTOEmitImportsFiles, indexFile.get(), onIndexWrite);
   } else {
     backend = lto::createInProcessThinBackend(
         llvm::heavyweight_hardware_concurrency(config->thinLTOJobs),
         onIndexWrite, config->thinLTOEmitIndexFiles,
         config->thinLTOEmitImportsFiles);
   }
 
-  ltoObj = std::make_unique<lto::LTO>(createConfig(), backend,
-                                       config->ltoPartitions);
+  constexpr llvm::lto::LTO::LTOKind ltoModes[3] =
+    {llvm::lto::LTO::LTOKind::LTOK_UnifiedThin,
+     llvm::lto::LTO::LTOKind::LTOK_UnifiedRegular,
+     llvm::lto::LTO::LTOKind::LTOK_Default};
+  ltoObj = std::make_unique<lto::LTO>(
+      createConfig(), backend, config->ltoPartitions,
+      ltoModes[config->ltoKind]);
 
   // Initialize usedStartStop.
   if (ctx.bitcodeFiles.empty())
     return;
   for (Symbol *sym : symtab.getSymbols()) {
     if (sym->isPlaceholder())
       continue;
     StringRef s = sym->getName();

lld/ELF/Options.td

 def: Flag<["-"], "S">, Alias<strip_debug>, HelpText<"Alias for --strip-debug">;
 def: Flag<["-"], "t">, Alias<trace>, HelpText<"Alias for --trace">;
 def: Joined<["-", "--"], "Ttext-segment=">, Alias<Ttext_segment>;
 def: JoinedOrSeparate<["-"], "y">, Alias<trace_symbol>, HelpText<"Alias for --trace-symbol">;
 def: JoinedOrSeparate<["-"], "u">, Alias<undefined>, HelpText<"Alias for --undefined">;
 def: Flag<["-"], "V">, Alias<v>, HelpText<"Alias for -v">;
 
 // LTO-related options.
+
+def lto: JJ<"lto=">, HelpText<"Set LTO backend">,
+                 MetaVarName<"[full,thin]">;
 def lto_aa_pipeline: JJ<"lto-aa-pipeline=">,
   HelpText<"AA pipeline to run during LTO. Used in conjunction with -lto-newpm-passes">;
 def lto_debug_pass_manager: FF<"lto-debug-pass-manager">,
   HelpText<"Debug new pass manager">;
 def lto_emit_asm: FF<"lto-emit-asm">,
   HelpText<"Emit assembly code">;
 def lto_newpm_passes: JJ<"lto-newpm-passes=">,
   HelpText<"Passes to run during LTO">;

lld/test/ELF/lto/unified-lto.ll

+; REQUIRES: x86
+; RUN: opt -thinlto-bc -thinlto-split-lto-unit -unified-lto %s -o %t0.o
+; RUN: opt -thinlto-bc -thinlto-split-lto-unit %s -o %t1.o
+; RUN: ld.lld --lto=full %t0.o -o %t0
+; RUN: llvm-readelf -s %t0 | FileCheck %s --check-prefix=FULL
+; RUN: ld.lld --lto=thin %t0.o -o %t0
+; RUN: llvm-readelf -s %t0 | FileCheck %s --check-prefix=THIN
+; RUN: ld.lld --lto=default %t0.o -o %t0
+; RUN: llvm-readelf -s %t0 | FileCheck %s --check-prefix=THIN
+; RUN: ld.lld --lto=default %t1.o -o %t1
+; RUN: llvm-readelf -s %t1 | FileCheck %s --check-prefix=THIN
+; RUN: ld.lld %t0.o -o %t0 2>&1 | count 0
+; RUN: llvm-readelf -s %t0 | FileCheck %s --check-prefix=THIN
+; RUN: not ld.lld --lto=unknown %t1.o -o /dev/null 2>&1 | \
+; RUN:   FileCheck --implicit-check-not=error: --check-prefix=ERR %s
+; ERR: error: unknown LTO mode: unknown
+
+; FULL:      Symbol table '.symtab' contains 3 entries:
+; FULL-NEXT: Num:    Value          Size Type    Bind   Vis       Ndx Name
+; FULL-NEXT: 0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT   UND
+; FULL-NEXT: 1: 0000000000000000     0 FILE    LOCAL  DEFAULT   ABS ld-temp.o
+; FULL-NEXT: 2: 0000000000201120     1 FUNC    GLOBAL DEFAULT     1 _start
+
+; THIN:      Symbol table '.symtab' contains 3 entries:
+; THIN-NEXT: Num:    Value          Size Type    Bind   Vis       Ndx Name
+; THIN-NEXT: 0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT   UND
+; THIN-NEXT: 1: 0000000000000000     0 FILE    LOCAL  DEFAULT   ABS unified-lto.ll
+; THIN-NEXT: 2: 0000000000201120     1 FUNC    GLOBAL DEFAULT     1 _start
+
+target triple = "x86_64-unknown-linux-gnu"
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+
+define void @_start() {
+  ret void
+}