[lld/mac] Add support for $ld$previous symbols with explicit symbol name

[thakis]

Summary

A symbol $ld$previous$/Another$1.2.3$1$3.0$14.0$_xxx$ means
"pretend symbol _xxx is in dylib /Another with version 1.2.3
if the deployment target is between 3.0 and 14.0 and we're
targeting platform 1 (ie macOS)".

This means dylibs can now inject synthetic dylibs into the link, so
DylibFile needs to grow a 3rd constructor.

The only other interesting thing is that such an injected dylib
counts as a use of the original dylib. This patch gets this mostly
right (if _only_ $ld$previous symbols are used from a dylib,
we don't add a dep on the dylib itself, matching ld64), but one case
where we don't match ld64 yet is that ld64 even omits the original
dylib when linking it with -needed-l. Lld currently still adds a load
command for the original dylib in that case. (That's for a future
patch.)

Fixes #56074.

[thakis]

lld/MachO/InputFiles.h

240

Moving this to an initializer is mostly unrelated, just didn't want to duplicate it in the 3rd ctor. I could land this change as a tiny standalone commit if you want.

lld/MachO/Writer.cpp

797–800

The

std::vector<DylibFile *> dylibFiles;
  for (InputFile *file : inputFiles) {
    if (auto *dylibFile = dyn_cast<DylibFile>(file))
      dylibFiles.push_back(dylibFile);
  }

bit and dedenting this for loop here could also land in its own commit, to make this diff smaller, if you want.

[thakis]

address bot feedback

lld/MachO/InputFiles.h

240

…nevermind, the enum is only predeclared in this header. Undid this part.

[int3]

just some questions about the comments but lgtm

lld/MachO/InputFiles.cpp

2111

what do you mean by "works" here? what's the failure case that we have avoided?

lld/MachO/InputFiles.h

245–249

can we make this private so it's clear that we should be calling isExplicitlyLinked()? Looks like it's only being written to from loadDylib but we could make that a friend function if you find a setter too ugly

246

nit: would prefer if all the methods were located together (so at line 227 above) instead of interleaved with fields

lld/test/MachO/special-symbol-ld-previous.s

33–34

when a symbol is part of $previous$ if and only if that symbol is referenced.

kind of confused by this. Did you mean "only when the named symbol is referenced"?

[thakis]

address comments, soup up test slightly

lld/MachO/InputFiles.cpp

2111

The tbd file usually contains the $ld$previous symbol for an old version, and then the symbol itself later, for newer deployment targets, like so:

 symbols:         [
   '$ld$previous$/Another$$1$3.0$14.0$_zzz$',
   _zzz,
]

If they weren't sorted, then _zzz would be added with the current dylib first (and since it's added first, it would win over the $ld$previous symbol.

Suggestions on how to reword the comment?

lld/test/MachO/special-symbol-ld-previous.s

33–34

Yes, that's what I mean. Reworded it a bit.

[thakis]

Note to future self: To test things I had foo.tbd containing:

--- !tapi-tbd-v3
archs:           [ x86_64 ]
uuids:           [ 'x86_64: 19311019-01AB-342E-812B-73A74271A715' ]
platform:        macosx
install-name:    '/Old'
current-version: 6
compatibility-version: 1.1.1
exports:
  - archs:           [ x86_64 ]
    symbols:         [
      '$ld$previous$/Another$$1$3.0$14.0$_zzz$',
      '$ld$previous$/New$1.2.3$1$3.0$14.0$_yyy$',
      _xxx,
      _yyy,
      _zzz,
   ]
...

and test.s containing

.subsections_via_symbols

.globl _main
_main:
    call _xxx
    call _yyy
    call _zzz
    ret

and I'd uncomment the various call instructions, and run out/gn/bin/clang test.s -isysroot $(xcrun -show-sdk-path) --target=x86_64-apple-macos foo.tbd followed by otool -L a.out, and then add -fuse-ld=lld to the clang command, and replace foo.tbd with -Wl,-needed_library,foo.tbd, etc.

[thakis]

(I'll land the current version addressing the first round of feedback for now, given it's approved. I'll address potential follow-on feedback in a follow-on change.)

[int3]

lld/MachO/InputFiles.cpp

2111

How about

The tbd file usually contains the $ld$previous symbol for an old version, and then the symbol itself later, for newer deployment targets, like so:
<example>
Since the symbols are sorted, adding them to the symtab in the given order means the $ld$previous version of _zzz will prevail, as desired.

lld/test/MachO/special-symbol-ld-previous.s

33–34

I think it's confusing because it's a bit of a run-on sentence. How about

## Case 4: special symbol $ld$previous affects the install name / compatibility version if and only if:
##   * the specified version 11.0.0 is within the affected range [3.0, 14.0), and
##   * the symbol name after $previous$ points to a referenced symbol

[thakis]

Thanks, did both in 2681c9e0654b848e8983c1087840717f9ad486c8.

Should we try merging the original change to the 15.0 branch?

[thakis]

(This has since been merged to 15.0, see #56074.)

lld/MachO/DriverUtils.cpp

 static DenseMap<CachedHashStringRef, DylibFile *> loadedDylibs;
 
 DylibFile *macho::loadDylib(MemoryBufferRef mbref, DylibFile *umbrella,
                             bool isBundleLoader, bool explicitlyLinked) {
   CachedHashStringRef path(mbref.getBufferIdentifier());
   DylibFile *&file = loadedDylibs[path];
   if (file) {
     if (explicitlyLinked)
-      file->explicitlyLinked = explicitlyLinked;
+      file->setExplicitlyLinked();
     return file;
   }
 
   DylibFile *newFile;
   file_magic magic = identify_magic(mbref.getBuffer());
   if (magic == file_magic::tapi_file) {
     Expected<std::unique_ptr<InterfaceFile>> result = TextAPIReader::get(mbref);
     if (!result) {

lld/MachO/InputFiles.h

public:
   // the root dylib to ensure symbols in the child library are correctly bound
   // to the root. On the other hand, if a dylib is being directly loaded
   // (through an -lfoo flag), then `umbrella` should be a nullptr.
   explicit DylibFile(MemoryBufferRef mb, DylibFile *umbrella,
                      bool isBundleLoader, bool explicitlyLinked);
   explicit DylibFile(const llvm::MachO::InterfaceFile &interface,
                      DylibFile *umbrella, bool isBundleLoader,
                      bool explicitlyLinked);
+  explicit DylibFile(DylibFile *umbrella);
 
   void parseLoadCommands(MemoryBufferRef mb);
   void parseReexports(const llvm::MachO::InterfaceFile &interface);
   bool isReferenced() const { return numReferencedSymbols > 0; }
+  bool isExplicitlyLinked() const;
+  void setExplicitlyLinked() { explicitlyLinked = true; }
 
   static bool classof(const InputFile *f) { return f->kind() == DylibKind; }
 
   StringRef installName;
   DylibFile *exportingFile = nullptr;
   DylibFile *umbrella;
   SmallVector<StringRef, 2> rpaths;
   uint32_t compatibilityVersion = 0;
   uint32_t currentVersion = 0;
   int64_t ordinal = 0; // Ordinal numbering starts from 1, so 0 is a sentinel
   unsigned numReferencedSymbols = 0;
   RefState refState;
   bool reexport = false;
   bool forceNeeded = false;
   bool forceWeakImport = false;
   bool deadStrippable = false;
-  bool explicitlyLinked = false;
+
+private:
+  bool explicitlyLinked = false; // Access via isExplicitlyLinked().
+
+public:
   // An executable can be used as a bundle loader that will load the output
   // file being linked, and that contains symbols referenced, but not
   // implemented in the bundle. When used like this, it is very similar
   // to a dylib, so we've used the same class to represent it.
   bool isBundleLoader;
 
+  // Synthetic Dylib objects created by $ld$previous symbols in this dylib.
+  // Usually empty. These synthetic dylibs won't have synthetic dylibs
+  // themselves.
+  SmallVector<DylibFile *, 2> extraDylibs;
+
 private:
+  DylibFile *getSyntheticDylib(StringRef installName, uint32_t currentVersion,
+                               uint32_t compatVersion);
+
   bool handleLDSymbol(StringRef originalName);
   void handleLDPreviousSymbol(StringRef name, StringRef originalName);
   void handleLDInstallNameSymbol(StringRef name, StringRef originalName);
   void handleLDHideSymbol(StringRef name, StringRef originalName);
   void checkAppExtensionSafety(bool dylibIsAppExtensionSafe) const;
   void parseExportedSymbols(uint32_t offset, uint32_t size);
 
   llvm::DenseSet<llvm::CachedHashStringRef> hiddenSymbols;

lld/MachO/InputFiles.cpp

case SymbolKind::ObjectiveCClassEHType:
       break;
     case SymbolKind::ObjectiveCInstanceVariable:
       addSymbol(objc::ivar + symbol->getName());
       break;
     }
   }
 }
 
+DylibFile::DylibFile(DylibFile *umbrella)
+    : InputFile(DylibKind, MemoryBufferRef{}), refState(RefState::Unreferenced),
+      explicitlyLinked(false), isBundleLoader(false) {
+  if (umbrella == nullptr)
+    umbrella = this;
+  this->umbrella = umbrella;
+}
+
 void DylibFile::parseReexports(const InterfaceFile &interface) {
   const InterfaceFile *topLevel =
       interface.getParent() == nullptr ? &interface : interface.getParent();
   for (const InterfaceFileRef &intfRef : interface.reexportedLibraries()) {
     InterfaceFile::const_target_range targets = intfRef.targets();
     if (is_contained(skipPlatformChecks, intfRef.getInstallName()) ||
         isTargetPlatformArchCompatible(targets, config->platformInfo.target))
       loadReexport(intfRef.getInstallName(), exportingFile, topLevel);
   }
 }
 
+bool DylibFile::isExplicitlyLinked() const {
+  if (!explicitlyLinked)
+    return false;
+
+  // If this dylib was explicitly linked, but at least one of the symbols
+  // of the synthetic dylibs it created via $ld$previous symbols is
+  // referenced, then that synthetic dylib fulfils the explicit linkedness
+  // and we can deadstrip this dylib if it's unreferenced.
+  for (const auto *dylib : extraDylibs)
+    if (dylib->isReferenced())
+      return false;
+
+  return true;
+}
+
+DylibFile *DylibFile::getSyntheticDylib(StringRef installName,
+                                        uint32_t currentVersion,
+                                        uint32_t compatVersion) {
+  for (DylibFile *dylib : extraDylibs)
+    if (dylib->installName == installName) {
+      // FIXME: Check what to do if different $ld$previous symbols
+      // request the same dylib, but with different versions.
+      return dylib;
+    }
+
+  auto *dylib = make<DylibFile>(umbrella == this ? nullptr : umbrella);
+  dylib->installName = saver().save(installName);
+  dylib->currentVersion = currentVersion;
+  dylib->compatibilityVersion = compatVersion;
+  extraDylibs.push_back(dylib);
+  return dylib;
+}
+
 // $ld$ symbols modify the properties/behavior of the library (e.g. its install
 // name, compatibility version or hide/add symbols) for specific target
 // versions.
 bool DylibFile::handleLDSymbol(StringRef originalName) {
   if (!originalName.startswith("$ld$"))
     return false;
 
   StringRef action;
void DylibFile::handleLDPreviousSymbol(StringRef name, StringRef originalName) {
   StringRef symbolName;
   StringRef rest;
 
   std::tie(installName, name) = name.split('$');
   std::tie(compatVersion, name) = name.split('$');
   std::tie(platformStr, name) = name.split('$');
   std::tie(startVersion, name) = name.split('$');
   std::tie(endVersion, name) = name.split('$');
-  std::tie(symbolName, rest) = name.split('$');
-  // TODO: ld64 contains some logic for non-empty symbolName as well.
-  if (!symbolName.empty())
-    return;
+  std::tie(symbolName, rest) = name.rsplit('$');
+
+  // FIXME: Does this do the right thing for zippered files?
   unsigned platform;
   if (platformStr.getAsInteger(10, platform) ||
       platform != static_cast<unsigned>(config->platform()))
     return;
 
   VersionTuple start;
   if (start.tryParse(startVersion)) {
     warn("failed to parse start version, symbol '" + originalName +
          "' ignored");
     return;
   }
   VersionTuple end;
   if (end.tryParse(endVersion)) {
     warn("failed to parse end version, symbol '" + originalName + "' ignored");
     return;
   }
   if (config->platformInfo.minimum < start ||
       config->platformInfo.minimum >= end)
     return;
 
-  this->installName = saver().save(installName);
-
+  // Initialized to compatibilityVersion for the symbolName branch below.
+  uint32_t newCompatibilityVersion = compatibilityVersion;
+  uint32_t newCurrentVersionForSymbol = currentVersion;
   if (!compatVersion.empty()) {
     VersionTuple cVersion;
     if (cVersion.tryParse(compatVersion)) {
       warn("failed to parse compatibility version, symbol '" + originalName +
            "' ignored");
       return;
     }
-    compatibilityVersion = encodeVersion(cVersion);
+    newCompatibilityVersion = encodeVersion(cVersion);
+    newCurrentVersionForSymbol = newCompatibilityVersion;
   }
+
+  if (!symbolName.empty()) {
+    // A $ld$previous$ symbol with symbol name adds a symbol with that name to
+    // a dylib with given name and version.
+    auto *dylib = getSyntheticDylib(installName, newCurrentVersionForSymbol,
+                                    newCompatibilityVersion);
+
+    // Just adding the symbol to the symtab works because dylibs contain their
+    // symbols in alphabetical order, guaranteeing $ld$ symbols to precede
+    // normal symbols.
+    dylib->symbols.push_back(symtab->addDylib(
+        saver().save(symbolName), dylib, /*isWeakDef=*/false, /*isTlv=*/false));
+    return;
+  }
+
+  // A $ld$previous$ symbol without symbol name modifies the dylib it's in.
+  this->installName = saver().save(installName);
+  this->compatibilityVersion = newCompatibilityVersion;
 }
 
 void DylibFile::handleLDInstallNameSymbol(StringRef name,
                                           StringRef originalName) {
   // originalName: $ld$ install_name $ os<version> $ install_name
   StringRef condition, installName;
   std::tie(condition, installName) = name.split('$');
   VersionTuple version;

lld/MachO/Writer.cpp

if (config->secondaryPlatformInfo) {
     in.header->addLoadCommand(
         make<LCBuildVersion>(*config->secondaryPlatformInfo));
   }
 
   // This is down here to match ld64's load command order.
   if (config->outputType == MH_EXECUTE)
     in.header->addLoadCommand(make<LCMain>());
 
+  // See ld64's OutputFile::buildDylibOrdinalMapping for the corresponding
+  // library ordinal computation code in ld64.
   int64_t dylibOrdinal = 1;
   DenseMap<StringRef, int64_t> ordinalForInstallName;
+
+  std::vector<DylibFile *> dylibFiles;
   for (InputFile *file : inputFiles) {
-    if (auto *dylibFile = dyn_cast<DylibFile>(file)) {
-      if (dylibFile->isBundleLoader) {
-        dylibFile->ordinal = BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE;
-        // Shortcut since bundle-loader does not re-export the symbols.
+    if (auto *dylibFile = dyn_cast<DylibFile>(file))
+      dylibFiles.push_back(dylibFile);
+  }
+  for (size_t i = 0; i < dylibFiles.size(); ++i)
+    dylibFiles.insert(dylibFiles.end(), dylibFiles[i]->extraDylibs.begin(),
+                      dylibFiles[i]->extraDylibs.end());
+
+  for (DylibFile *dylibFile : dylibFiles) {
 
-        dylibFile->reexport = false;
-        continue;
-      }
 
-      // Don't emit load commands for a dylib that is not referenced if:
-      // - it was added implicitly (via a reexport, an LC_LOAD_DYLINKER --
-      //   if it's on the linker command line, it's explicit)
-      // - or it's marked MH_DEAD_STRIPPABLE_DYLIB
-      // - or the flag -dead_strip_dylibs is used
-      // FIXME: `isReferenced()` is currently computed before dead code
-      // stripping, so references from dead code keep a dylib alive. This
-      // matches ld64, but it's something we should do better.
-      if (!dylibFile->isReferenced() && !dylibFile->forceNeeded &&
-          (!dylibFile->explicitlyLinked || dylibFile->deadStrippable ||
-           config->deadStripDylibs))
-        continue;
+        (!dylibFile->isExplicitlyLinked() || dylibFile->deadStrippable ||
 
-      // Several DylibFiles can have the same installName. Only emit a single
-      // load command for that installName and give all these DylibFiles the
-      // same ordinal.
-      // This can happen in several cases:
-      // - a new framework could change its installName to an older
-      //   framework name via an $ld$ symbol depending on platform_version
-      // - symlinks (for example, libpthread.tbd is a symlink to libSystem.tbd;
-      //   Foo.framework/Foo.tbd is usually a symlink to
-      //   Foo.framework/Versions/Current/Foo.tbd, where
-      //   Foo.framework/Versions/Current is usually a symlink to
-      //   Foo.framework/Versions/A)
-      // - a framework can be linked both explicitly on the linker
-      //   command line and implicitly as a reexport from a different
-      //   framework. The re-export will usually point to the tbd file
-      //   in Foo.framework/Versions/A/Foo.tbd, while the explicit link will
-      //   usually find Foo.framework/Foo.tbd. These are usually symlinks,
-      //   but in a --reproduce archive they will be identical but distinct
-      //   files.
-      // In the first case, *semantically distinct* DylibFiles will have the
-      // same installName.
-      int64_t &ordinal = ordinalForInstallName[dylibFile->installName];
-      if (ordinal) {
-        dylibFile->ordinal = ordinal;
-        continue;
-      }
 
-      ordinal = dylibFile->ordinal = dylibOrdinal++;
-      LoadCommandType lcType =
-          dylibFile->forceWeakImport || dylibFile->refState == RefState::Weak
-              ? LC_LOAD_WEAK_DYLIB
-              : LC_LOAD_DYLIB;
-      in.header->addLoadCommand(make<LCDylib>(lcType, dylibFile->installName,
-                                              dylibFile->compatibilityVersion,
-                                              dylibFile->currentVersion));
 
-      if (dylibFile->reexport)
-        in.header->addLoadCommand(
-            make<LCDylib>(LC_REEXPORT_DYLIB, dylibFile->installName));
-    }
-  }
 
   if (functionStartsSection)
     in.header->addLoadCommand(make<LCFunctionStarts>(functionStartsSection));
   if (dataInCodeSection)
     in.header->addLoadCommand(make<LCDataInCode>(dataInCodeSection));
   if (codeSignatureSection)
     in.header->addLoadCommand(make<LCCodeSignature>(codeSignatureSection));
 

lld/test/MachO/special-symbol-ld-previous.s

 # REQUIRES: x86
 
 # RUN: rm -rf %t; split-file --no-leading-lines %s %t
 
-# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/foo.s -o %t/foo.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/ref_xxx.s -o %t/ref_xxx.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/ref_ySyy.s -o %t/ref_ySyy.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/ref_zzz.s -o %t/ref_zzz.o
 
 ## Case 1: special symbol $ld$previous affects the install name / compatibility version
 ## since the specified version 11.0.0 is within the affected range [3.0, 14.0).
 
-# RUN: %lld -o %t/libfoo1.dylib %t/libLDPreviousInstallName.tbd %t/foo.o -dylib -platform_version macos 11.0.0 11.0.0
+# RUN: %lld -o %t/libfoo1.dylib %t/libLDPreviousInstallName.tbd %t/ref_xxx.o -dylib -platform_version macos 11.0.0 11.0.0
 # RUN: llvm-objdump --macho --dylibs-used %t/libfoo1.dylib | FileCheck --check-prefix=CASE1 %s
-# CASE1: /New (compatibility version 1.2.3, current version 5.0.0)
+# CASE1: /Old (compatibility version 1.2.3, current version 5.0.0)
 
 ## Case 2: special symbol $ld$previous does not affect the install name / compatibility version
 ## since the specified version 2.0.0 is lower than the affected range [3.0, 14.0).
 
-# RUN: %lld -o %t/libfoo2.dylib %t/libLDPreviousInstallName.tbd %t/foo.o -dylib -platform_version macos 2.0.0 2.0.0
+# RUN: %lld -o %t/libfoo2.dylib %t/libLDPreviousInstallName.tbd %t/ref_xxx.o -dylib -platform_version macos 2.0.0 2.0.0
 # RUN: llvm-objdump --macho --dylibs-used %t/libfoo2.dylib | FileCheck --check-prefix=CASE2 %s
-# CASE2: /Old (compatibility version 1.1.1, current version 5.0.0)
+# CASE2: /New (compatibility version 1.1.1, current version 5.0.0)
 
 ## Case 3: special symbol $ld$previous does not affect the install name / compatibility version
 ## since the specified version 14.0.0 is higher than the affected range [3.0, 14.0).
 
-# RUN: %lld -o %t/libfoo3.dylib %t/libLDPreviousInstallName.tbd %t/foo.o -dylib -platform_version macos 2.0.0 2.0.0
+# RUN: %lld -o %t/libfoo3.dylib %t/libLDPreviousInstallName.tbd %t/ref_xxx.o -dylib -platform_version macos 2.0.0 2.0.0
 # RUN: llvm-objdump --macho --dylibs-used %t/libfoo3.dylib | FileCheck --check-prefix=CASE3 %s
-# CASE3: /Old (compatibility version 1.1.1, current version 5.0.0)
+# CASE3: /New (compatibility version 1.1.1, current version 5.0.0)
+
+## The remaining cases test handling when a symbol name is part of $ld$previous.
+
+## Case 4: special symbol $ld$previous affects the install name / compatibility version
+## when the specified version 11.0.0 is within the affected range [3.0, 14.0) when a symbol
+## is part of $previous$ if and only if that named symbol is referenced.
+## That is, for $ld$previous$/NewName$$3.0$14.0$_symNam$, if _symNam is
+## referenced, it refers to dylib /NewName if the deployment target is
+## in [3.0, 14.0).
+
+# RUN: %lld -o %t/libfoo4_yes.dylib %t/libLDPreviousInstallName-Symbol.tbd %t/ref_ySyy.o -dylib -platform_version macos 11.0.0 11.0.0
+# RUN: llvm-otool -L %t/libfoo4_yes.dylib | FileCheck --check-prefix=CASE4-YES --implicit-check-not=/New %s
+# CASE4-YES: /Old (compatibility version 1.2.3, current version 1.2.3)
+
+## $previous has no effect because deployment target is too new.
+# RUN: %lld -o %t/libfoo4_no.dylib %t/libLDPreviousInstallName-Symbol.tbd %t/ref_ySyy.o -dylib -platform_version macos 14.0.0 14.0.0
+# RUN: llvm-otool -L %t/libfoo4_no.dylib | FileCheck --check-prefix=CASE4-NO --implicit-check-not=/Old %s
+# CASE4-NO: /New (compatibility version 1.1.1, current version 5.0.0)
+
+## $previous has no effect because named symbol isn't referenced.
+# RUN: %lld -o %t/libfoo4_no.dylib %t/libLDPreviousInstallName-Symbol.tbd %t/ref_zzz.o -dylib -platform_version macos 11.0.0 11.0.0
+# RUN: llvm-otool -L %t/libfoo4_no.dylib | FileCheck --check-prefix=CASE4-NO %s
+
+## Case 5: Reference two symbols that add different $previous names each,
+## and one that references the "normal" dylib.
+## This should produce three different load commands.
+# RUN: %lld -o %t/libfoo5.dylib %t/libLDPreviousInstallName-Symbol.tbd %t/ref_xxx.o %t/ref_ySyy.o %t/ref_zzz.o -dylib -platform_version macos 11.0.0 11.0.0
+# RUN: llvm-otool -L %t/libfoo5.dylib | FileCheck --check-prefix=CASE5 %s
+# CASE5: /New (compatibility version 1.1.1, current version 5.0.0)
+# CASE5-DAG: /Another (compatibility version 1.1.1, current version 5.0.0)
+# CASE5-DAG: /Old (compatibility version 1.2.3, current version 1.2.3)
 
 ## Check that we emit a warning for an invalid start, end and compatibility versions.
 
-# RUN: %no-fatal-warnings-lld -o %t/libfoo1.dylib %t/libLDPreviousInvalid.tbd %t/foo.o -dylib \
+# RUN: %no-fatal-warnings-lld -o %t/libfoo1.dylib %t/libLDPreviousInvalid.tbd %t/ref_xxx.o -dylib \
 # RUN:  -platform_version macos 11.0.0 11.0.0 2>&1 | FileCheck --check-prefix=INVALID-VERSION %s
 
 # INVALID-VERSION-DAG: failed to parse start version, symbol '$ld$previous$/New$1.2.3$1$3.a$14.0$$' ignored
 # INVALID-VERSION-DAG: failed to parse end version, symbol '$ld$previous$/New$1.2.3$1$3.0$14.b$$' ignored
 # INVALID-VERSION-DAG: failed to parse compatibility version, symbol '$ld$previous$/New$1.2.c$1$3.0$14.0$$' ignored
 
-#--- foo.s
+#--- ref_xxx.s
 .long _xxx@GOTPCREL
 
+#--- ref_ySyy.s
+.long _y$yy@GOTPCREL
+
+#--- ref_zzz.s
+.long _zzz@GOTPCREL
+
 #--- libLDPreviousInstallName.tbd
 --- !tapi-tbd-v3
 archs:           [ x86_64 ]
 uuids:           [ 'x86_64: 19311019-01AB-342E-812B-73A74271A715' ]
 platform:        macosx
-install-name:    '/Old'
+install-name:    '/New'
+current-version: 5
+compatibility-version: 1.1.1
+exports:
+  - archs:           [ x86_64 ]
+    symbols:         [ '$ld$previous$/Old$1.2.3$1$3.0$14.0$$', _xxx ]
+...
+
+#--- libLDPreviousInstallName-Symbol.tbd
+--- !tapi-tbd-v3
+archs:           [ x86_64 ]
+uuids:           [ 'x86_64: 19311019-01AB-342E-812B-73A74271A715' ]
+platform:        macosx
+install-name:    '/New'
 current-version: 5
 compatibility-version: 1.1.1
 exports:
   - archs:           [ x86_64 ]
-    symbols:         [ '$ld$previous$/New$1.2.3$1$3.0$14.0$$', _xxx ]
+    symbols:         [
+      '$ld$previous$/Another$$1$3.0$14.0$_xxx$',
+      '$ld$previous$/Old$1.2.3$1$3.0$14.0$_y$yy$',
+      _xxx,
+      '_y$yy',
+      _zzz,
+    ]
 ...
 
 #--- libLDPreviousInvalid.tbd
 --- !tapi-tbd-v3
 archs:           [ x86_64 ]
 uuids:           [ 'x86_64: 19311019-01AB-342E-112B-73A74271A715' ]
 platform:        macosx
 install-name:    '/Old'