[lld-link] implement -lto-obj-path

[inglorion]

Summary

This adds the -lto-obj-path option to lld-link. This can be
used to specify a path at which to write a native object file for
the full LTO part when using LTO unit splitting.

[rnk]

I think the command line flag needs a better name to indicate that it's the destination for the merged, whole-program bitcode file. In ELF, the config name is ltoObjPath, and the flag is -plugin-opt=obj-path=. I think we can be more descriptive. How about: -split-bc-path:, -merged-bc-path:, -lto-bc-path, or something else descriptive?

[inglorion]

In ELF, the config name is ltoObjPath, and the flag is -plugin-opt=obj-path=

Yes. That's how I came up with -thinlto-obj-path. All the ThinLTO options that are -plugin-opt=??? in the ELF are -thinlto-??? in the COFF linker.

That said, I'm not opposed to giving this a more descriptive name. Since this is the path to the native object file we get out of LTO, how about -lto-merged-obj?

[inglorion]

@rnk, what do you think of the name I proposed?

[rnk]

-lto-merged-obj sounds good to me, unless anyone objects. I see it was added to the gold plugin back in rL125663, and @rdhindsa ported it to LLD LTO in rL331817.

I don't want to use the -thinlto prefix, since this should affect regular LTO as well.

[inglorion]

After discussion in person, we decided on -lto-obj-path: similar to the naming in the ELF linker, and we'

[inglorion]

'll call the Config field ltoObjPath, same as in the ELF linker.

[inglorion]

changed flag name to -lto-obj-path:

[rnk]

lgtm

[ruiu]

LGTM

lld/trunk/COFF/Config.h

struct Configuration {
   llvm::StringRef thinLTOIndexOnlyArg;
 
   // Used for /thinlto-object-prefix-replace:
   std::pair<llvm::StringRef, llvm::StringRef> thinLTOPrefixReplace;
 
   // Used for /thinlto-object-suffix-replace:
   std::pair<llvm::StringRef, llvm::StringRef> thinLTOObjectSuffixReplace;
 
+  // Used for /lto-obj-path:
+  llvm::StringRef ltoObjPath;
+
   uint64_t align = 4096;
   uint64_t imageBase = -1;
   uint64_t fileAlign = 512;
   uint64_t stackReserve = 1024 * 1024;
   uint64_t stackCommit = 4096;
   uint64_t heapReserve = 1024 * 1024;
   uint64_t heapCommit = 4096;
   uint32_t majorImageVersion = 0;

lld/trunk/COFF/Driver.cpp

void LinkerDriver::link(ArrayRef<const char *> argsArr) {
   config->thinLTOIndexOnly = args.hasArg(OPT_thinlto_index_only) ||
                              args.hasArg(OPT_thinlto_index_only_arg);
   config->thinLTOIndexOnlyArg =
       args.getLastArgValue(OPT_thinlto_index_only_arg);
   config->thinLTOPrefixReplace =
       getOldNewOptions(args, OPT_thinlto_prefix_replace);
   config->thinLTOObjectSuffixReplace =
       getOldNewOptions(args, OPT_thinlto_object_suffix_replace);
+  config->ltoObjPath = args.getLastArgValue(OPT_lto_obj_path);
   // Handle miscellaneous boolean flags.
   config->allowBind = args.hasFlag(OPT_allowbind, OPT_allowbind_no, true);
   config->allowIsolation =
       args.hasFlag(OPT_allowisolation, OPT_allowisolation_no, true);
   config->incremental =
       args.hasFlag(OPT_incremental, OPT_incremental_no,
                    !config->doGC && !config->doICF && !args.hasArg(OPT_order) &&
                        !args.hasArg(OPT_profile));

lld/trunk/COFF/LTO.cpp

for (StringRef s : thinIndices) {
     if (config->thinLTOEmitImportsFiles)
       openFile(path + ".imports");
   }
 
   // ThinLTO with index only option is required to generate only the index
   // files. After that, we exit from linker and ThinLTO backend runs in a
   // distributed environment.
   if (config->thinLTOIndexOnly) {
+    if (!config->ltoObjPath.empty())
+      saveBuffer(buf[0], config->ltoObjPath);
     if (indexFile)
       indexFile->close();
     return {};
   }
 
   if (!config->ltoCache.empty())
     pruneCache(config->ltoCache, config->ltoCachePolicy);
 

lld/trunk/COFF/Options.td

def thinlto_index_only_arg : P<
     "thinlto-index-only",
     "-thinlto-index-only and also write native module names to file">;
 def thinlto_object_suffix_replace : P<
     "thinlto-object-suffix-replace",
     "'old;new' replace old suffix with new suffix in ThinLTO index">;
 def thinlto_prefix_replace: P<
     "thinlto-prefix-replace",
     "'old;new' replace old prefix with new prefix in ThinLTO outputs">;
+def lto_obj_path : P<
+    "lto-obj-path",
+    "output native object for merged LTO unit to this path">;
 def dash_dash_version : Flag<["--"], "version">,
   HelpText<"Print version information">;
 defm threads: B<"threads",
     "Run the linker multi-threaded (default)",
     "Do not run the linker multi-threaded">;
 
 // Flags for debugging
 def lldmap : F<"lldmap">;

lld/trunk/test/COFF/lto-obj-path.ll

+; REQUIRES: x86
+
+; Test to ensure that thinlto-index-only with lto-obj-path creates
+; the native object file.
+; RUN: opt -module-summary %s -o %t1.obj
+; RUN: opt -module-summary %p/Inputs/thinlto.ll -o %t2.obj
+; RUN: rm -f %t4.obj
+; RUN: lld-link -thinlto-index-only -lto-obj-path:%t4.obj -out:t3.exe \
+; RUN:     -entry:main %t1.obj %t2.obj
+; RUN: llvm-readobj -h %t4.obj | FileCheck %s
+; RUN: llvm-nm %t4.obj 2>&1 | FileCheck %s -check-prefix=SYMBOLS
+; RUN: llvm-nm %t4.obj 2>&1 | count 1
+
+; CHECK: Format: COFF-x86-64
+; SYMBOLS: @feat.00
+
+target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-pc-windows-msvc19.0.24215"
+
+declare void @g(...)
+
+define void @main() {
+  call void (...) @g()
+  ret void
+}