[TextAPI] Add New Supported Platforms

[cishida]

Summary

This patch introduces simulators, as well was the restriced zippered and macCatalyst to supported platforms

[cishida]

Inline PlatformSet Output

[ributzka]

LGTM

llvm/include/llvm/TextAPI/MachO/Platform.h

 
 /// Defines the list of MachO platforms.
 enum class PlatformKind : unsigned {
   unknown,
   macOS = MachO::PLATFORM_MACOS,
   iOS = MachO::PLATFORM_IOS,
   tvOS = MachO::PLATFORM_TVOS,
   watchOS = MachO::PLATFORM_WATCHOS,
-  bridgeOS = MachO::PLATFORM_BRIDGEOS
+  bridgeOS = MachO::PLATFORM_BRIDGEOS,
+  macCatalyst = MachO::PLATFORM_MACCATALYST,
+  iOSSimulator = MachO::PLATFORM_IOSSIMULATOR,
+  tvOSSimulator = MachO::PLATFORM_TVOSSIMULATOR,
+  watchOSSimulator = MachO::PLATFORM_WATCHOSSIMULATOR
 };
 
 using PlatformSet = SmallSet<PlatformKind, 3>;
 
+PlatformKind mapToPlatformKind(PlatformKind Platform, bool WantSim);
 PlatformKind mapToPlatformKind(const Triple &Target);
 PlatformSet mapToPlatformSet(ArrayRef<Triple> Targets);
 StringRef getPlatformName(PlatformKind Platform);
 
 } // end namespace MachO.
 } // end namespace llvm.
 
 #endif // LLVM_TEXTAPI_MACHO_PLATFORM_H
 No newline at end of file

llvm/lib/TextAPI/MachO/Platform.cpp

 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/TextAPI/MachO/Platform.h"
 
 namespace llvm {
 namespace MachO {
 
+PlatformKind mapToPlatformKind(PlatformKind Platform, bool WantSim) {
+  switch (Platform) {
+  default:
+    return Platform;
+  case PlatformKind::iOS:
+    return WantSim ? PlatformKind::iOSSimulator : PlatformKind::iOS;
+  case PlatformKind::tvOS:
+    return WantSim ? PlatformKind::tvOSSimulator : PlatformKind::tvOS;
+  case PlatformKind::watchOS:
+    return WantSim ? PlatformKind::watchOSSimulator : PlatformKind::watchOS;
+  }
+}
+
 PlatformKind mapToPlatformKind(const Triple &Target) {
   switch (Target.getOS()) {
   default:
     return PlatformKind::unknown;
   case Triple::MacOSX:
     return PlatformKind::macOS;
   case Triple::IOS:
+    if (Target.isSimulatorEnvironment())
+      return PlatformKind::iOSSimulator;
+    if (Target.getEnvironment() == Triple::MacABI)
+      return PlatformKind::macCatalyst;
     return PlatformKind::iOS;
   case Triple::TvOS:
-    return PlatformKind::tvOS;
+    return Target.isSimulatorEnvironment() ? PlatformKind::tvOSSimulator
+                                           : PlatformKind::tvOS;
   case Triple::WatchOS:
-    return PlatformKind::watchOS;
+    return Target.isSimulatorEnvironment() ? PlatformKind::watchOSSimulator
+                                           : PlatformKind::watchOS;
     // TODO: add bridgeOS once in llvm::Triple
   }
 }
 
 PlatformSet mapToPlatformSet(ArrayRef<Triple> Targets) {
   PlatformSet Result;
   for (const auto &Target : Targets)
     Result.insert(mapToPlatformKind(Target));
StringRef getPlatformName(PlatformKind Platform) {
   case PlatformKind::iOS:
     return "iOS";
   case PlatformKind::tvOS:
     return "tvOS";
   case PlatformKind::watchOS:
     return "watchOS";
   case PlatformKind::bridgeOS:
     return "bridgeOS";
+  case PlatformKind::macCatalyst:
+    return "macCatalyst";
+  case PlatformKind::iOSSimulator:
+    return "iOS Simulator";
+  case PlatformKind::tvOSSimulator:
+    return "tvOS Simulator";
+  case PlatformKind::watchOSSimulator:
+    return "watchOS Simulator";
   }
 }
 
 } // end namespace MachO.
 } // end namespace llvm.
 No newline at end of file

llvm/lib/TextAPI/MachO/TextStub.cpp

