[lld-macho] Add support for -alias

[keith]

Summary

This creates a symbol alias similar to --defsym in the elf linker. This
is used by swiftpm for all executables, so it's useful to support. This
doesn't implement -alias_list but that could be done pretty easily as
needed.

[keith]

Switch to vector

[int3]

lld/MachO/Driver.cpp

1566

const auto &

1569

why not just pair.second

lld/test/MachO/aliases.s

27–28

would be nice to check that the addresses are the same too

[keith]

Add addresses to tests

[int3]

Thanks!

lld/MachO/Driver.cpp

1566

I think you did the next two lines but forgot this one?

lld/test/MachO/aliases.s

17

nit: would be nice to align the 2nd column

[keith]

Formatting

[oontvoo]

lld/MachO/Driver.cpp

1569–1573

i wonder if it's worth adding a Symtab::copy(<src>, <target>) rather than listing all the symbol's internals here. (reason being that occasionally we do add a new field, which means going to hunt down all these instances and update them - kind of bug-prone)

lld/test/MachO/aliases.s

8

nit: this shouldn't be needed (ie., the tests should be in the OPT framework, not LLD-macho since it's not implementing argument parsing code)

[keith]

Move alias logic into SymbolTable.cpp

lld/MachO/Driver.cpp

1569–1573

Yea good idea, I moved it. I didn't see any other similar logic today so I made it specific to this use case, but it still seems nicer to live with the other symtab logic. lmk what you think!

[oontvoo]

LG - thanks!

[thakis]

Is it time to do the 2nd FIXME in MarkLive.cpp now?

// FIXME: When we implement these flags, make symbols from them GC
// roots:
// * -reexported_symbol(s_list)
// * -alias(-list)
// * -init

[keith]

Ah thanks, submitted https://reviews.llvm.org/D135082. I also ran that test against ld64 and it passed, otherwise I didn't look at the ld64 behavior

lld/MachO/Config.h

struct Configuration {
   SectionRenameMap sectionRenameMap;
   SegmentRenameMap segmentRenameMap;
 
   bool hasExplicitExports = false;
   SymbolPatterns exportedSymbols;
   SymbolPatterns unexportedSymbols;
   SymbolPatterns whyLive;
 
+  std::vector<std::pair<llvm::StringRef, llvm::StringRef>> aliasedSymbols;
+
   SymtabPresence localSymbolsPresence = SymtabPresence::All;
   SymbolPatterns localSymbolPatterns;
 
   bool zeroModTime = false;
 
   llvm::StringRef osoPrefix;
 
   llvm::MachO::Architecture arch() const { return platformInfo.target.Arch; }

lld/MachO/Driver.cpp

config->dedupLiterals =
       config->icfLevel != ICFLevel::none;
   config->warnDylibInstallName = args.hasFlag(
       OPT_warn_dylib_install_name, OPT_no_warn_dylib_install_name, false);
   config->ignoreOptimizationHints = args.hasArg(OPT_ignore_optimization_hints);
   config->callGraphProfileSort = args.hasFlag(
       OPT_call_graph_profile_sort, OPT_no_call_graph_profile_sort, true);
   config->printSymbolOrder = args.getLastArgValue(OPT_print_symbol_order);
 
+  for (const Arg *arg : args.filtered(OPT_alias)) {
+    config->aliasedSymbols.push_back(
+        std::make_pair(arg->getValue(0), arg->getValue(1)));
+  }
+
   // FIXME: Add a commandline flag for this too.
   config->zeroModTime = getenv("ZERO_AR_DATE");
 
   std::array<PlatformType, 3> encryptablePlatforms{
       PLATFORM_IOS, PLATFORM_WATCHOS, PLATFORM_TVOS};
   config->emitEncryptionInfo =
       args.hasFlag(OPT_encryptable, OPT_no_encryption,
                    is_contained(encryptablePlatforms, config->platform()));
if (config->timeTraceEnabled)
     referenceStubBinder();
 
     // FIXME: should terminate the link early based on errors encountered so
     // far?
 
