[llvm][TextAPI] Handle implicitly upgraded deployment versions

[cishida]

Summary

Sometimes the clang driver will receive a target triple where the
deployment version is too low to support the platform + arch. In those
cases, the compiler upgrades the final minOS which is what gets recorded
ultimately by the linker in LC_BUILD_VERSION. TextAPI should also reuse
this logic for capturing minOS in recorded TBDv5 files.

[cishida]

ping

[ributzka]

LGTM

llvm/include/llvm/TextAPI/Platform.h

 //===- llvm/TextAPI/Platform.h - Platform -----------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines the Platforms supported by Tapi and helpers.
 //
 //===----------------------------------------------------------------------===//
 #ifndef LLVM_TEXTAPI_PLATFORM_H
 #define LLVM_TEXTAPI_PLATFORM_H
 
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/BinaryFormat/MachO.h"
+#include "llvm/Support/VersionTuple.h"
 
 namespace llvm {
 namespace MachO {
 
 using PlatformSet = SmallSet<PlatformType, 3>;
 
 PlatformType mapToPlatformType(PlatformType Platform, bool WantSim);
 PlatformType mapToPlatformType(const Triple &Target);
 PlatformSet mapToPlatformSet(ArrayRef<Triple> Targets);
 StringRef getPlatformName(PlatformType Platform);
 PlatformType getPlatformFromName(StringRef Name);
 std::string getOSAndEnvironmentName(PlatformType Platform,
                                     std::string Version = "");
+VersionTuple mapToSupportedOSVersion(const Triple &Triple);
 
 } // end namespace MachO.
 } // end namespace llvm.
 
 #endif // LLVM_TEXTAPI_PLATFORM_H

llvm/include/llvm/TextAPI/Target.h

 class Target {
 public:
   Target() = default;
   Target(Architecture Arch, PlatformType Platform,
          VersionTuple MinDeployment = {})
       : Arch(Arch), Platform(Platform), MinDeployment(MinDeployment) {}
   explicit Target(const llvm::Triple &Triple)
       : Arch(mapToArchitecture(Triple)), Platform(mapToPlatformType(Triple)),
-        MinDeployment(Triple.getOSVersion()) {}
+        MinDeployment(mapToSupportedOSVersion(Triple)) {}
 
   static llvm::Expected<Target> create(StringRef Target);
 
   operator std::string() const;
 
   Architecture Arch;
   PlatformType Platform;
   VersionTuple MinDeployment;

llvm/lib/TextAPI/Platform.cpp

std::string getOSAndEnvironmentName(PlatformType Platform,
   case PLATFORM_WATCHOSSIMULATOR:
     return "watchos" + Version + "-simulator";
   case PLATFORM_DRIVERKIT:
     return "driverkit" + Version;
   }
   llvm_unreachable("Unknown llvm::MachO::PlatformType enum");
 }
 
+VersionTuple mapToSupportedOSVersion(const Triple &Triple) {
+  const VersionTuple MinSupportedOS = Triple.getMinimumSupportedOSVersion();
+  if (MinSupportedOS > Triple.getOSVersion())
+    return MinSupportedOS;
+  return Triple.getOSVersion();
+}
+
 } // end namespace MachO.
 } // end namespace llvm.

llvm/lib/TextAPI/TextStubV5.cpp

if (!VersionStr)
       return make_error<JSONStubError>(getParseErrorMsg(TBDKey::Deployment));
     VersionTuple Version;
     if (Version.tryParse(*VersionStr))
       return make_error<JSONStubError>(getParseErrorMsg(TBDKey::Deployment));
     auto TargetOrErr = Target::create(*TargetStr);
     if (!TargetOrErr)
       return make_error<JSONStubError>(getParseErrorMsg(TBDKey::Target));
     TargetOrErr->MinDeployment = Version;
-
-    IFTargets.push_back(*TargetOrErr);
+    // Convert to LLVM::Triple to accurately compute minOS + platform + arch
+    // pairing.
+    IFTargets.push_back(
+        MachO::Target(Triple(getTargetTripleName(*TargetOrErr))));
   }
   return std::move(IFTargets);
 }
 
 Error collectSymbolsFromSegment(const Object *Segment, TargetsToSymbols &Result,
                                 SymbolFlags SectionFlag) {
   auto Err = collectFromArray(
       TBDKey::Globals, Segment, [&Result, &SectionFlag](StringRef Name) {

llvm/unittests/TextAPI/TextStubV5Tests.cpp

"main_library": {
 
   Expected<TBDFile> Output =
       TextAPIReader::get(MemoryBufferRef(Buffer, "Output.tbd"));
   EXPECT_TRUE(!!Output);
   TBDFile WriteResultFile = std::move(Output.get());
   EXPECT_EQ(*File, *WriteResultFile);
 }
 
+TEST(TBDv5, Target_UnsupportedMinOS) {
+  static const char TBDv5File[] = R"({ 
+"tapi_tbd_version": 5,
+"main_library": {
+  "target_info": [
+    {
+      "target": "arm64-macos",
+      "min_deployment": "10.14"
+    },
+    {
+      "target": "x86_64-macos",
+      "min_deployment": "10.14" 
+    }
+  ],
+  "install_names":[
+    { "name":"/S/L/F/Foo.framework/Foo" }
+  ]
+}})";
+
+  Expected<TBDFile> Result =
+      TextAPIReader::get(MemoryBufferRef(TBDv5File, "Test.tbd"));
+  EXPECT_TRUE(!!Result);
+  TBDFile File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V5, File->getFileType());
+  TargetList ExpectedTargets = {
+      Target(AK_x86_64, PLATFORM_MACOS, VersionTuple(10, 14)),
+      Target(AK_arm64, PLATFORM_MACOS, VersionTuple(11, 0)),
+  };
+  TargetList Targets{File->targets().begin(), File->targets().end()};
+  llvm::sort(Targets);
+  EXPECT_EQ(Targets, ExpectedTargets);
+
+  SmallString<4096> Buffer;
+  raw_svector_ostream OS(Buffer);
+  Error WriteResult = TextAPIWriter::writeToStream(OS, *File);
+  EXPECT_TRUE(!WriteResult);
+
+  Expected<TBDFile> Output =
+      TextAPIReader::get(MemoryBufferRef(Buffer, "Output.tbd"));
+  EXPECT_TRUE(!!Output);
+  TBDFile WriteResultFile = std::move(Output.get());
+  EXPECT_EQ(*File, *WriteResultFile);
+}
+
 TEST(TBDv5, MisspelledKey) {
   static const char TBDv5File[] = R"({ 
 "tapi_tbd_version": 5,
 "main_library": {
   "target_info": [
     {
       "target": "arm64-ios-simulator",
       "min_deployment": "11.0"