[mac/lld] Implement -t

[thakis]

Summary

Goes well with -why_load to get an idea of load order.

[compnerd]

Seems fine to me. Does the output match what ld64 does?

[thakis]

In D92583#2432016, @compnerd wrote:

Seems fine to me. Does the output match what ld64 does?

Yes. (Unless you use both -t and -why_load -- then we interleave while ld64 does all -t output before all -why_load output.)

[thakis]

In D92583#2432024, @thakis wrote:

In D92583#2432016, @compnerd wrote:

Seems fine to me. Does the output match what ld64 does?

Yes. (Unless you use both -t and -why_load -- then we interleave while ld64 does all -t output before all -why_load output.)

Oh, and for .a files we only show the basename, while ld64 prints the full path to the .a (but only the basename of the .o therein). Maybe we should change all LLDs to show the full path to the .a, that feels like it'd be generally a good change.

lld/MachO/Config.h

 struct Configuration {
   Symbol *entry;
   bool hasReexports = false;
   bool allLoad = false;
   bool forceLoadObjC = false;
   bool staticLink = false;
   bool isPic = false;
   bool headerPadMaxInstallNames = false;
+  bool printEachFile = false;
   bool printWhyLoad = false;
   bool searchDylibsFirst = false;
   bool saveTemps = false;
   uint32_t headerPad;
   llvm::StringRef installName;
   llvm::StringRef outputFile;
   bool demangle = false;
   llvm::MachO::Architecture arch;

lld/MachO/Driver.h

 // Check for both libfoo.dylib and libfoo.tbd (in that order).
 llvm::Optional<std::string> resolveDylibPath(llvm::StringRef path);
 
 llvm::Optional<DylibFile *> makeDylibFromTAPI(llvm::MemoryBufferRef mbref,
                                               DylibFile *umbrella = nullptr);
 
 uint32_t getModTime(llvm::StringRef path);
 
-void printWhyLoad(StringRef reason, const InputFile *);
+void printArchiveMemberLoad(StringRef reason, const InputFile *);
 
 } // namespace macho
 } // namespace lld
 
 #endif

