[mac/lld] Implement -why_load

[thakis]

Summary

This is useful for debugging why lld loads .o it shouldn't load.
It's also useful for users of lld -- I've used ld64's version of this a
few times.

[compnerd]

Nice! Thanks @thakis, this is a rather useful debugging aid (for users of the linker).

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 printWhyLoad = false;
   bool searchDylibsFirst = false;
   bool saveTemps = false;
   uint32_t headerPad;
   llvm::StringRef installName;
   llvm::StringRef outputFile;
   bool demangle = false;
   llvm::MachO::Architecture arch;
   PlatformInfo platform;

lld/MachO/Driver.h

 #include "llvm/ADT/StringRef.h"
 #include "llvm/Option/OptTable.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 namespace lld {
 namespace macho {
 
 class DylibFile;
+class InputFile;
 
 class MachOOptTable : public llvm::opt::OptTable {
 public:
   MachOOptTable();
   llvm::opt::InputArgList parse(ArrayRef<const char *> argv);
   void printHelp(const char *argv0, bool showHidden) const;
 };
 

 // 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 *);
+
 } // namespace macho
 } // namespace lld
 
 #endif

lld/MachO/Driver.cpp

case file_magic::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());
         }
       }
     } 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());
           }
         }
       }
     }
 
     newFile = make<ArchiveFile>(std::move(file));
     break;
   }
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->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))
     config->staticLink = (arg->getOption().getID() == OPT_static);

lld/MachO/DriverUtils.cpp

 //===- DriverUtils.cpp ----------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "Driver.h"
+#include "Config.h"
 #include "InputFiles.h"
 
 #include "lld/Common/Args.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Reproduce.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
uint32_t macho::getModTime(StringRef path) {
   fs::file_status stat;
   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';
+}

lld/MachO/InputFiles.cpp

void ArchiveFile::fetch(const object::Archive::Symbol &sym) {
   uint32_t modTime = toTimeT(
       CHECK(c.getLastModified(), toString(this) +
                                      ": could not get the modification time "
                                      "for the member defining symbol " +
                                      toMachOString(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.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 commons : Separate<["-"], "commons">,
      MetaVarName<"<treatment>">,
      HelpText<"Resolve tentative definitions in dylibs according to <treatment>: ignore_dylibs, use_dylibs, error (default is ignore_dylibs)">,
      Flags<[HelpHidden]>,
      Group<grp_resolve>;
 
 def grp_introspect : OptionGroup<"introspect">, HelpText<"INTROSPECTING THE LINKER">;
 
 def why_load : Flag<["-"], "why_load">,
-     HelpText<"Log the symbol that compels loading of each object file from a static library">,
-     Flags<[HelpHidden]>,
+     HelpText<"Log why each object file is loaded from a static library">,
      Group<grp_introspect>;
 def whyload : Flag<["-"], "whyload">,
      Alias<why_load>,
      HelpText<"Alias for -why_load">,
      Flags<[HelpHidden]>,
      Group<grp_introspect>;
 def why_live : Separate<["-"], "why_live">,
      MetaVarName<"<symbol>">,

lld/test/MachO/why-load.s

+# REQUIRES: x86
+# RUN: rm -rf %t
+# RUN: split-file %s %t
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-macos -o %t/objc.o %t/objc.s
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-macos -o %t/foo.o %t/foo.s
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-macos -o %t/bar.o %t/bar.s
+# RUN: llvm-ar csr  %t/lib.a %t/objc.o %t/foo.o %t/bar.o
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-macos -o %t/main.o %t/main.s
+
+# The first line checks that we never demangle symbols in -why_load output.
+# RUN: %lld %t/main.o %t/lib.a -o /dev/null -why_load -demangle | \
+# RUN:     FileCheck %s --check-prefix=WHY
+# RUN: %lld %t/main.o -force_load %t/lib.a -o /dev/null -why_load | \
+# RUN:     FileCheck %s --check-prefix=WHYFORCE
+# RUN: %lld %t/main.o %t/lib.a -o /dev/null -all_load -why_load | \
+# RUN:     FileCheck %s --check-prefix=WHYALL
+# RUN: %lld %t/main.o -force_load %t/lib.a -o /dev/null -all_load -why_load | \
+# RUN:     FileCheck %s --check-prefix=WHYALLFORCE
+
+# RUN: %lld %t/main.o %t/lib.a -o /dev/null -ObjC -why_load | \
+# RUN:     FileCheck %s --check-prefix=WHYOBJC
+# RUN: %lld %t/main.o -force_load %t/lib.a -o /dev/null -ObjC -why_load | \
+# RUN:     FileCheck %s --check-prefix=WHYOBJCFORCE
+# RUN: %lld %t/main.o %t/lib.a -o /dev/null -ObjC -all_load -why_load | \
+# RUN:     FileCheck %s --check-prefix=WHYOBJCALL
+# RUN: %lld %t/main.o -force_load %t/lib.a -o /dev/null -ObjC -all_load -why_load | \
+# RUN:     FileCheck %s --check-prefix=WHYOBJCALLFORCE
+
+# WHY-DAG: _bar forced load of lib.a(bar.o)
+# WHY-DAG: __Z3foo forced load of lib.a(foo.o)
+# WHY-NOT: {{.*}} forced load of lib.a(objc.o)
+
+# WHYFORCE-DAG: -force_load forced load of lib.a(bar.o)
+# WHYFORCE-DAG: -force_load forced load of lib.a(foo.o)
+# WHYFORCE-DAG: -force_load forced load of lib.a(objc.o)
+
+# WHYALL-DAG: -all_load forced load of lib.a(bar.o)
+# WHYALL-DAG: -all_load forced load of lib.a(foo.o)
+# WHYALL-DAG: -all_load forced load of lib.a(objc.o)
+
+# WHYALLFORCE-DAG: -force_load forced load of lib.a(bar.o)
+# WHYALLFORCE-DAG: -force_load forced load of lib.a(foo.o)
+# WHYALLFORCE-DAG: -force_load forced load of lib.a(objc.o)
+
+# WHYOBJC-DAG: _bar forced load of lib.a(bar.o)
+# WHYOBJC-DAG: __Z3foo forced load of lib.a(foo.o)
+# WHYOBJC-DAG: -ObjC forced load of lib.a(objc.o)
+
+# WHYOBJCFORCE-DAG: -force_load forced load of lib.a(bar.o)
+# WHYOBJCFORCE-DAG: -force_load forced load of lib.a(foo.o)
+# WHYOBJCFORCE-DAG: -force_load forced load of lib.a(objc.o)
+
+# WHYOBJCALL-DAG: -all_load forced load of lib.a(bar.o)
+# WHYOBJCALL-DAG: -all_load forced load of lib.a(foo.o)
+# WHYOBJCALL-DAG: -all_load forced load of lib.a(objc.o)
+
+# WHYOBJCALLFORCE-DAG: -force_load forced load of lib.a(bar.o)
+# WHYOBJCALLFORCE-DAG: -force_load forced load of lib.a(foo.o)
+# WHYOBJCALLFORCE-DAG: -force_load forced load of lib.a(objc.o)
+
+#--- objc.s
+.section  __DATA,__objc_catlist
+.quad 0x1234
+
+#--- foo.s
+.globl __Z3foo
+__Z3foo:
+  ret
+
+#--- bar.s
+.globl _bar
+_bar:
+  callq __Z3foo
+  ret
+
+#--- main.s
+.globl _main
+_main:
+  callq _bar
+  callq __Z3foo
+  ret