[lld-macho] Add LTO cache support

[lgrey]

Summary

This adds support for the lld-only --thinlto-cache-policy option, as well as implementations for ld64's -cache_path_lto, -prune_interval_lto, -prune_after_lto, and -max_relative_cache_size_lto.

Because llvm::CachePruningPolicy has reasonable default values, it's infeasible to give --thinlto-cache-policy precedence over the individual ld64 cache pruning options without replicating the parsing code. Currently, we ignore the individual options when the composite option is provided, but we can also give the individual options precedence if that seems better.

Test is adapted from lld/test/ELF/lto/cache.ll

[lgrey]

lld/MachO/Driver.cpp

1218

This is really awkward and repetitive but I couldn't think of a way to abstract this without making it *more* complex 🤷

[thakis]

Nice :)

lld/MachO/Driver.cpp

1218

As far as I can tell, parseCachePruningPolicy() applies options on top of the defaults in the policy, so using it doesn't conflict with using the reasonable defaults for things not specified. The way I'd try to structure this is:

SmallString<128> ltoPolicy; 
auto add = [ltoPolicy](Twine add) {
  if (ltoPolicy.empty())
    ltoPolicy.append(':');
  ltoPolicy.append(add);
}
for (const Arg *arg : args.filtered(OPT_thinlto_cache_policy, OPT_prune_interval_lto,
                                                       OPT_prune_after_lto, OPT_max_relative_cache_size_lto)) {
  switch (arg->getOption().getID()) {
  case OPT_thinlto_cache_policy: add(arg->getValue()); break;
  case OPT_prune_interval_lto:
    if (!strcmp("-1", arg->getValue())
      add("prune_interval=87600h"); // 10 years
    else
      add(Twine("prune_interval=") + arg->getValue() + "s");
    break;
  case OPT_prune_after_lto: add(Twine("prune_after=" + arg->getValue() + "s"); break;
  case OPT_max_relative_cache_size_lto: add(Twine("cache_size=" + arg->getValue() + "%"); break;
  }
}
config->thinLTOCachePolicy =
      CHECK(parseCachePruningPolicy(ltoPolicy),
            "invalid LTO cache policy");

I think that should work and it seems like a fairly natural way to handle this to me.

In any case, please pull the cache policy flag handling logic into a handleLTOPolicyFlags() helper function.

lld/MachO/LTO.cpp

129

Why is this here? The other ports don't have it.

154

The COFF port says

// Get the native object contents either from the cache or from memory.  Do
// not use the cached MemoryBuffer directly, or the PDB will not be
// deterministic.

Is this something we need to worry about? (Fine as-is for now in any case though.)

lld/MachO/Options.td

71

lld-style options use -- and style Joined if they take args, and then use a trailing = (…usually. --lto-O is an exception). This makes the lld extensions look different from the ld64 compat options.

(eg Joined<["--"], "thinlto-cache-policy=" ...)

lld/test/MachO/Inputs/lto-cache.ll

10 ↗

(On Diff #358356)

You can use split-file to have several .ll files in a single .ll test file. See e.g. lld/test/MachO/lto-save-temps.ll for an example.

(split-file is new(ish), that's why most ELF tests don't use it yet)

lld/test/MachO/lto-cache.ll

6

Mention in CL desc that the test is based on lld/test/ELF/lto/cache.ll

13

nit: You can put \ at the end of a RUN line to continue it on the next line:

; RUN: foo bar baz \
; RUN:   quux

LLVM's style technically is 80 cols, but some people go a bit over in test files sometimes. But keeping it short enough so it doesn't wrap in phab is probably a good idea.

53

Can you add some coverage for the ld64-style options too?

[int3]

lld/MachO/Driver.cpp

1224

no need for llvm::

lld/MachO/LTO.h

12

if we only need MemoryBuffer in this header, can we just include MemoryBuffer.h?

lld/test/MachO/lto-cache.ll

10–11

nit: we usually double-comment the "real" comments in lit tests, to distinguish them from RUN/CHECK lines

[lgrey]

lld/MachO/Driver.cpp

1218

Sorry, I wasn't clear. What I meant:
-parseCachePruningPolicy creates a new object, vs. updating an existing object in place

• Since a default-constructed CachePruningPolicy has defaults, you can't tell which fields parseCachePruningPolicy are default and which came from the string
• So that means, you either fill in a default constructed object and set values from the individual options and then stomp it with the new object from parseCachePruningPolicy, or you create an object with parseCachePruningPolicy, and fill in the individual options, except we have no way of knowing which fields were set by the policy string and which are default.

That said, a variant of this way works! But: it relies on an implementation detail in parseCachePruningPolicy: the fact that the string is parsed in order. That feels fragile to me, but happy to defer.

1224

Using the method thakis@ suggested instead.

lld/MachO/LTO.cpp

129

Reverted because of Chesterton's fence, but I don't really get it. We check for the first one, why not the rest? Overall, it's not immediately obvious to me that the interaction of save temps and caching works correctly as written in ELF/COFF (are we overwriting existing temps from cache hits with an empty buffer?)

154

Based on the review when it was added, I would *guess* not. I'll experiment with some dSYMs.

[thakis]

LG with minor comments addressed :)

lld/MachO/Driver.cpp

225

I'd put this in the loop above: If you say -prune_interval 10 --thinlto-cache-policy=20s -prune_interval 30 I think it's least surprising if you end up with a prune interval of 30s.

We usually follow a "last setting on commandline wins" policy: For example, -Wno-return-type disables the warning for missing return types, -Wno-return-type -Wall enables it because -Wall is later and overrides it, -Wno-return-type -Wall -Wno-return-type disables it. That's a somewhat academic discussion since in practice nobody will pass both kinds of flags here, but I think it's still better to process them in order.

Also, as-is, this ignores all but the last --thin-lto-cache-policy= flag, and processing them in the loop together with the others fixes that too.

lld/test/MachO/lto-cache.ll

53

nit: -max_relative_cache_size_lto is still untested

[thakis]

lld/test/MachO/lto-cache.ll

27

Looks like date -v fails on Linux and Windows, see presubmit bot above.

[lgrey]

thakis@ comments

[lgrey]

lld/test/MachO/lto-cache.ll

27

Removed since the functionality this was testing changed

lld/MachO/Config.h

 //===- Config.h -------------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_MACHO_CONFIG_H
 #define LLD_MACHO_CONFIG_H
 
 #include "llvm/ADT/CachedHashString.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/MachO.h"
+#include "llvm/Support/CachePruning.h"
 #include "llvm/Support/GlobPattern.h"
 #include "llvm/Support/VersionTuple.h"
 #include "llvm/TextAPI/Architecture.h"
 #include "llvm/TextAPI/Platform.h"
 #include "llvm/TextAPI/Target.h"
 
 #include <vector>
 
struct Configuration {
   llvm::StringRef finalOutput;
 
   llvm::StringRef installName;
   llvm::StringRef mapFile;
   llvm::StringRef ltoObjPath;
   llvm::StringRef thinLTOJobs;
   llvm::StringRef umbrella;
   uint32_t ltoo = 2;
+  llvm::CachePruningPolicy thinLTOCachePolicy;
+  llvm::StringRef thinLTOCacheDir;
   bool deadStripDylibs = false;
   bool demangle = false;
   bool deadStrip = false;
   PlatformInfo platformInfo;
   NamespaceKind namespaceKind = NamespaceKind::twolevel;
   UndefinedSymbolTreatment undefinedSymbolTreatment =
       UndefinedSymbolTreatment::error;
   ICFLevel icfLevel = ICFLevel::none;

lld/MachO/Driver.cpp

 
 static std::vector<StringRef>
 getFrameworkSearchPaths(InputArgList &args,
                         const std::vector<StringRef> &roots) {
   return getSearchPaths(OPT_F, args, roots,
                         {"/Library/Frameworks", "/System/Library/Frameworks"});
 }
 
+static llvm::CachePruningPolicy getLTOCachePolicy(InputArgList &args) {
+  SmallString<128> ltoPolicy;
+  auto add = [&ltoPolicy](Twine val) {
+    if (!ltoPolicy.empty())
+      ltoPolicy += ":";
+    val.toVector(ltoPolicy);
+  };
+  for (const Arg *arg :
+       args.filtered(OPT_prune_interval_lto, OPT_prune_after_lto,
+                     OPT_max_relative_cache_size_lto)) {
+    switch (arg->getOption().getID()) {
+    case OPT_prune_interval_lto:
+      if (!strcmp("-1", arg->getValue()))
+        add("prune_interval=87600h"); // 10 years
+      else
+        add(Twine("prune_interval=") + arg->getValue() + "s");
+      break;
+    case OPT_prune_after_lto:
+      add(Twine("prune_after=") + arg->getValue() + "s");
+      break;
+    case OPT_max_relative_cache_size_lto:
+      add(Twine("cache_size=") + arg->getValue() + "%");
+      break;
+    }
+  }
+  // This goes last because `parseCachePruningPolicy` reads the string in order.
+  // Anything specified in `--thinlto-cache-policy` will override individual
+  // ld64-compat options in case of conflic.
+  if (const Arg *arg = args.getLastArg(OPT_thinlto_cache_policy)) {
+    add(arg->getValue());
+  }
+  return CHECK(parseCachePruningPolicy(ltoPolicy), "invalid LTO cache policy");
+}
+
 namespace {
 struct ArchiveMember {
   MemoryBufferRef mbref;
   uint32_t modTime;
 };
 } // namespace
 
 // Returns slices of MB by parsing MB as an archive file.
bool macho::link(ArrayRef<const char *> argsArr, bool canExitEarly,
   }
   config->ltoObjPath = args.getLastArgValue(OPT_object_path_lto);
   config->ltoNewPassManager =
       args.hasFlag(OPT_no_lto_legacy_pass_manager, OPT_lto_legacy_pass_manager,
                    LLVM_ENABLE_NEW_PASS_MANAGER);
   config->ltoo = args::getInteger(args, OPT_lto_O, 2);
   if (config->ltoo > 3)
     error("--lto-O: invalid optimization level: " + Twine(config->ltoo));
+  config->thinLTOCacheDir = args.getLastArgValue(OPT_cache_path_lto);
+  config->thinLTOCachePolicy = getLTOCachePolicy(args);
   config->runtimePaths = args::getStrings(args, OPT_rpath);
   config->allLoad = args.hasArg(OPT_all_load);
   config->archMultiple = args.hasArg(OPT_arch_multiple);
   config->applicationExtension = args.hasFlag(
       OPT_application_extension, OPT_no_application_extension, false);
   config->exportDynamic = args.hasArg(OPT_export_dynamic);
   config->forceLoadObjC = args.hasArg(OPT_ObjC);
   config->forceLoadSwift = args.hasArg(OPT_force_load_swift_libs);
   config->deadStripDylibs = args.hasArg(OPT_dead_strip_dylibs);
   config->demangle = args.hasArg(OPT_demangle);
   config->implicitDylibs = !args.hasArg(OPT_no_implicit_dylibs);
   config->emitFunctionStarts =
       args.hasFlag(OPT_function_starts, OPT_no_function_starts, true);
   config->emitBitcodeBundle = args.hasArg(OPT_bitcode_bundle);
   config->emitDataInCodeInfo =
       args.hasFlag(OPT_data_in_code_info, OPT_no_data_in_code_info, true);
   config->icfLevel = getICFLevel(args);
   config->dedupLiterals = args.hasArg(OPT_deduplicate_literals) ||
                           config->icfLevel != ICFLevel::none;
 
   // FIXME: Add a commandline flag for this too.

lld/MachO/LTO.h

 //===- LTO.h ----------------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_MACHO_LTO_H
 #define LLD_MACHO_LTO_H
 
 #include "llvm/ADT/SmallString.h"
+#include "llvm/Support/MemoryBuffer.h"
 #include <memory>
 #include <vector>
 
 namespace llvm {
 namespace lto {
 class LTO;
 } // namespace lto
 } // namespace llvm
public:
   BitcodeCompiler();
 
   void add(BitcodeFile &f);
   std::vector<ObjFile *> compile();
 
 private:
   std::unique_ptr<llvm::lto::LTO> ltoObj;
   std::vector<llvm::SmallString<0>> buf;
+  std::vector<std::unique_ptr<llvm::MemoryBuffer>> files;
 };
 
 } // namespace macho
 } // namespace lld
 
 #endif

lld/MachO/LTO.cpp

 #include "InputFiles.h"
 #include "Symbols.h"
 #include "Target.h"
 
 #include "lld/Common/Args.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Strings.h"
 #include "lld/Common/TargetOptionsCommandFlags.h"
+#include "llvm/LTO/Caching.h"
+#include "llvm/LTO/Config.h"
 #include "llvm/LTO/LTO.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/ObjCARC.h"
 
 using namespace lld;
 using namespace lld::macho;
void BitcodeCompiler::add(BitcodeFile &f) {
   checkError(ltoObj->add(std::move(f.obj), resols));
 }
 
 // Merge all the bitcode files we have seen, codegen the result
 // and return the resulting ObjectFile(s).
 std::vector<ObjFile *> BitcodeCompiler::compile() {
   unsigned maxTasks = ltoObj->getMaxTasks();
   buf.resize(maxTasks);
+  files.resize(maxTasks);
 
-  checkError(ltoObj->run([&](size_t task) {
+  // The -cache_path_lto option specifies the path to a directory in which
+  // to cache native object files for ThinLTO incremental builds. If a path was
+  // specified, configure LTO to use it as the cache directory.
+  lto::NativeObjectCache cache;
+  if (!config->thinLTOCacheDir.empty())
+    cache = check(
+        lto::localCache(config->thinLTOCacheDir,
+                        [&](size_t task, std::unique_ptr<MemoryBuffer> mb) {
+                          files[task] = std::move(mb);
+                        }));
+
+  checkError(ltoObj->run(
+      [&](size_t task) {
         return std::make_unique<lto::NativeObjectStream>(
             std::make_unique<raw_svector_ostream>(buf[task]));
-  }));
+      },
+      cache));
+
+  if (!config->thinLTOCacheDir.empty())
+    pruneCache(config->thinLTOCacheDir, config->thinLTOCachePolicy);
 
   if (config->saveTemps) {
     if (!buf[0].empty())
       saveBuffer(buf[0], config->outputFile + ".lto.o");
     for (unsigned i = 1; i != maxTasks; ++i)
       saveBuffer(buf[i], config->outputFile + Twine(i) + ".lto.o");
   }
 
   if (!config->ltoObjPath.empty())
     fs::create_directories(config->ltoObjPath);
 
   std::vector<ObjFile *> ret;
   for (unsigned i = 0; i != maxTasks; ++i) {
     if (buf[i].empty())
       continue;
     SmallString<261> filePath("/tmp/lto.tmp");
     uint32_t modTime = 0;
     if (!config->ltoObjPath.empty()) {
       filePath = config->ltoObjPath;
       path::append(filePath, Twine(i) + "." +
                                  getArchitectureName(config->arch()) +
                                  ".lto.o");
       saveBuffer(buf[i], filePath);
       modTime = getModTime(filePath);
     }
     ret.push_back(make<ObjFile>(
         MemoryBufferRef(buf[i], saver.save(filePath.str())), modTime, ""));
   }
-
+  for (std::unique_ptr<MemoryBuffer> &file : files)
+    if (file)
+      ret.push_back(make<ObjFile>(*file, 0, ""));
   return ret;
 }

lld/MachO/Options.td

 def icf_eq: Joined<["--"], "icf=">,
     HelpText<"Set level for identical code folding (default: none)">,
     MetaVarName<"[none,safe,all]">,
     Group<grp_lld>;
 def lto_O: Joined<["--"], "lto-O">,
     HelpText<"Set optimization level for LTO (default: 2)">,
     MetaVarName<"<opt-level>">,
     Group<grp_lld>;
+def thinlto_cache_policy: Joined<["--"], "thinlto-cache-policy=">,
+    HelpText<"Pruning policy for the ThinLTO cache">,
+    Group<grp_lld>;
 
 // This is a complete Options.td compiled from Apple's ld(1) manpage
 // dated 2018-03-07 and cross checked with ld64 source code in repo
 // https://github.com/apple-opensource/ld64 at git tag "512.4" dated
 // 2018-03-18.
 
 // Flags<[HelpHidden]> marks options that are not yet ported to lld,
 // and serve as a scoreboard for annotating our progress toward
def no_objc_category_merging : Flag<["-"], "no_objc_category_merging">,
     Group<grp_rare>;
 def object_path_lto : Separate<["-"], "object_path_lto">,
     MetaVarName<"<path>">,
     HelpText<"Retain any temporary mach-o file in <path> that would otherwise be deleted during LTO">,
     Group<grp_rare>;
 def cache_path_lto : Separate<["-"], "cache_path_lto">,
     MetaVarName<"<path>">,
     HelpText<"Use <path> as a directory for the incremental LTO cache">,
-    Flags<[HelpHidden]>,
     Group<grp_rare>;
 def prune_interval_lto : Separate<["-"], "prune_interval_lto">,
     MetaVarName<"<seconds>">,
     HelpText<"Prune the incremental LTO cache after <seconds> (-1 disables pruning)">,
-    Flags<[HelpHidden]>,
     Group<grp_rare>;
 def prune_after_lto : Separate<["-"], "prune_after_lto">,
     MetaVarName<"<seconds>">,
     HelpText<"Remove LTO cache entries after <seconds>">,
-    Flags<[HelpHidden]>,
     Group<grp_rare>;
 def max_relative_cache_size_lto : Separate<["-"], "max_relative_cache_size_lto">,
     MetaVarName<"<percent>">,
     HelpText<"Limit the incremental LTO cache growth to <percent> of free disk, space">,
-    Flags<[HelpHidden]>,
     Group<grp_rare>;
 def page_align_data_atoms : Flag<["-"], "page_align_data_atoms">,
     HelpText<"Distribute global variables on separate pages so page used/dirty status can guide creation of an order file to cluster commonly used/dirty globals">,
     Flags<[HelpHidden]>,
     Group<grp_rare>;
 def not_for_dyld_shared_cache : Flag<["-"], "not_for_dyld_shared_cache">,
     HelpText<"Prevent system dylibs from being placed into the dylib shared cache">,
     Flags<[HelpHidden]>,

lld/test/MachO/lto-cache.ll

+; REQUIRES: x86
+; NetBSD: noatime mounts currently inhibit 'touch' from updating atime
+; UNSUPPORTED: system-netbsd
+
+; RUN: rm -rf %t; split-file %s %t
+; RUN: opt -module-hash -module-summary %t/foo.ll -o %t/foo.o
+; RUN: opt -module-hash -module-summary %t/bar.ll -o %t/bar.o
+
+; RUN: rm -Rf %t/cache && mkdir %t/cache
+;; Create two files that would be removed by cache pruning due to age.
+;; We should only remove files matching the pattern "llvmcache-*".
+; RUN: touch -t 197001011200 %t/cache/llvmcache-baz %t/cache/baz
+; RUN: %lld -cache_path_lto %t/cache \
+; RUN:   --thinlto-cache-policy=prune_after=1h:prune_interval=0s \
+; RUN:   -o %t/test %t/foo.o %t/bar.o
+
+;; Two cached objects, plus a timestamp file and "baz", minus the file we removed.
+; RUN: ls %t/cache | count 4
+
+;; Same thing, but with `-prune_after_lto`
+; RUN: touch -t 197001011200 %t/cache/llvmcache-baz
+; RUN: %lld -cache_path_lto %t/cache -prune_after_lto 3600 -prune_interval_lto 0 \
+; RUN:   -o %t/test %t/foo.o %t/bar.o
+; RUN: ls %t/cache | count 4
+
+;; --thin-lto-cache-policy should take precedence over -prune_after_lto
+; RUN: touch -t $(date -v-30M +%Y%m%d%H%M) %t/cache/llvmcache-baz
+; RUN: %lld -cache_path_lto %t/cache -prune_after_lto 900 \
+; RUN:   --thinlto-cache-policy=prune_after=60m:prune_interval=0s \
+; RUN:   -o %t/test %t/foo.o %t/bar.o
+;; File is 30 min old. `--lto-cache-policy` says 60 min, `-prune_after_lto` says
+;; 15 minutes; `--lto-cache-policy` wins and the file remains.
+; RUN: ls %t/cache | count 5
+
+; RUN: %lld -cache_path_lto %t/cache -prune_after_lto 3600 \
+; RUN:   --thinlto-cache-policy=prune_after=15m:prune_interval=0s \
+; RUN:   -o %t/test %t/foo.o %t/bar.o
+;; Now `--lto-cache-policy` says 15 min and `-prune_after_lto` says 60 minutes;
+;; `--lto-cache-policy` wins and the file is deleted.
+; RUN: ls %t/cache | count 4
+
+;; Create a file of size 64KB.
+; RUN: %python -c "print(' ' * 65536)" > %t/cache/llvmcache-baz
+
+;; This should leave the file in place.
+; RUN: %lld -cache_path_lto %t/cache \
+; RUN:   --thinlto-cache-policy=cache_size_bytes=128k:prune_interval=0s \
+; RUN:   -o %t/test %t/foo.o %t/bar.o
+; RUN: ls %t/cache | count 5
+
+;; Increase the age of llvmcache-baz, which will give it the oldest time stamp
+;; so that it is processed and removed first.
+; RUN: %python -c 'import os,sys,time; t=time.time()-120; os.utime(sys.argv[1],(t,t))' \
+; RUN:    %t/cache/llvmcache-baz
+
+;; This should remove it.
+; RUN: %lld -cache_path_lto %t/cache \
+; RUN:   --thinlto-cache-policy=cache_size_bytes=32k:prune_interval=0s \
+; RUN:   -o %t/test %t/foo.o %t/bar.o
+; RUN: ls %t/cache | count 4
+
+;--- foo.ll
+
+target triple = "x86_64-apple-macosx10.15.0"
+target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+
+define void @globalfunc() #0 {
+entry:
+  ret void
+}
+
+
+;--- bar.ll
+
+target triple = "x86_64-apple-macosx10.15.0"
+target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+
+define i32 @main() {
+entry:
+  call void (...) @globalfunc()
+  ret i32 0
+}
+
+declare void @globalfunc(...)