lld/MachO/Driver.cpp

 
 static InputFile *addFile(StringRef path, bool forceLoadArchive) {
   Optional<MemoryBufferRef> buffer = readFile(path);
   if (!buffer)
     return nullptr;
   MemoryBufferRef mbref = *buffer;
   InputFile *newFile = nullptr;
 
-  switch (identify_magic(mbref.getBuffer())) {
+  auto magic = identify_magic(mbref.getBuffer());
+  switch (magic) {
   case file_magic::archive: {
     std::unique_ptr<object::Archive> file = CHECK(
         object::Archive::create(mbref), path + ": failed to parse archive");
 
     if (!file->isEmpty() && !file->hasSymbolTable())
       error(path + ": archive has no index; run ranlib to add one");
 
     if (config->allLoad || forceLoadArchive) {
       if (Optional<MemoryBufferRef> buffer = readFile(path)) {
         for (const ArchiveMember &member : getArchiveMembers(*buffer)) {
           inputFiles.push_back(
               make<ObjFile>(member.mbref, member.modTime, path));
-          printWhyLoad((forceLoadArchive ? "-force_load" : "-all_load"),
-                       inputFiles.back());
+          printArchiveMemberLoad(
+              (forceLoadArchive ? "-force_load" : "-all_load"),
         }
       }
     } else if (config->forceLoadObjC) {
       for (const object::Archive::Symbol &sym : file->symbols())
         if (sym.getName().startswith(objc::klass))
           symtab->addUndefined(sym.getName());
 
       // TODO: no need to look for ObjC sections for a given archive member if
       // we already found that it contains an ObjC symbol. We should also
       // consider creating a LazyObjFile class in order to avoid double-loading
       // these files here and below (as part of the ArchiveFile).
       if (Optional<MemoryBufferRef> buffer = readFile(path)) {
         for (const ArchiveMember &member : getArchiveMembers(*buffer)) {
           if (hasObjCSection(member.mbref)) {
             inputFiles.push_back(
                 make<ObjFile>(member.mbref, member.modTime, path));
-            printWhyLoad("-ObjC", inputFiles.back());
+            printArchiveMemberLoad("-ObjC", inputFiles.back());
           }
         }
       }
     }
 
     newFile = make<ArchiveFile>(std::move(file));
     break;
   }
case file_magic::tapi_file: {
     break;
   }
   case file_magic::bitcode:
     newFile = make<BitcodeFile>(mbref);
     break;
   default:
     error(path + ": unhandled file type");
   }
-  if (newFile)
+  if (newFile) {
+    // printArchiveMemberLoad() prints both .a and .o names, so no need to
+    // print the .a name here.
+    if (config->printEachFile && magic != file_magic::archive)
+      lld::outs() << toString(newFile) << '\n';
     inputFiles.push_back(newFile);
+  }
   return newFile;
 }
 
 static void addFileList(StringRef path) {
   Optional<MemoryBufferRef> buffer = readFile(path);
   if (!buffer)
     return;
   MemoryBufferRef mbref = *buffer;
bool macho::link(llvm::ArrayRef<const char *> argsArr, bool canExitEarly,
 
   config->entry = symtab->addUndefined(args.getLastArgValue(OPT_e, "_main"));
   config->outputFile = args.getLastArgValue(OPT_o, "a.out");
   config->installName =
       args.getLastArgValue(OPT_install_name, config->outputFile);
   config->headerPad = args::getHex(args, OPT_headerpad, /*Default=*/32);
   config->headerPadMaxInstallNames =
       args.hasArg(OPT_headerpad_max_install_names);
+  config->printEachFile = args.hasArg(OPT_t);
   config->printWhyLoad = args.hasArg(OPT_why_load);
   config->outputType = getOutputType(args);
   config->runtimePaths = args::getStrings(args, OPT_rpath);
   config->allLoad = args.hasArg(OPT_all_load);
   config->forceLoadObjC = args.hasArg(OPT_ObjC);
   config->demangle = args.hasArg(OPT_demangle);
 
   if (const opt::Arg *arg = args.getLastArg(OPT_static, OPT_dynamic))

lld/MachO/DriverUtils.cpp

uint32_t macho::getModTime(StringRef path) {
   if (!fs::status(path, stat))
     if (fs::exists(stat))
       return toTimeT(stat.getLastModificationTime());
 
   warn("failed to get modification time of " + path);
   return 0;
 }
 
-void macho::printWhyLoad(StringRef reason, const InputFile *f) {
-  if (!config->printWhyLoad)
-    return;
-  lld::outs() << reason << " forced load of " << toString(f)
-              << '\n';
+void macho::printArchiveMemberLoad(StringRef reason, const InputFile *f) {
+  if (config->printEachFile)
+    lld::outs() << toString(f) << '\n';
+  if (config->printWhyLoad)
+    lld::outs() << reason << " forced load of " << toString(f) << '\n';
 }

lld/MachO/InputFiles.cpp

void ArchiveFile::fetch(const object::Archive::Symbol &sym) {
   // and become invalid after that call. Copy it to the stack so we can refer
   // to it later.
   const object::Archive::Symbol sym_copy = sym;
 
   auto file = make<ObjFile>(mb, modTime, getName());
 
   // ld64 doesn't demangle sym here even with -demangle. Match that, so
   // intentionally no call to toMachOString() here.
-  printWhyLoad(sym_copy.getName(), file);
+  printArchiveMemberLoad(sym_copy.getName(), file);
 
   symbols.insert(symbols.end(), file->symbols.begin(), file->symbols.end());
   subsections.insert(subsections.end(), file->subsections.begin(),
                      file->subsections.end());
 }
 
 BitcodeFile::BitcodeFile(MemoryBufferRef mbref)
     : InputFile(BitcodeKind, mbref) {
   obj = check(lto::InputFile::create(mbref));
 }

lld/MachO/Options.td

def why_live : Separate<["-"], "why_live">,
      Flags<[HelpHidden]>,
      Group<grp_introspect>;
 def print_statistics : Flag<["-"], "print_statistics">,
      HelpText<"Log the linker's memory and CPU usage">,
      Flags<[HelpHidden]>,
      Group<grp_introspect>;
 def t : Flag<["-"], "t">,
      HelpText<"Log every file the linker loads: object, archive, and dylib">,
-     Flags<[HelpHidden]>,
      Group<grp_introspect>;
 def whatsloaded : Flag<["-"], "whatsloaded">,
      HelpText<"Logs only the object files the linker loads">,
      Flags<[HelpHidden]>,
      Group<grp_introspect>;
 def order_file_statistics : Flag<["-"], "order_file_statistics">,
      HelpText<"Logs information about -order_file">,
      Flags<[HelpHidden]>,

lld/test/MachO/t.s

+# REQUIRES: x86
+# RUN: rm -rf %t
+# RUN: split-file %s %t
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-macos -o %t/foo.o %t/foo.s
+# RUN: %lld -dylib -o %t/libfoo.dylib %t/foo.o
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-macos -o %t/bar.o %t/bar.s
+# RUN: llvm-ar csr  %t/bar.a %t/bar.o
+
+# RUN: llvm-as %t/baz.ll -o %t/baz.o
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-macos -o %t/main.o %t/main.s
+
+# RUN: %lld %t/main.o %t/baz.o %t/bar.a %t/libfoo.dylib -lSystem -o /dev/null -t | FileCheck -DPATH='%:t' %s
+
+# CHECK-DAG: bar.a(bar.o)
+# CHECK-DAG: [[PATH]]/main.o
+# CHECK-DAG: [[PATH]]/baz.o
+# CHECK-DAG: [[PATH]]/libfoo.dylib
+# CHECK-DAG: {{.*}}/usr/lib/libSystem.tbd
+
+#--- foo.s
+.globl __Z3foo
+__Z3foo:
+  ret
+
+#--- bar.s
+.globl _bar
+_bar:
+  callq __Z3foo
+  ret
+
+#--- baz.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 @baz() {
+  ret void
+}
+
+#--- main.s
+.globl _main
+_main:
+  callq _bar
+  callq __Z3foo
+  callq _baz
+  ret