NormalizedTBD(IO &IO, const InterfaceFile *&File) {
         llvm::sort(Section.ClassEHs.begin(), Section.ClassEHs.end());
         llvm::sort(Section.IVars.begin(), Section.IVars.end());
         llvm::sort(Section.WeakRefSymbols.begin(),
                    Section.WeakRefSymbols.end());
         Undefineds.emplace_back(std::move(Section));
       }
     }
 
+    // TBD v1 - TBD v3 files only support one platform and several
+    // architectures. It is possible to have more than one platform for TBD v3
+    // files, but the architectures don't apply to all
+    // platforms, specifically to filter out the i386 slice from
+    // platform macCatalyst.
     TargetList synthesizeTargets(ArchitectureSet Architectures,
                                           const PlatformSet &Platforms) {
       TargetList Targets;
 
       for (auto Platform : Platforms) {
-        for (const auto &&Architecture : Architectures)
+        Platform = mapToPlatformKind(Platform, Architectures.hasX86());
+
+        for (const auto &&Architecture : Architectures) {
+          if ((Architecture == AK_i386) &&
+              (Platform == PlatformKind::macCatalyst))
+            continue;
+
           Targets.emplace_back(Architecture, Platform);
         }
+      }
       return Targets;
     }
 
     const InterfaceFile *denormalize(IO &IO) {
       auto Ctx = reinterpret_cast<TextAPIContext *>(IO.getContext());
       assert(Ctx);
 
       auto *File = new InterfaceFile;

llvm/lib/TextAPI/MachO/TextStubCommon.cpp

IO.enumCase(Constraint, "retain_release_for_simulator",
               ObjCConstraintType::Retain_Release_For_Simulator);
   IO.enumCase(Constraint, "retain_release_or_gc",
               ObjCConstraintType::Retain_Release_Or_GC);
   IO.enumCase(Constraint, "gc", ObjCConstraintType::GC);
 }
 
 void ScalarTraits<PlatformSet>::output(const PlatformSet &Values, void *IO,
                                        raw_ostream &OS) {
+
+  const auto *Ctx = reinterpret_cast<TextAPIContext *>(IO);
+  assert((!Ctx || Ctx && Ctx->FileKind != FileType::Invalid) &&
+         "File type is not set in context");
+
+  if ( Ctx && Ctx->FileKind == TBD_V3 && Values.count(PlatformKind::macOS) &&
+      Values.count(PlatformKind::macCatalyst) ) {
+    OS << "zippered";
+    return;
+  }
+
   assert(Values.size() == 1U);
   switch (*Values.begin()) {
   default:
     llvm_unreachable("unexpected platform");
     break;
   case PlatformKind::macOS:
     OS << "macosx";
     break;
   case PlatformKind::iOS:
     OS << "ios";
     break;
   case PlatformKind::watchOS:
     OS << "watchos";
     break;
   case PlatformKind::tvOS:
     OS << "tvos";
     break;
   case PlatformKind::bridgeOS:
     OS << "bridgeos";
     break;
   }
 }
+namespace {
+// TBDv3 is the only version that has zippered and macCatalyst support
+bool isValidTBDV3Platform(StringRef Scalar, PlatformKind Platform,
+                           PlatformSet &Values) {
+  if (Platform != PlatformKind::unknown) {
+    Values.insert(Platform);
+  } else if (Scalar == "zippered") {
+    Values.insert(PlatformKind::macOS);
+    Values.insert(PlatformKind::macCatalyst);
+  } else
+    return false;
+  return true;
+}
+}
 
 StringRef ScalarTraits<PlatformSet>::input(StringRef Scalar, void *IO,
                                            PlatformSet &Values) {
+  const auto *Ctx = reinterpret_cast<TextAPIContext *>(IO);
+  assert((!Ctx || Ctx && Ctx->FileKind != FileType::Invalid) &&
+         "File type is not set in context");
+
   auto Platform = StringSwitch<PlatformKind>(Scalar)
                       .Case("unknown", PlatformKind::unknown)
                       .Case("macosx", PlatformKind::macOS)
                       .Case("ios", PlatformKind::iOS)
                       .Case("watchos", PlatformKind::watchOS)
                       .Case("tvos", PlatformKind::tvOS)
                       .Case("bridgeos", PlatformKind::bridgeOS)
+                      .Case("iosmac", PlatformKind::macCatalyst)
                       .Default(PlatformKind::unknown);
 
-  if (Platform == PlatformKind::unknown)
-    return "unknown platform";
+  if (Ctx && Ctx->FileKind == FileType::TBD_V3 &&
+      isValidTBDV3Platform(Scalar, Platform, Values))
+    return {};
 
+  switch (Platform) {
+  default:
     Values.insert(Platform);
     return {};
+  case PlatformKind::unknown:
+    return "unknown platform";
+  case PlatformKind::macCatalyst:
+    return "invalid platform";
+  }
 }
 
 QuotingType ScalarTraits<PlatformSet>::mustQuote(StringRef) {
   return QuotingType::None;
 }
 
 void ScalarBitSetTraits<ArchitectureSet>::bitset(IO &IO,
                                                  ArchitectureSet &Archs) {

llvm/unittests/TextAPI/TextStubV2Tests.cpp

auto Result = TextAPIReader::get(
       MemoryBufferRef(tbd_v2_file_unknown_platform, "Test.tbd"));
   EXPECT_FALSE(!!Result);
   auto errorMessage = toString(Result.takeError());
   EXPECT_EQ("malformed file\nTest.tbd:3:11: error: unknown platform\nplatform: "
             "newOS\n          ^~~~~\n",
             errorMessage);
 }
 