     createSyntheticSections();
     createSyntheticSymbols();
 
+    for (const auto &pair : config->aliasedSymbols) {
+      if (const auto &sym = symtab->find(pair.first)) {
+        if (const auto &defined = dyn_cast<Defined>(sym)) {
+          symtab->aliasDefined(defined, pair.second);
+          continue;
+        }
+      }
+
+      warn("undefined base symbol '" + pair.first + "' for alias '" +
+           pair.second + "'\n");
+    }
+
     if (config->hasExplicitExports) {
       parallelForEach(symtab->getSymbols(), [](Symbol *sym) {
         if (auto *defined = dyn_cast<Defined>(sym)) {
           StringRef symbolName = defined->getName();
           if (config->exportedSymbols.match(symbolName)) {
             if (defined->privateExtern) {
               if (defined->weakDefCanBeHidden) {
                 // weak_def_can_be_hidden symbols behave similarly to

lld/MachO/Options.td

 def reexported_symbols_list : Separate<["-"], "reexported_symbols_list">,
     MetaVarName<"<file>">,
     HelpText<"Symbols from dependent dylibs specified in <file> are reexported by this dylib">,
     Flags<[HelpHidden]>,
     Group<grp_resolve>;
 def alias : MultiArg<["-"], "alias", 2>,
     MetaVarName<"<symbol_name> <alternate_name>">,
     HelpText<"Create a symbol alias with default global visibility">,
-    Flags<[HelpHidden]>,
     Group<grp_resolve>;
 def alias_list : Separate<["-"], "alias_list">,
     MetaVarName<"<file>">,
     HelpText<"Create symbol aliases specified in <file>">,
     Flags<[HelpHidden]>,
     Group<grp_resolve>;
 def flat_namespace : Flag<["-"], "flat_namespace">,
     HelpText<"Resolve symbols from all dylibs, both direct and transitive. Do not record source libraries: dyld must re-search at runtime and use the first definition found">,

lld/MachO/SymbolTable.h

 class SymbolTable {
 public:
   Defined *addDefined(StringRef name, InputFile *, InputSection *,
                       uint64_t value, uint64_t size, bool isWeakDef,
                       bool isPrivateExtern, bool isThumb,
                       bool isReferencedDynamically, bool noDeadStrip,
                       bool isWeakDefCanBeHidden);
 
+  Defined *aliasDefined(Defined *src, StringRef target);
+
   Symbol *addUndefined(StringRef name, InputFile *, bool isWeakRef);
 
   Symbol *addCommon(StringRef name, InputFile *, uint64_t size, uint32_t align,
                     bool isPrivateExtern);
 
   Symbol *addDylib(StringRef name, DylibFile *file, bool isWeakDef, bool isTlv);
   Symbol *addDynamicLookup(StringRef name);
 

lld/MachO/SymbolTable.cpp

Defined *SymbolTable::addDefined(StringRef name, InputFile *file,
   Defined *defined = replaceSymbol<Defined>(
       s, name, file, isec, value, size, isWeakDef, /*isExternal=*/true,
       isPrivateExtern, /*includeInSymtab=*/true, isThumb,
       isReferencedDynamically, noDeadStrip, overridesWeakDef,
       isWeakDefCanBeHidden, interposable);
   return defined;
 }
 
+Defined *SymbolTable::aliasDefined(Defined *src, StringRef target) {
+  return addDefined(target, src->getFile(), src->isec, src->value, src->size,
+                    src->isWeakDef(), src->privateExtern, src->thumb,
+                    src->referencedDynamically, src->noDeadStrip,
+                    src->weakDefCanBeHidden);
+}
+
 Symbol *SymbolTable::addUndefined(StringRef name, InputFile *file,
                                   bool isWeakRef) {
   Symbol *s;
   bool wasInserted;
   std::tie(s, wasInserted) = insert(name, file);
 
   RefState refState = isWeakRef ? RefState::Weak : RefState::Strong;
 

lld/test/MachO/aliases.s

+# REQUIRES: x86
+# RUN: rm -rf %t; split-file %s %t
+
+# 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/main.o %t/main.s
+
+# RUN: %lld -alias _foo _bar -u _bar -exported_symbol _bar %t/main.o %t/foo.o -o %t/bar.o
+# RUN: llvm-nm %t/bar.o | FileCheck %s --check-prefix=BAR
+
+# BAR: [[#%x,FOO_ADDR:]] T _bar
+# BAR: [[#FOO_ADDR]]     t _foo
+
+# RUN: not %lld -alias _missing _bar -alias _missing2 _baz %t/main.o -o %t/missing.o %s 2>&1 | FileCheck %s --check-prefix=MISSING
+
+# MISSING-DAG: undefined base symbol '_missing' for alias '_bar'
+# MISSING-DAG: undefined base symbol '_missing2' for alias '_baz'
+
+# RUN: %lld -alias _foo _main %t/foo.o -o %t/main_rename.o
+# RUN: llvm-nm %t/main_rename.o | FileCheck %s --check-prefix=MAIN
+
+# MAIN: [[#%x,FOO_ADDR:]] T _foo
+# MAIN: [[#FOO_ADDR]]     T _main
+
+# RUN: %lld -alias _foo _bar -alias _main _fake_main %t/main.o %t/foo.o -o %t/multiple.o
+# RUN: llvm-nm %t/multiple.o | FileCheck %s --check-prefix=MULTIPLE
+
+# MULTIPLE: [[#%x,FOO_ADDR:]]  T _bar
+# MULTIPLE: [[#%x,MAIN_ADDR:]] T _fake_main
+# MULTIPLE: [[#FOO_ADDR]]      T _foo
+# MULTIPLE: [[#MAIN_ADDR]]     T _main
+
+#--- foo.s
+.globl _foo
+_foo:
+  ret
+
+#--- main.s
+.globl _main
+_main:
+  ret