[lld-macho] Don't reference entry symbol for non-executables

[int3]

Summary

This would cause us to pull in symbols (and code) that should
be unused.

[gkm]

LGTM!

lld/MachO/Config.h

76

Nit: The name entry is too generic.

lld/test/MachO/bundle-loader.s

10–12

lld/test/MachO/entry-symbol.s

11–12

[int3]

lld/MachO/Config.h

76

the other LLD ports use just entry too

lld/test/MachO/entry-symbol.s

11–12

It's supposed to be aligned to the "SYMBOL TABLE" contents above. The sectname stuff below is from a different part of the objdump output. I'll add a newline to make things clearer

[int3]

lld/MachO/Config.h

public:
   void clear();
   void insert(llvm::StringRef symbolName);
   bool matchLiteral(llvm::StringRef symbolName) const;
   bool matchGlob(llvm::StringRef symbolName) const;
   bool match(llvm::StringRef symbolName) const;
 };
 
 struct Configuration {
-  Symbol *entry;
+  Symbol *entry = nullptr;
   bool hasReexports = false;
   bool allLoad = false;
   bool forceLoadObjC = false;
   bool staticLink = false;
   bool implicitDylibs = false;
   bool isPic = false;
   bool headerPadMaxInstallNames = false;
   bool ltoNewPassManager = LLVM_ENABLE_NEW_PASS_MANAGER;

lld/MachO/Driver.cpp

if (auto *arg = args.getLastArg(OPT_threads_eq)) {
     parallel::strategy = hardware_concurrency(threads);
     config->thinLTOJobs = v;
   }
   if (auto *arg = args.getLastArg(OPT_thinlto_jobs_eq))
     config->thinLTOJobs = arg->getValue();
   if (!get_threadpool_strategy(config->thinLTOJobs))
     error("--thinlto-jobs: invalid job count: " + config->thinLTOJobs);
 
-  config->entry = symtab->addUndefined(args.getLastArgValue(OPT_e, "_main"),
-                                       /*file=*/nullptr,
-                                       /*isWeakRef=*/false);
   for (const Arg *arg : args.filtered(OPT_u)) {
     config->explicitUndefineds.push_back(symtab->addUndefined(
         arg->getValue(), /*file=*/nullptr, /*isWeakRef=*/false));
   }
 
   for (const Arg *arg : args.filtered(OPT_U))
     symtab->addDynamicLookup(arg->getValue());
 
#endif
   if (const Arg *arg =
           args.getLastArg(OPT_flat_namespace, OPT_twolevel_namespace))
     config->namespaceKind = arg->getOption().getID() == OPT_twolevel_namespace
                                 ? NamespaceKind::twolevel
                                 : NamespaceKind::flat;
 
   config->undefinedSymbolTreatment = getUndefinedSymbolTreatment(args);
 
+  if (config->outputType == MH_EXECUTE)
+    config->entry = symtab->addUndefined(args.getLastArgValue(OPT_e, "_main"),
+                                         /*file=*/nullptr,
+                                         /*isWeakRef=*/false);
+
   config->librarySearchPaths =
       getLibrarySearchPaths(args, config->systemLibraryRoots);
   config->frameworkSearchPaths =
       getFrameworkSearchPaths(args, config->systemLibraryRoots);
   if (const Arg *arg =
           args.getLastArg(OPT_search_paths_first, OPT_search_dylibs_first))
     config->searchDylibsFirst =
         arg->getOption().getID() == OPT_search_dylibs_first;

lld/MachO/Writer.cpp

if (auto *dysym = dyn_cast<DylibSymbol>(sym)) {
     if (defined->isExternalWeakDef()) {
       if (in.stubs->addEntry(sym)) {
         in.rebase->addEntry(in.lazyPointers->isec,
                             sym->stubsIndex * target->wordSize);
         in.weakBinding->addEntry(sym, in.lazyPointers->isec,
                                  sym->stubsIndex * target->wordSize);
       }
     }
+  } else {
+    assert(false && "invalid symbol type for branch");
   }
 }
 
 // Can a symbol's address can only be resolved at runtime?
 static bool needsBinding(const Symbol *sym) {
   if (isa<DylibSymbol>(sym))
     return true;
   if (const auto *defined = dyn_cast<Defined>(sym))
void Writer::writeOutputFile() {
   writeUuid();
   writeCodeSignature();
 
   if (auto e = buffer->commit())
     error("failed to write to the output file: " + toString(std::move(e)));
 }
 
 template <class LP> void Writer::run() {
+  if (config->entry)
     prepareBranchTarget(config->entry);
   scanRelocations();
   if (in.stubHelper->isNeeded())
     in.stubHelper->setup();
   scanSymbols();
   createOutputSections<LP>();
   // No more sections nor segments are created beyond this point.
   sortSegmentsAndSections();
   createLoadCommands<LP>();

lld/test/MachO/bundle-loader.s

 # REQUIRES: x86
 
 # RUN: rm -rf %t; split-file %s %t
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/2.s -o %t/2.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/3.s -o %t/3.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/main.s -o %t/main.o
 
-# RUN: %lld  -lSystem -dylib -install_name %t/my_lib.dylib -o %t/mylib.dylib %t/2.o
-# RUN: %lld %t/2.o %t/main.o -o %t/main
+# RUN: %lld -lSystem -dylib -install_name %t/my_lib.dylib -o %t/mylib.dylib %t/2.o
+# RUN: %lld -lSystem %t/2.o %t/main.o -o %t/main
 # RUN: %lld -lSystem -bundle -bundle_loader %t/main -o %t/bundle.bundle %t/3.o %t/mylib.dylib
-# Check bundle.bundle to ensure the `my_func` symbol is from executable
-# RUN: llvm-nm -m %t/bundle.bundle |  FileCheck %s --check-prefix BUNDLE
-# BUNDLE: (undefined) external _main (from executable)
+## Check bundle.bundle to ensure the `my_func` symbol is from executable
+# RUN: llvm-nm -m %t/bundle.bundle | FileCheck %s --check-prefix BUNDLE
 # BUNDLE: (undefined) external my_func (from executable)
 # RUN: llvm-objdump  --macho --lazy-bind %t/bundle.bundle | FileCheck %s --check-prefix BUNDLE-OBJ
 # BUNDLE-OBJ: segment  section             address            dylib                 symbol
 # BUNDLE-OBJ: __DATA   __la_symbol_ptr     0x{{[0-9a-f]*}}    main-executable       my_fun
 
-
 # RUN: %lld -lSystem -bundle -bundle_loader %t/main -o %t/bundle2.bundle %t/3.o %t/2.o
-# Check bundle2.bundle to ensure that _main is still from executable
-# but my_func is not.
+## Check bundle.bundle to ensure the `my_func` symbol is not from executable
 # RUN: llvm-nm -m %t/bundle2.bundle | FileCheck %s --check-prefix BUNDLE2
-# BUNDLE2: (undefined) external _main (from executable)
 # BUNDLE2: (__TEXT,__text) external my_func
 
 # Test that bundle_loader can only be used with MachO bundle output.
 # RUN: not %lld -lSystem -bundle_loader %t/main -o %t/bundle3.bundle 2>&1 | FileCheck %s --check-prefix ERROR
 # ERROR: -bundle_loader can only be used with MachO bundle output
 
 #--- 2.s
 # my_lib: This contains the exported function

lld/test/MachO/entry-symbol.s

 # REQUIRES: x86
 # RUN: rm -rf %t; split-file %s %t
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/not-main.s -o %t/not-main.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/libfoo.s -o %t/libfoo.o
 # RUN: %lld -lSystem -dylib %t/libfoo.o -o %t/libfoo.dylib
 
-# RUN: %lld -o %t/not-main %t/not-main.o -e _not_main
+# RUN: %lld -lSystem -o %t/not-main %t/not-main.o -e _not_main
 # RUN: llvm-objdump --macho --all-headers --syms %t/not-main | FileCheck %s
+
 # CHECK-LABEL: SYMBOL TABLE
-# CHECK-NEXT: {{0*}}[[#%x, ENTRY_ADDR:]] {{.*}} __TEXT,__text _not_main
+# CHECK:       {{0*}}[[#%x, ENTRY_ADDR:]] {{.*}} __TEXT,__text _not_main
+
 # CHECK:      sectname __text
 # CHECK-NEXT: segname __TEXT
 ## Note: the following checks assume that the entry symbol is right at the
 ## beginning of __text.
 # CHECK-NEXT: addr 0x{{0*}}[[#ENTRY_ADDR]]
 # CHECK-NEXT: size
 # CHECK-NEXT: offset [[#ENTRYOFF:]]
 # CHECK:      cmd  LC_MAIN

 # WEAK-DYSYM-NEXT:  entryoff [[#%u, DYSYM_ENTRY_ADDR - 0x100000000]]
 # WEAK-DYSYM-LABEL: Bind table:
 # WEAK-DYSYM-NEXT:  segment  section          address  type     addend  dylib      symbol
 # WEAK-DYSYM:       __DATA   __la_symbol_ptr  {{.*}}   pointer       0  libfoo _weak_dysym_main
 # WEAK-DYSYM-LABEL: Weak bind table:
 # WEAK-DYSYM-NEXT:  segment  section          address  type     addend  symbol
 # WEAK-DYSYM-NEXT:  __DATA   __la_symbol_ptr  {{.*}}   pointer       0  _weak_dysym_main
 
+# RUN: %lld -dylib -lSystem -o %t/dysym-main.dylib %t/not-main.o %t/libfoo.dylib -e _dysym_main
+# RUN: llvm-objdump --macho --indirect-symbols --lazy-bind %t/dysym-main.dylib | FileCheck %s --check-prefix=DYLIB-NO-MAIN
+# DYLIB-NO-MAIN-NOT: _dysym_main
+
 # RUN: not %lld -o /dev/null %t/not-main.o -e _missing 2>&1 | FileCheck %s --check-prefix=UNDEFINED
 # UNDEFINED: error: undefined symbol: _missing
 # RUN: not %lld -o /dev/null %t/not-main.o 2>&1 | FileCheck %s --check-prefix=DEFAULT-ENTRY
 # DEFAULT-ENTRY: error: undefined symbol: _main
 
 #--- libfoo.s
 .text
 .global _dysym_main, _weak_dysym_main