+TEST(TBDv2, InvalidPlatform) {
+  static const char tbd_v2_file_invalid_platform[] =
+      "--- !tapi-tbd-v2\n"
+      "archs: [ i386 ]\n"
+      "platform: iosmac\n"
+      "install-name: Test.dylib\n"
+      "...\n";
+
+  auto Result = TextAPIReader::get(
+      MemoryBufferRef(tbd_v2_file_invalid_platform, "Test.tbd"));
+  EXPECT_FALSE(!!Result);
+  auto errorMessage = toString(Result.takeError());
+  EXPECT_EQ("malformed file\nTest.tbd:3:11: error: invalid platform\nplatform: "
+            "iosmac\n          ^~~~~~\n",
+            errorMessage);
+}
+
 TEST(TBDv2, MalformedFile1) {
   static const char malformed_file1[] = "--- !tapi-tbd-v2\n"
                                         "archs: [ arm64 ]\n"
                                         "foobar: \"Unsupported key\"\n"
                                         "...\n";
 
   auto Result =
       TextAPIReader::get(MemoryBufferRef(malformed_file1, "Test.tbd"));

llvm/unittests/TextAPI/TextStubV3Tests.cpp

TEST(TBDv3, Platform_bridgeOS) {
   EXPECT_TRUE(!!Result);
   auto Platform = PlatformKind::bridgeOS;
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
 }
 
+TEST(TBDv3, Platform_macCatalyst) {
+  static const char tbd_v1_platform_iosmac[] = "--- !tapi-tbd-v3\n"
+                                                 "archs: [ armv7k ]\n"
+                                                 "platform: iosmac\n"
+                                                 "install-name: Test.dylib\n"
+                                                 "...\n";
+
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_platform_iosmac, "Test.tbd"));
+  EXPECT_TRUE(!!Result);
+  auto Platform = PlatformKind::macCatalyst;
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V3, File->getFileType());
+  EXPECT_EQ(Platform, *File->getPlatforms().begin());
+}
+
+TEST(TBDv3, Platform_zippered) {
+  static const char tbd_v1_platform_zip[] = "--- !tapi-tbd-v3\n"
+                                                 "archs: [ armv7k ]\n"
+                                                 "platform: zippered\n"
+                                                 "install-name: Test.dylib\n"
+                                                 "...\n";
+
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_platform_zip, "Test.tbd"));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V3, File->getFileType());
+
+  PlatformSet Platforms;
+  Platforms.insert(PlatformKind::macOS);
+  Platforms.insert(PlatformKind::macCatalyst);
+  EXPECT_EQ(Platforms.size(), File->getPlatforms().size());
+  for (auto Platform : File->getPlatforms())
+      EXPECT_EQ(Platforms.count(Platform), 1U);
+}
+
 TEST(TBDv3, Swift_1_0) {
   static const char tbd_v1_swift_1_0[] = "--- !tapi-tbd-v3\n"
                                          "archs: [ arm64 ]\n"
                                          "platform: ios\n"
                                          "install-name: Test.dylib\n"
                                          "swift-abi-version: 1.0\n"
                                          "...\n";