NOT FOR REVIEW: [lld/mac] incorrect patch for compat_version setting with $ld$..install_name

[thakis]

Summary

This doesn't match ld64

[thakis]

wrong approach, D103821 is better

lld/MachO/InputFiles.h

explicit DylibFile(const llvm::MachO::InterfaceFile &interface,
                      DylibFile *umbrella = nullptr,
                      bool isBundleLoader = false);
 
   void parseLoadCommands(MemoryBufferRef mb);
   void parseReexports(const llvm::MachO::InterfaceFile &interface);
 
   static bool classof(const InputFile *f) { return f->kind() == DylibKind; }
 
+  StringRef originalInstallName;
   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
   RefState refState;

lld/MachO/InputFiles.cpp

DylibFile::DylibFile(MemoryBufferRef mb, DylibFile *umbrella,
   auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
   auto *hdr = reinterpret_cast<const mach_header *>(mb.getBufferStart());
 
   // Initialize installName.
   if (const load_command *cmd = findCommand(hdr, LC_ID_DYLIB)) {
     auto *c = reinterpret_cast<const dylib_command *>(cmd);
     currentVersion = read32le(&c->dylib.current_version);
     compatibilityVersion = read32le(&c->dylib.compatibility_version);
-    installName =
+    installName = originalInstallName =
         reinterpret_cast<const char *>(cmd) + read32le(&c->dylib.name);
   } else if (!isBundleLoader) {
     // macho_executable and macho_bundle don't have LC_ID_DYLIB,
     // so it's OK.
     error("dylib " + toString(this) + " missing LC_ID_DYLIB load command");
     return;
   }
 
DylibFile::DylibFile(const InterfaceFile &interface, DylibFile *umbrella,
     : InputFile(DylibKind, interface), refState(RefState::Unreferenced),
       isBundleLoader(isBundleLoader) {
   // FIXME: Add test for the missing TBD code path.
 
   if (umbrella == nullptr)
     umbrella = this;
   this->umbrella = umbrella;
 
-  installName = saver.save(interface.getInstallName());
+  installName = originalInstallName= saver.save(interface.getInstallName());
   compatibilityVersion = interface.getCompatibilityVersion().rawValue();
   currentVersion = interface.getCurrentVersion().rawValue();
 
   if (config->printEachFile)
     message(toString(this));
 
   if (!is_contained(skipPlatformChecks, installName) &&
       !is_contained(interface.targets(), config->platformInfo.target)) {

lld/MachO/Writer.cpp

static const std::map<PlatformKind, llvm::VersionTuple> minVersion = {
       {PlatformKind::tvOS, llvm::VersionTuple(12, 0)},
       {PlatformKind::tvOSSimulator, llvm::VersionTuple(13, 0)},
       {PlatformKind::watchOS, llvm::VersionTuple(5, 0)},
       {PlatformKind::watchOSSimulator, llvm::VersionTuple(6, 0)}};
   auto it = minVersion.find(platformInfo.target.Platform);
   return it == minVersion.end() ? true : platformInfo.minimum >= it->second;
 }
 
+static void updateDylibVersions() {
+  // For dylibs that had their installName updated later, updates
+  // compatibilityVersion and currentVersion from the dylib that
+  // originally had that installName.
+  DenseMap<StringRef, DylibFile*> dylibForInstallName;
+  for (InputFile *file : inputFiles)
+    if (auto *dylibFile = dyn_cast<DylibFile>(file))
+      dylibForInstallName[dylibFile->originalInstallName] = dylibFile;
+  for (InputFile *file : inputFiles) {
+    if (auto *dylibFile = dyn_cast<DylibFile>(file)) {
+      auto it = dylibForInstallName.find(dylibFile->installName);
+      if (it != dylibForInstallName.end()) {
+        dylibFile->compatibilityVersion = it->second->compatibilityVersion;
+        dylibFile->currentVersion = it->second->currentVersion;
+      }
+    }
+  }
+}
+
 template <class LP> void Writer::createLoadCommands() {
   uint8_t segIndex = 0;
   for (OutputSegment *seg : outputSegments) {
     in.header->addLoadCommand(make<LCSegment<LP>>(seg->name, seg));
     seg->index = segIndex++;
   }
 
   in.header->addLoadCommand(make<LCDyldInfo>(
template <class LP> void Writer::createLoadCommands() {
   uuidCommand = make<LCUuid>();
   in.header->addLoadCommand(uuidCommand);
 
   if (useLCBuildVersion(config->platformInfo))
     in.header->addLoadCommand(make<LCBuildVersion>(config->platformInfo));
   else
     in.header->addLoadCommand(make<LCMinVersion>(config->platformInfo));
 
+  updateDylibVersions();
+
   int64_t dylibOrdinal = 1;
   DenseMap<StringRef, int64_t> ordinalForInstallName;
   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.
 

lld/test/MachO/special-symbol-ld-install-name.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
 
 ## Case 1: special symbol $ld$install_name affects the install name
 ## since the specified version 11.0.0 matches the target version 11.0.0
 
 # RUN: %lld -o %t/libfoo1.dylib %t/libLDInstallName.tbd %t/foo.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
+# RUN: llvm-otool -L %t/libfoo1.dylib | FileCheck --check-prefix=CASE1 %s
 # CASE1: /New (compatibility version 1.1.1, current version 5.0.0)
 
 ## Case 2: special symbol $ld$install_name does not affect the install name
 ## since the specified version 11.0.0 does not match the target version 12.0.0
 
 # RUN: %lld -o %t/libfoo2.dylib %t/libLDInstallName.tbd %t/foo.o -dylib -platform_version macos 12.0.0 12.0.0
-# RUN: llvm-objdump --macho --dylibs-used %t/libfoo2.dylib | FileCheck --check-prefix=CASE2 %s
+# RUN: llvm-otool -L %t/libfoo2.dylib | FileCheck --check-prefix=CASE2 %s
 # CASE2: /Old (compatibility version 1.1.1, current version 5.0.0)
 
 ## Check that we emit a warning for an invalid os version.
 
 # RUN: %no_fatal_warnings_lld -o %t/libfoo3.dylib %t/libLDInstallNameInvalid.tbd %t/foo.o -dylib \
 # RUN:  -platform_version macos 11.0.0 11.0.0 2>&1 | FileCheck --check-prefix=INVALID-VERSION %s
 
 # INVALID-VERSION: failed to parse os version, symbol '$ld$install_name$os11.a$/New' ignored
 
+## Case 3: If there's another library that has '/New' as its original
+## install_name, we should take current-version and compatibility-version from
+## there.
+# RUN: ld -o %t/libfoo3.dylib %t/libLDInstallNameNew.tbd %t/foo.o -dylib -platform_version macos 11.0.0 11.0.0
+# RUN: llvm-otool -L %t/libfoo3.dylib | FileCheck --check-prefix=CASE3 %s
+# RUN: ld -o %t/libfoo3.dylib %t/libLDInstallName.tbd %t/libLDInstallNameNew.tbd %t/foo.o -dylib -platform_version macos 11.0.0 11.0.0
+# RUN: llvm-otool -L %t/libfoo3.dylib | FileCheck --check-prefix=CASE3 %s
+# RUN: ld -o %t/libfoo3.dylib %t/libLDInstallNameNew.tbd %t/libLDInstallName.tbd %t/foo.o -dylib -platform_version macos 11.0.0 11.0.0
+# RUN: llvm-otool -L %t/libfoo3.dylib | FileCheck --check-prefix=CASE3 %s
+# CASE3: /New (compatibility version 4.5.6, current version 9.0.0)
+
 #--- foo.s
 .long _xxx@GOTPCREL
 
 #--- libLDInstallName.tbd
 --- !tapi-tbd-v3
 archs:           [ x86_64 ]
 uuids:           [ 'x86_64: 19311012-01AB-342E-812B-73A74271A715' ]
 platform:        macosx

 platform:        macosx
 install-name:    '/Old'
 current-version: 5
 compatibility-version: 1.1.1
 exports:
   - archs:           [ x86_64 ]
     symbols:         [ '$ld$install_name$os11.a$/New', _xxx ]
 ...
+
+#--- libLDInstallNameNew.tbd
+--- !tapi-tbd
+tbd-version: 4
+targets: [ x86_64-macos ]
+uuids:
+  - target: x86_64-macos
+    value:  2E994C7F-3F03-3A07-879C-55690D22BEDA
+install-name: '/New'
+current-version: 9
+compatibility-version: 4.5.6
+reexported-libraries:
+  - targets:         [ x86_64-macos ]
+    libraries:       [ '@loader_path/libLDInstallName' ]
+...