16 files changed, 211 insertions, 227 deletions

diff --git a/llvm/include/llvm/BinaryFormat/MachO.h b/llvm/include/llvm/BinaryFormat/MachO.h
index df2ba94..ce3a5c4 100644
--- a/llvm/include/llvm/BinaryFormat/MachO.h
+++ b/llvm/include/llvm/BinaryFormat/MachO.h
@@ -489,6 +489,7 @@ enum { VM_PROT_READ = 0x1, VM_PROT_WRITE = 0x2, VM_PROT_EXECUTE = 0x4 };
 
 // Values for platform field in build_version_command.
 enum PlatformType {
+  PLATFORM_UNKNOWN = 0,
   PLATFORM_MACOS = 1,
   PLATFORM_IOS = 2,
   PLATFORM_TVOS = 3,
diff --git a/llvm/include/llvm/TextAPI/Platform.h b/llvm/include/llvm/TextAPI/Platform.h
index f7affc3..d4225ca 100644
--- a/llvm/include/llvm/TextAPI/Platform.h
+++ b/llvm/include/llvm/TextAPI/Platform.h
@@ -18,29 +18,14 @@
 namespace llvm {
 namespace MachO {
 
-/// 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,
-  macCatalyst = MachO::PLATFORM_MACCATALYST,
-  iOSSimulator = MachO::PLATFORM_IOSSIMULATOR,
-  tvOSSimulator = MachO::PLATFORM_TVOSSIMULATOR,
-  watchOSSimulator = MachO::PLATFORM_WATCHOSSIMULATOR,
-  driverKit = MachO::PLATFORM_DRIVERKIT,
-};
+using PlatformSet = SmallSet<PlatformType, 3>;
 
-using PlatformSet = SmallSet<PlatformKind, 3>;
-
-PlatformKind mapToPlatformKind(PlatformKind Platform, bool WantSim);
-PlatformKind mapToPlatformKind(const Triple &Target);
+PlatformType mapToPlatformType(PlatformType Platform, bool WantSim);
+PlatformType mapToPlatformType(const Triple &Target);
 PlatformSet mapToPlatformSet(ArrayRef<Triple> Targets);
-StringRef getPlatformName(PlatformKind Platform);
-PlatformKind getPlatformFromName(StringRef Name);
-std::string getOSAndEnvironmentName(PlatformKind Platform,
+StringRef getPlatformName(PlatformType Platform);
+PlatformType getPlatformFromName(StringRef Name);
+std::string getOSAndEnvironmentName(PlatformType Platform,
                                     std::string Version = "");
 
 } // end namespace MachO.
diff --git a/llvm/include/llvm/TextAPI/Target.h b/llvm/include/llvm/TextAPI/Target.h
index c2588b9..e35afcc 100644
--- a/llvm/include/llvm/TextAPI/Target.h
+++ b/llvm/include/llvm/TextAPI/Target.h
@@ -24,17 +24,17 @@ namespace MachO {
 class Target {
 public:
   Target() = default;
-  Target(Architecture Arch, PlatformKind Platform)
+  Target(Architecture Arch, PlatformType Platform)
       : Arch(Arch), Platform(Platform) {}
   explicit Target(const llvm::Triple &Triple)
-      : Arch(mapToArchitecture(Triple)), Platform(mapToPlatformKind(Triple)) {}
+      : Arch(mapToArchitecture(Triple)), Platform(mapToPlatformType(Triple)) {}
 
   static llvm::Expected<Target> create(StringRef Target);
 
   operator std::string() const;
 
   Architecture Arch;
-  PlatformKind Platform;
+  PlatformType Platform;
 };
 
 inline bool operator==(const Target &LHS, const Target &RHS) {
diff --git a/llvm/lib/MC/MCAsmStreamer.cpp b/llvm/lib/MC/MCAsmStreamer.cpp
index 5c2aadd..119237b 100644
--- a/llvm/lib/MC/MCAsmStreamer.cpp
+++ b/llvm/lib/MC/MCAsmStreamer.cpp
@@ -620,6 +620,8 @@ void MCAsmStreamer::emitVersionMin(MCVersionMinType Type, unsigned Major,
 
 static const char *getPlatformName(MachO::PlatformType Type) {
   switch (Type) {
+  case MachO::PLATFORM_UNKNOWN: /* silence warning*/
+    break;
   case MachO::PLATFORM_MACOS:            return "macos";
   case MachO::PLATFORM_IOS:              return "ios";
   case MachO::PLATFORM_TVOS:             return "tvos";
diff --git a/llvm/lib/MC/MCParser/DarwinAsmParser.cpp b/llvm/lib/MC/MCParser/DarwinAsmParser.cpp
index 91aa2de..308b384 100644
--- a/llvm/lib/MC/MCParser/DarwinAsmParser.cpp
+++ b/llvm/lib/MC/MCParser/DarwinAsmParser.cpp
@@ -1145,6 +1145,8 @@ bool DarwinAsmParser::parseVersionMin(StringRef Directive, SMLoc Loc,
 
 static Triple::OSType getOSTypeFromPlatform(MachO::PlatformType Type) {
   switch (Type) {
+  case MachO::PLATFORM_UNKNOWN: /* silence warning */
+    break;
   case MachO::PLATFORM_MACOS:   return Triple::MacOSX;
   case MachO::PLATFORM_IOS:     return Triple::IOS;
   case MachO::PLATFORM_TVOS:    return Triple::TvOS;
diff --git a/llvm/lib/Object/TapiFile.cpp b/llvm/lib/Object/TapiFile.cpp
index 6b57626..83568e8 100644
--- a/llvm/lib/Object/TapiFile.cpp
+++ b/llvm/lib/Object/TapiFile.cpp
@@ -45,8 +45,7 @@ TapiFile::TapiFile(MemoryBufferRef Source, const InterfaceFile &interface,
       Symbols.emplace_back(StringRef(), Symbol->getName(), getFlags(Symbol));
       break;
     case SymbolKind::ObjectiveCClass:
-      if (interface.getPlatforms().count(PlatformKind::macOS) &&
-          Arch == AK_i386) {
+      if (interface.getPlatforms().count(PLATFORM_MACOS) && Arch == AK_i386) {
         Symbols.emplace_back(ObjC1ClassNamePrefix, Symbol->getName(),
                              getFlags(Symbol));
       } else {
diff --git a/llvm/lib/TextAPI/Platform.cpp b/llvm/lib/TextAPI/Platform.cpp
index a2ce6d0..728c45c 100644
--- a/llvm/lib/TextAPI/Platform.cpp
+++ b/llvm/lib/TextAPI/Platform.cpp
@@ -18,120 +18,116 @@
 namespace llvm {
 namespace MachO {
 
-PlatformKind mapToPlatformKind(PlatformKind Platform, bool WantSim) {
+PlatformType mapToPlatformType(PlatformType 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;
+  case PLATFORM_IOS:
+    return WantSim ? PLATFORM_IOSSIMULATOR : PLATFORM_IOS;
+  case PLATFORM_TVOS:
+    return WantSim ? PLATFORM_TVOSSIMULATOR : PLATFORM_TVOS;
+  case PLATFORM_WATCHOS:
+    return WantSim ? PLATFORM_WATCHOSSIMULATOR : PLATFORM_WATCHOS;
   }
-  llvm_unreachable("Unknown llvm::MachO::PlatformKind enum");
 }
 
-PlatformKind mapToPlatformKind(const Triple &Target) {
+PlatformType mapToPlatformType(const Triple &Target) {
   switch (Target.getOS()) {
   default:
-    return PlatformKind::unknown;
+    return PLATFORM_UNKNOWN;
   case Triple::MacOSX:
-    return PlatformKind::macOS;
+    return PLATFORM_MACOS;
   case Triple::IOS:
     if (Target.isSimulatorEnvironment())
-      return PlatformKind::iOSSimulator;
+      return PLATFORM_IOSSIMULATOR;
     if (Target.getEnvironment() == Triple::MacABI)
-      return PlatformKind::macCatalyst;
-    return PlatformKind::iOS;
+      return PLATFORM_MACCATALYST;
+    return PLATFORM_IOS;
   case Triple::TvOS:
-    return Target.isSimulatorEnvironment() ? PlatformKind::tvOSSimulator
-                                           : PlatformKind::tvOS;
+    return Target.isSimulatorEnvironment() ? PLATFORM_TVOSSIMULATOR
+                                           : PLATFORM_TVOS;
   case Triple::WatchOS:
-    return Target.isSimulatorEnvironment() ? PlatformKind::watchOSSimulator
-                                           : PlatformKind::watchOS;
+    return Target.isSimulatorEnvironment() ? PLATFORM_WATCHOSSIMULATOR
+                                           : PLATFORM_WATCHOS;
     // TODO: add bridgeOS & driverKit once in llvm::Triple
   }
-  llvm_unreachable("Unknown Target Triple");
 }
 
 PlatformSet mapToPlatformSet(ArrayRef<Triple> Targets) {
   PlatformSet Result;
   for (const auto &Target : Targets)
-    Result.insert(mapToPlatformKind(Target));
+    Result.insert(mapToPlatformType(Target));
   return Result;
 }
 
-StringRef getPlatformName(PlatformKind Platform) {
+StringRef getPlatformName(PlatformType Platform) {
   switch (Platform) {
-  case PlatformKind::unknown:
+  case PLATFORM_UNKNOWN:
     return "unknown";
-  case PlatformKind::macOS:
+  case PLATFORM_MACOS:
     return "macOS";
-  case PlatformKind::iOS:
+  case PLATFORM_IOS:
     return "iOS";
-  case PlatformKind::tvOS:
+  case PLATFORM_TVOS:
     return "tvOS";
-  case PlatformKind::watchOS:
+  case PLATFORM_WATCHOS:
     return "watchOS";
-  case PlatformKind::bridgeOS:
+  case PLATFORM_BRIDGEOS:
     return "bridgeOS";
-  case PlatformKind::macCatalyst:
+  case PLATFORM_MACCATALYST:
     return "macCatalyst";
-  case PlatformKind::iOSSimulator:
+  case PLATFORM_IOSSIMULATOR:
     return "iOS Simulator";
-  case PlatformKind::tvOSSimulator:
+  case PLATFORM_TVOSSIMULATOR:
     return "tvOS Simulator";
-  case PlatformKind::watchOSSimulator:
+  case PLATFORM_WATCHOSSIMULATOR:
     return "watchOS Simulator";
-  case PlatformKind::driverKit:
+  case PLATFORM_DRIVERKIT:
     return "DriverKit";
   }
-  llvm_unreachable("Unknown llvm::MachO::PlatformKind enum");
 }
 
-PlatformKind getPlatformFromName(StringRef Name) {
-  return StringSwitch<PlatformKind>(Name)
-      .Case("macos", PlatformKind::macOS)
-      .Case("ios", PlatformKind::iOS)
-      .Case("tvos", PlatformKind::tvOS)
-      .Case("watchos", PlatformKind::watchOS)
-      .Case("bridgeos", PlatformKind::macOS)
-      .Case("ios-macabi", PlatformKind::macCatalyst)
-      .Case("ios-simulator", PlatformKind::iOSSimulator)
-      .Case("tvos-simulator", PlatformKind::tvOSSimulator)
-      .Case("watchos-simulator", PlatformKind::watchOSSimulator)
-      .Case("driverkit", PlatformKind::driverKit)
-      .Default(PlatformKind::unknown);
+PlatformType getPlatformFromName(StringRef Name) {
+  return StringSwitch<PlatformType>(Name)
+      .Case("macos", PLATFORM_MACOS)
+      .Case("ios", PLATFORM_IOS)
+      .Case("tvos", PLATFORM_TVOS)
+      .Case("watchos", PLATFORM_WATCHOS)
+      .Case("bridgeos", PLATFORM_BRIDGEOS)
+      .Case("ios-macabi", PLATFORM_MACCATALYST)
+      .Case("ios-simulator", PLATFORM_IOSSIMULATOR)
+      .Case("tvos-simulator", PLATFORM_TVOSSIMULATOR)
+      .Case("watchos-simulator", PLATFORM_WATCHOSSIMULATOR)
+      .Case("driverkit", PLATFORM_DRIVERKIT)
+      .Default(PLATFORM_UNKNOWN);
 }
 
-std::string getOSAndEnvironmentName(PlatformKind Platform,
+std::string getOSAndEnvironmentName(PlatformType Platform,
                                     std::string Version) {
   switch (Platform) {
-  case PlatformKind::unknown:
+  case PLATFORM_UNKNOWN:
     return "darwin" + Version;
-  case PlatformKind::macOS:
+  case PLATFORM_MACOS:
     return "macos" + Version;
-  case PlatformKind::iOS:
+  case PLATFORM_IOS:
     return "ios" + Version;
-  case PlatformKind::tvOS:
+  case PLATFORM_TVOS:
     return "tvos" + Version;
-  case PlatformKind::watchOS:
+  case PLATFORM_WATCHOS:
     return "watchos" + Version;
-  case PlatformKind::bridgeOS:
+  case PLATFORM_BRIDGEOS:
     return "bridgeos" + Version;
-  case PlatformKind::macCatalyst:
+  case PLATFORM_MACCATALYST:
     return "ios" + Version + "-macabi";
-  case PlatformKind::iOSSimulator:
+  case PLATFORM_IOSSIMULATOR:
     return "ios" + Version + "-simulator";
-  case PlatformKind::tvOSSimulator:
+  case PLATFORM_TVOSSIMULATOR:
     return "tvos" + Version + "-simulator";
-  case PlatformKind::watchOSSimulator:
+  case PLATFORM_WATCHOSSIMULATOR:
     return "watchos" + Version + "-simulator";
-  case PlatformKind::driverKit:
+  case PLATFORM_DRIVERKIT:
     return "driverkit" + Version;
   }
-  llvm_unreachable("Unknown llvm::MachO::PlatformKind enum");
 }
 
 } // end namespace MachO.
diff --git a/llvm/lib/TextAPI/Target.cpp b/llvm/lib/TextAPI/Target.cpp
index 35fe1bf..feeb5c6 100644
--- a/llvm/lib/TextAPI/Target.cpp
+++ b/llvm/lib/TextAPI/Target.cpp
@@ -22,26 +22,26 @@ Expected<Target> Target::create(StringRef TargetValue) {
   auto ArchitectureStr = Result.first;
   auto Architecture = getArchitectureFromName(ArchitectureStr);
   auto PlatformStr = Result.second;
-  PlatformKind Platform;
-  Platform = StringSwitch<PlatformKind>(PlatformStr)
-                 .Case("macos", PlatformKind::macOS)
-                 .Case("ios", PlatformKind::iOS)
-                 .Case("tvos", PlatformKind::tvOS)
-                 .Case("watchos", PlatformKind::watchOS)
-                 .Case("bridgeos", PlatformKind::bridgeOS)
-                 .Case("maccatalyst", PlatformKind::macCatalyst)
-                 .Case("ios-simulator", PlatformKind::iOSSimulator)
-                 .Case("tvos-simulator", PlatformKind::tvOSSimulator)
-                 .Case("watchos-simulator", PlatformKind::watchOSSimulator)
-                 .Case("driverkit", PlatformKind::driverKit)
-                 .Default(PlatformKind::unknown);
+  PlatformType Platform;
+  Platform = StringSwitch<PlatformType>(PlatformStr)
+                 .Case("macos", PLATFORM_MACOS)
+                 .Case("ios", PLATFORM_IOS)
+                 .Case("tvos", PLATFORM_TVOS)
+                 .Case("watchos", PLATFORM_WATCHOS)
+                 .Case("bridgeos", PLATFORM_BRIDGEOS)
+                 .Case("maccatalyst", PLATFORM_MACCATALYST)
+                 .Case("ios-simulator", PLATFORM_IOSSIMULATOR)
+                 .Case("tvos-simulator", PLATFORM_TVOSSIMULATOR)
+                 .Case("watchos-simulator", PLATFORM_WATCHOSSIMULATOR)
+                 .Case("driverkit", PLATFORM_DRIVERKIT)
+                 .Default(PLATFORM_UNKNOWN);
 
-  if (Platform == PlatformKind::unknown) {
+  if (Platform == PLATFORM_UNKNOWN) {
     if (PlatformStr.startswith("<") && PlatformStr.endswith(">")) {
       PlatformStr = PlatformStr.drop_front().drop_back();
       unsigned long long RawValue;
       if (!PlatformStr.getAsInteger(10, RawValue))
-        Platform = (PlatformKind)RawValue;
+        Platform = (PlatformType)RawValue;
     }
   }
 
diff --git a/llvm/lib/TextAPI/TextStub.cpp b/llvm/lib/TextAPI/TextStub.cpp
index b64f19a..ff93e43 100644
--- a/llvm/lib/TextAPI/TextStub.cpp
+++ b/llvm/lib/TextAPI/TextStub.cpp
@@ -380,34 +380,34 @@ template <> struct ScalarTraits<Target> {
     default:
       OS << "unknown";
       break;
-    case PlatformKind::macOS:
+    case PLATFORM_MACOS:
       OS << "macos";
       break;
-    case PlatformKind::iOS:
+    case PLATFORM_IOS:
       OS << "ios";
       break;
-    case PlatformKind::tvOS:
+    case PLATFORM_TVOS:
       OS << "tvos";
       break;
-    case PlatformKind::watchOS:
+    case PLATFORM_WATCHOS:
       OS << "watchos";
       break;
-    case PlatformKind::bridgeOS:
+    case PLATFORM_BRIDGEOS:
       OS << "bridgeos";
       break;
-    case PlatformKind::macCatalyst:
+    case PLATFORM_MACCATALYST:
       OS << "maccatalyst";
       break;
-    case PlatformKind::iOSSimulator:
+    case PLATFORM_IOSSIMULATOR:
       OS << "ios-simulator";
       break;
-    case PlatformKind::tvOSSimulator:
+    case PLATFORM_TVOSSIMULATOR:
       OS << "tvos-simulator";
       break;
-    case PlatformKind::watchOSSimulator:
+    case PLATFORM_WATCHOSSIMULATOR:
       OS << "watchos-simulator";
       break;
-    case PlatformKind::driverKit:
+    case PLATFORM_DRIVERKIT:
       OS << "driverkit";
       break;
     }
@@ -423,7 +423,7 @@ template <> struct ScalarTraits<Target> {
     Value = *Result;
     if (Value.Arch == AK_unknown)
       return "unknown architecture";
-    if (Value.Platform == PlatformKind::unknown)
+    if (Value.Platform == PLATFORM_UNKNOWN)
       return "unknown platform";
 
     return {};
@@ -597,11 +597,10 @@ template <> struct MappingTraits<const InterfaceFile *> {
       TargetList Targets;
 
       for (auto Platform : Platforms) {
-        Platform = mapToPlatformKind(Platform, Architectures.hasX86());
+        Platform = mapToPlatformType(Platform, Architectures.hasX86());
 
         for (const auto &&Architecture : Architectures) {
-          if ((Architecture == AK_i386) &&
-              (Platform == PlatformKind::macCatalyst))
+          if ((Architecture == AK_i386) && (Platform == PLATFORM_MACCATALYST))
             continue;
 
           Targets.emplace_back(Architecture, Platform);
diff --git a/llvm/lib/TextAPI/TextStubCommon.cpp b/llvm/lib/TextAPI/TextStubCommon.cpp
index c2713b9..29b74f9 100644
--- a/llvm/lib/TextAPI/TextStubCommon.cpp
+++ b/llvm/lib/TextAPI/TextStubCommon.cpp
@@ -49,8 +49,8 @@ void ScalarTraits<PlatformSet>::output(const PlatformSet &Values, void *IO,
   assert((!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)) {
+  if (Ctx && Ctx->FileKind == TBD_V3 && Values.count(PLATFORM_MACOS) &&
+      Values.count(PLATFORM_MACCATALYST)) {
     OS << "zippered";
     return;
   }
@@ -60,31 +60,31 @@ void ScalarTraits<PlatformSet>::output(const PlatformSet &Values, void *IO,
   default:
     llvm_unreachable("unexpected platform");
     break;
-  case PlatformKind::macOS:
+  case PLATFORM_MACOS:
     OS << "macosx";
     break;
-  case PlatformKind::iOSSimulator:
+  case PLATFORM_IOSSIMULATOR:
     LLVM_FALLTHROUGH;
-  case PlatformKind::iOS:
+  case PLATFORM_IOS:
     OS << "ios";
     break;
-  case PlatformKind::watchOSSimulator:
+  case PLATFORM_WATCHOSSIMULATOR:
     LLVM_FALLTHROUGH;
-  case PlatformKind::watchOS:
+  case PLATFORM_WATCHOS:
     OS << "watchos";
     break;
-  case PlatformKind::tvOSSimulator:
+  case PLATFORM_TVOSSIMULATOR:
     LLVM_FALLTHROUGH;
-  case PlatformKind::tvOS:
+  case PLATFORM_TVOS:
     OS << "tvos";
     break;
-  case PlatformKind::bridgeOS:
+  case PLATFORM_BRIDGEOS:
     OS << "bridgeos";
     break;
-  case PlatformKind::macCatalyst:
+  case PLATFORM_MACCATALYST:
     OS << "iosmac";
     break;
-  case PlatformKind::driverKit:
+  case PLATFORM_DRIVERKIT:
     OS << "driverkit";
     break;
   }
@@ -98,28 +98,27 @@ StringRef ScalarTraits<PlatformSet>::input(StringRef Scalar, void *IO,
 
   if (Scalar == "zippered") {
     if (Ctx && Ctx->FileKind == FileType::TBD_V3) {
-      Values.insert(PlatformKind::macOS);
-      Values.insert(PlatformKind::macCatalyst);
+      Values.insert(PLATFORM_MACOS);
+      Values.insert(PLATFORM_MACCATALYST);
       return {};
     }
     return "invalid platform";
   }
 
-  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::macCatalyst)
+  auto Platform = StringSwitch<PlatformType>(Scalar)
+                      .Case("macosx", PLATFORM_MACOS)
+                      .Case("ios", PLATFORM_IOS)
+                      .Case("watchos", PLATFORM_WATCHOS)
+                      .Case("tvos", PLATFORM_TVOS)
+                      .Case("bridgeos", PLATFORM_BRIDGEOS)
+                      .Case("iosmac", PLATFORM_MACCATALYST)
+                      .Default(PLATFORM_UNKNOWN);
+
+  if (Platform == PLATFORM_MACCATALYST)
     if (Ctx && Ctx->FileKind != FileType::TBD_V3)
       return "invalid platform";
 
-  if (Platform == PlatformKind::unknown)
+  if (Platform == PLATFORM_UNKNOWN)
     return "unknown platform";
 
   Values.insert(Platform);
@@ -226,7 +225,7 @@ StringRef ScalarTraits<UUID>::input(StringRef Scalar, void *, UUID &Value) {
   if (UUID.empty())
     return "invalid uuid string pair";
   Value.second = std::string(UUID);
-  Value.first = Target{getArchitectureFromName(Arch), PlatformKind::unknown};
+  Value.first = Target{getArchitectureFromName(Arch), PLATFORM_UNKNOWN};
   return {};
 }
 
diff --git a/llvm/tools/llvm-ifs/llvm-ifs.cpp b/llvm/tools/llvm-ifs/llvm-ifs.cpp
index 0792066..2dcd0c5 100644
--- a/llvm/tools/llvm-ifs/llvm-ifs.cpp
+++ b/llvm/tools/llvm-ifs/llvm-ifs.cpp
@@ -198,26 +198,26 @@ static Expected<std::unique_ptr<IFSStub>> readInputFile(StringRef FilePath) {
 static int writeTbdStub(const Triple &T, const std::vector<IFSSymbol> &Symbols,
                         const StringRef Format, raw_ostream &Out) {
 
-  auto PlatformKindOrError =
-      [](const llvm::Triple &T) -> llvm::Expected<llvm::MachO::PlatformKind> {
+  auto PlatformTypeOrError =
+      [](const llvm::Triple &T) -> llvm::Expected<llvm::MachO::PlatformType> {
     if (T.isMacOSX())
-      return llvm::MachO::PlatformKind::macOS;
+      return llvm::MachO::PLATFORM_MACOS;
     if (T.isTvOS())
-      return llvm::MachO::PlatformKind::tvOS;
+      return llvm::MachO::PLATFORM_TVOS;
     if (T.isWatchOS())
-      return llvm::MachO::PlatformKind::watchOS;
+      return llvm::MachO::PLATFORM_WATCHOS;
     // Note: put isiOS last because tvOS and watchOS are also iOS according
     // to the Triple.
     if (T.isiOS())
-      return llvm::MachO::PlatformKind::iOS;
+      return llvm::MachO::PLATFORM_IOS;
 
     return createStringError(errc::not_supported, "Invalid Platform.\n");
   }(T);
 
-  if (!PlatformKindOrError)
+  if (!PlatformTypeOrError)
     return -1;
 
-  PlatformKind Plat = PlatformKindOrError.get();
+  PlatformType Plat = PlatformTypeOrError.get();
   TargetList Targets({Target(llvm::MachO::mapToArchitecture(T), Plat)});
 
   InterfaceFile File;
diff --git a/llvm/tools/llvm-tapi-diff/DiffEngine.cpp b/llvm/tools/llvm-tapi-diff/DiffEngine.cpp
index ff60d52..45a1f78 100644
--- a/llvm/tools/llvm-tapi-diff/DiffEngine.cpp
+++ b/llvm/tools/llvm-tapi-diff/DiffEngine.cpp
@@ -94,8 +94,7 @@ std::string SymScalar::stringifySymbolFlag(MachO::SymbolFlags Flag) {
 
 void SymScalar::print(raw_ostream &OS, std::string Indent, MachO::Target Targ) {
   if (Val->getKind() == MachO::SymbolKind::ObjectiveCClass) {
-    if (Targ.Arch == MachO::AK_i386 &&
-        Targ.Platform == MachO::PlatformKind::macOS) {
+    if (Targ.Arch == MachO::AK_i386 && Targ.Platform == MachO::PLATFORM_MACOS) {
       OS << Indent << "\t\t" << ((Order == lhs) ? "< " : "> ")
          << ObjC1ClassNamePrefix << Val->getName()
          << getFlagString(Val->getFlags()) << "\n";
diff --git a/llvm/unittests/TextAPI/TextStubV1Tests.cpp b/llvm/unittests/TextAPI/TextStubV1Tests.cpp
index 7931070..e1cd64f 100644
--- a/llvm/unittests/TextAPI/TextStubV1Tests.cpp
+++ b/llvm/unittests/TextAPI/TextStubV1Tests.cpp
@@ -72,7 +72,7 @@ TEST(TBDv1, ReadFile) {
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V1, File->getFileType());
   auto Archs = AK_armv7 | AK_armv7s | AK_armv7k | AK_arm64;
-  auto Platform = PlatformKind::iOS;
+  auto Platform = PLATFORM_IOS;
   TargetList Targets;
   for (auto &&arch : Archs)
     Targets.emplace_back(Target(arch, Platform));
@@ -126,7 +126,7 @@ TEST(TBDv1, ReadFile2) {
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V1, File->getFileType());
   auto Archs = AK_armv7 | AK_armv7s | AK_armv7k | AK_arm64;
-  auto Platform = PlatformKind::iOS;
+  auto Platform = PLATFORM_IOS;
   TargetList Targets;
   for (auto &&arch : Archs)
     Targets.emplace_back(Target(arch, Platform));
@@ -171,7 +171,7 @@ TEST(TBDv1, WriteFile) {
   InterfaceFile File;
   TargetList Targets;
   for (auto &&arch : AK_i386 | AK_x86_64)
-    Targets.emplace_back(Target(arch, PlatformKind::macOS));
+    Targets.emplace_back(Target(arch, PLATFORM_MACOS));
   File.setPath("libfoo.dylib");
   File.setInstallName("/usr/lib/libfoo.dylib");
   File.setFileType(FileType::TBD_V1);
@@ -208,7 +208,7 @@ TEST(TBDv1, Platform_macOS) {
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv1PlatformMacOS, "Test.tbd"));
   EXPECT_TRUE(!!Result);
-  auto Platform = PlatformKind::macOS;
+  auto Platform = PLATFORM_MACOS;
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V1, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
@@ -225,7 +225,7 @@ TEST(TBDv1, Platform_iOS) {
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv1PlatformiOS, "Test.tbd"));
   EXPECT_TRUE(!!Result);
-  auto Platform = PlatformKind::iOS;
+  auto Platform = PLATFORM_IOS;
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V1, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
@@ -242,7 +242,7 @@ TEST(TBDv1, Platform_watchOS) {
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv1PlatformWatchOS, "Test.tbd"));
   EXPECT_TRUE(!!Result);
-  auto Platform = PlatformKind::watchOS;
+  auto Platform = PLATFORM_WATCHOS;
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V1, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
@@ -259,7 +259,7 @@ TEST(TBDv1, Platform_tvOS) {
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv1PlatformtvOS, "Test.tbd"));
   EXPECT_TRUE(!!Result);
-  auto Platform = PlatformKind::tvOS;
+  auto Platform = PLATFORM_TVOS;
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V1, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
@@ -276,7 +276,7 @@ TEST(TBDv1, Platform_bridgeOS) {
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv1BridgeOS, "Test.tbd"));
   EXPECT_TRUE(!!Result);
-  auto Platform = PlatformKind::bridgeOS;
+  auto Platform = PLATFORM_BRIDGEOS;
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V1, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
diff --git a/llvm/unittests/TextAPI/TextStubV2Tests.cpp b/llvm/unittests/TextAPI/TextStubV2Tests.cpp
index 873fc1f..cb8493e 100644
--- a/llvm/unittests/TextAPI/TextStubV2Tests.cpp
+++ b/llvm/unittests/TextAPI/TextStubV2Tests.cpp
@@ -73,7 +73,7 @@ TEST(TBDv2, ReadFile) {
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V2, File->getFileType());
   auto Archs = AK_armv7 | AK_armv7s | AK_armv7k | AK_arm64;
-  auto Platform = PlatformKind::iOS;
+  auto Platform = PLATFORM_IOS;
   TargetList Targets;
   for (auto &&arch : Archs)
     Targets.emplace_back(Target(arch, Platform));
@@ -145,7 +145,7 @@ TEST(TBDv2, ReadFile2) {
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V2, File->getFileType());
   auto Archs = AK_armv7 | AK_armv7s | AK_armv7k | AK_arm64;
-  auto Platform = PlatformKind::iOS;
+  auto Platform = PLATFORM_IOS;
   TargetList Targets;
   for (auto &&arch : Archs)
     Targets.emplace_back(Target(arch, Platform));
@@ -189,7 +189,7 @@ TEST(TBDv2, WriteFile) {
   InterfaceFile File;
   TargetList Targets;
   for (auto &&arch : AK_i386 | AK_x86_64)
-    Targets.emplace_back(Target(arch, PlatformKind::macOS));
+    Targets.emplace_back(Target(arch, PLATFORM_MACOS));
   File.setPath("libfoo.dylib");
   File.setInstallName("/usr/lib/libfoo.dylib");
   File.setFileType(FileType::TBD_V2);
@@ -229,7 +229,7 @@ TEST(TBDv2, Platform_macOS) {
       TextAPIReader::get(MemoryBufferRef(TBDv2PlatformMacOS, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   TBDFile File = std::move(Result.get());
-  auto Platform = PlatformKind::macOS;
+  auto Platform = PLATFORM_MACOS;
   EXPECT_EQ(FileType::TBD_V2, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
@@ -245,7 +245,7 @@ TEST(TBDv2, Platform_iOS) {
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv2PlatformiOS, "Test.tbd"));
   EXPECT_TRUE(!!Result);
-  auto Platform = PlatformKind::iOS;
+  auto Platform = PLATFORM_IOS;
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V2, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
@@ -262,7 +262,7 @@ TEST(TBDv2, Platform_watchOS) {
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv2PlatformWatchOS, "Test.tbd"));
   EXPECT_TRUE(!!Result);
-  auto Platform = PlatformKind::watchOS;
+  auto Platform = PLATFORM_WATCHOS;
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V2, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
@@ -279,7 +279,7 @@ TEST(TBDv2, Platform_tvOS) {
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv2PlatformtvOS, "Test.tbd"));
   EXPECT_TRUE(!!Result);
-  auto Platform = PlatformKind::tvOS;
+  auto Platform = PLATFORM_TVOS;
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V2, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
@@ -296,7 +296,7 @@ TEST(TBDv2, Platform_bridgeOS) {
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv2BridgeOS, "Test.tbd"));
   EXPECT_TRUE(!!Result);
-  auto Platform = PlatformKind::bridgeOS;
+  auto Platform = PLATFORM_BRIDGEOS;
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V2, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
diff --git a/llvm/unittests/TextAPI/TextStubV3Tests.cpp b/llvm/unittests/TextAPI/TextStubV3Tests.cpp
index bad3b45..61ac44e 100644
--- a/llvm/unittests/TextAPI/TextStubV3Tests.cpp
+++ b/llvm/unittests/TextAPI/TextStubV3Tests.cpp
@@ -76,14 +76,14 @@ TEST(TBDv3, ReadFile) {
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   auto Archs = AK_armv7 | AK_arm64;
-  auto Platform = PlatformKind::iOS;
+  auto Platform = PLATFORM_IOS;
   TargetList Targets;
   for (auto &&arch : Archs)
     Targets.emplace_back(Target(arch, Platform));
   EXPECT_EQ(Archs, File->getArchitectures());
-  UUIDs Uuids = {{Target(AK_armv7, PlatformKind::unknown),
+  UUIDs Uuids = {{Target(AK_armv7, PLATFORM_UNKNOWN),
                   "00000000-0000-0000-0000-000000000000"},
-                 {Target(AK_arm64, PlatformKind::unknown),
+                 {Target(AK_arm64, PLATFORM_UNKNOWN),
                   "11111111-1111-1111-1111-111111111111"}};
   EXPECT_EQ(Uuids, File->uuids());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
@@ -166,14 +166,14 @@ TEST(TBDv3, ReadMultipleDocuments) {
   EXPECT_EQ(File->documents().size(), 1U);
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   auto Archs = AK_armv7 | AK_arm64;
-  auto Platform = PlatformKind::iOS;
+  auto Platform = PLATFORM_IOS;
   TargetList Targets;
   for (auto &&arch : Archs)
     Targets.emplace_back(Target(arch, Platform));
   EXPECT_EQ(Archs, File->getArchitectures());
-  UUIDs Uuids = {{Target(AK_armv7, PlatformKind::unknown),
+  UUIDs Uuids = {{Target(AK_armv7, PLATFORM_UNKNOWN),
                   "00000000-0000-0000-0000-000000000000"},
-                 {Target(AK_arm64, PlatformKind::unknown),
+                 {Target(AK_arm64, PLATFORM_UNKNOWN),
                   "11111111-1111-1111-1111-111111111111"}};
   EXPECT_EQ(Uuids, File->uuids());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
@@ -265,7 +265,7 @@ TEST(TBDv3, WriteFile) {
   InterfaceFile File;
   TargetList Targets;
   for (auto &&arch : AK_i386 | AK_x86_64)
-    Targets.emplace_back(Target(arch, PlatformKind::macOS));
+    Targets.emplace_back(Target(arch, PLATFORM_MACOS));
   File.setPath("libfoo.dylib");
   File.setInstallName("/usr/lib/libfoo.dylib");
   File.setFileType(FileType::TBD_V3);
@@ -330,8 +330,8 @@ TEST(TBDv3, WriteMultipleDocuments) {
   InterfaceFile File;
   TargetList Targets;
   for (auto &&arch : AK_i386 | AK_x86_64) {
-    Targets.emplace_back(Target(arch, PlatformKind::macOS));
-    Targets.emplace_back(Target(arch, PlatformKind::macCatalyst));
+    Targets.emplace_back(Target(arch, PLATFORM_MACOS));
+    Targets.emplace_back(Target(arch, PLATFORM_MACCATALYST));
   }
   File.addTargets(Targets);
   File.setPath("libfoo.dylib");
@@ -356,7 +356,7 @@ TEST(TBDv3, WriteMultipleDocuments) {
 
   // Inline document
   InterfaceFile Document;
-  Targets = {Target(AK_i386, PlatformKind::macOS)};
+  Targets = {Target(AK_i386, PLATFORM_MACOS)};
   Document.addTargets(Targets);
   Document.setPath("libbar.dylib");
   Document.setInstallName("/usr/lib/libbar.dylib");
@@ -385,7 +385,7 @@ TEST(TBDv3, Platform_macOS) {
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv3PlatformMacOS, "Test.tbd"));
   EXPECT_TRUE(!!Result);
-  auto Platform = PlatformKind::macOS;
+  auto Platform = PLATFORM_MACOS;
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
@@ -409,7 +409,7 @@ TEST(TBDv3, Platform_iOS) {
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv3PlatformiOS, "Test.tbd"));
   EXPECT_TRUE(!!Result);
-  auto Platform = PlatformKind::iOS;
+  auto Platform = PLATFORM_IOS;
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
@@ -432,7 +432,7 @@ TEST(TBDv3, Platform_watchOS) {
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv3watchOS, "Test.tbd"));
   EXPECT_TRUE(!!Result);
-  auto Platform = PlatformKind::watchOS;
+  auto Platform = PLATFORM_WATCHOS;
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
@@ -456,7 +456,7 @@ TEST(TBDv3, Platform_tvOS) {
       TextAPIReader::get(MemoryBufferRef(TBDv3PlatformtvOS, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   TBDFile File = std::move(Result.get());
-  auto Platform = PlatformKind::tvOS;
+  auto Platform = PLATFORM_TVOS;
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
@@ -479,7 +479,7 @@ TEST(TBDv3, Platform_bridgeOS) {
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv3BridgeOS, "Test.tbd"));
   EXPECT_TRUE(!!Result);
-  auto Platform = PlatformKind::bridgeOS;
+  auto Platform = PLATFORM_BRIDGEOS;
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
@@ -502,7 +502,7 @@ TEST(TBDv3, Platform_macCatalyst) {
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv3PlatformiOSmac, "Test.tbd"));
   EXPECT_TRUE(!!Result);
-  auto Platform = PlatformKind::macCatalyst;
+  auto Platform = PLATFORM_MACCATALYST;
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
@@ -529,8 +529,8 @@ TEST(TBDv3, Platform_zippered) {
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
 
   PlatformSet Platforms;
-  Platforms.insert(PlatformKind::macOS);
-  Platforms.insert(PlatformKind::macCatalyst);
+  Platforms.insert(PLATFORM_MACOS);
+  Platforms.insert(PLATFORM_MACCATALYST);
   EXPECT_EQ(Platforms.size(), File->getPlatforms().size());
   for (auto Platform : File->getPlatforms())
 	    EXPECT_EQ(Platforms.count(Platform), 1U);
@@ -553,7 +553,7 @@ TEST(TBDv3, Platform_iOSSim) {
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv3PlatformiOSsim, "Test.tbd"));
   EXPECT_TRUE(!!Result);
-  auto Platform = PlatformKind::iOSSimulator;
+  auto Platform = PLATFORM_IOSSIMULATOR;
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
@@ -577,7 +577,7 @@ TEST(TBDv3, Platform_watchOSSim) {
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv3watchOSsim, "Test.tbd"));
   EXPECT_TRUE(!!Result);
-  auto Platform = PlatformKind::watchOSSimulator;
+  auto Platform = PLATFORM_WATCHOSSIMULATOR;
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
@@ -601,7 +601,7 @@ TEST(TBDv3, Platform_tvOSSim) {
       TextAPIReader::get(MemoryBufferRef(TBDv3PlatformtvOSsim, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   TBDFile File = std::move(Result.get());
-  auto Platform = PlatformKind::tvOSSimulator;
+  auto Platform = PLATFORM_TVOSSIMULATOR;
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
@@ -625,7 +625,7 @@ TEST(TBDv3, Arch_arm64e) {
       TextAPIReader::get(MemoryBufferRef(TBDv3ArchArm64e, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   TBDFile File = std::move(Result.get());
-  auto Platform = PlatformKind::iOS;
+  auto Platform = PLATFORM_IOS;
   auto Archs = AK_arm64 | AK_arm64e;
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
@@ -908,7 +908,7 @@ TEST(TBDv3, InterfaceInequality) {
   InterfaceFile FileB = std::move(*ResultB.get());
 
   EXPECT_TRUE(checkEqualityOnTransform(FileA, FileB, [](InterfaceFile *File) {
-    File->addTarget(Target(AK_x86_64, PlatformKind::iOS));
+    File->addTarget(Target(AK_x86_64, PLATFORM_IOS));
   }));
   EXPECT_TRUE(checkEqualityOnTransform(FileA, FileB, [](InterfaceFile *File) {
     File->setCurrentVersion(PackedVersion(1, 2, 3));
@@ -925,22 +925,23 @@ TEST(TBDv3, InterfaceInequality) {
     File->setApplicationExtensionSafe(false);
   }));
   EXPECT_TRUE(checkEqualityOnTransform(FileA, FileB, [](InterfaceFile *File) {
-    File->addParentUmbrella(Target(AK_armv7, PlatformKind::iOS), "Umbrella.dylib");
+    File->addParentUmbrella(Target(AK_armv7, PLATFORM_IOS), "Umbrella.dylib");
   }));
   EXPECT_TRUE(checkEqualityOnTransform(FileA, FileB, [](InterfaceFile *File) {
-    File->addAllowableClient("ClientA", Target(AK_armv7, PlatformKind::iOS));
+    File->addAllowableClient("ClientA", Target(AK_armv7, PLATFORM_IOS));
   }));
   EXPECT_TRUE(checkEqualityOnTransform(FileA, FileB, [](InterfaceFile *File) {
     File->addReexportedLibrary("/System/Library/Frameworks/A.framework/A",
-                              Target(AK_armv7, PlatformKind::iOS));
+                               Target(AK_armv7, PLATFORM_IOS));
   }));
   EXPECT_TRUE(checkEqualityOnTransform(FileA, FileB, [](InterfaceFile *File) {
-    File->addSymbol(SymbolKind::GlobalSymbol, "_symA", {Target(AK_arm64, PlatformKind::iOS)});
+    File->addSymbol(SymbolKind::GlobalSymbol, "_symA",
+                    {Target(AK_arm64, PLATFORM_IOS)});
   }));
   EXPECT_TRUE(checkEqualityOnTransform(FileA, FileB, [](InterfaceFile *File) {
     InterfaceFile Document;
-    Document.addTargets(TargetList{Target(AK_armv7, PlatformKind::iOS),
-                      Target(AK_arm64, PlatformKind::iOS)});
+    Document.addTargets(TargetList{Target(AK_armv7, PLATFORM_IOS),
+                                   Target(AK_arm64, PLATFORM_IOS)});
     Document.setInstallName("/System/Library/Frameworks/A.framework/A");
     File->addDocument(std::make_shared<InterfaceFile>(std::move(Document)));
   }));
diff --git a/llvm/unittests/TextAPI/TextStubV4Tests.cpp b/llvm/unittests/TextAPI/TextStubV4Tests.cpp
index 1fe5081..fffbecc 100644
--- a/llvm/unittests/TextAPI/TextStubV4Tests.cpp
+++ b/llvm/unittests/TextAPI/TextStubV4Tests.cpp
@@ -86,9 +86,9 @@ TEST(TBDv4, ReadFile) {
   Platforms.insert(getPlatformFromName("ios"));
   auto Archs = AK_i386 | AK_x86_64;
   TargetList Targets = {
-      Target(AK_i386, PlatformKind::macOS),
-      Target(AK_x86_64, PlatformKind::macOS),
-      Target(AK_x86_64, PlatformKind::iOS),
+      Target(AK_i386, PLATFORM_MACOS),
+      Target(AK_x86_64, PLATFORM_MACOS),
+      Target(AK_x86_64, PLATFORM_IOS),
   };
   UUIDs uuids = {{Targets[0], "00000000-0000-0000-0000-000000000000"},
                  {Targets[1], "11111111-1111-1111-1111-111111111111"},
@@ -221,8 +221,8 @@ TEST(TBDv4, ReadMultipleDocuments) {
       "...\n";
 
   PlatformSet Platforms;
-  Platforms.insert(PlatformKind::macOS);
-  Platforms.insert(PlatformKind::macCatalyst);
+  Platforms.insert(PLATFORM_MACOS);
+  Platforms.insert(PLATFORM_MACCATALYST);
   ArchitectureSet Archs = AK_i386 | AK_x86_64;
   TargetList Targets;
   for (auto &&Arch : Archs)
@@ -260,7 +260,7 @@ TEST(TBDv4, ReadMultipleDocuments) {
   // Check Inlined Document
   Targets.clear();
   Uuids.clear();
-  PlatformKind Platform = PlatformKind::macOS;
+  PlatformType Platform = PLATFORM_MACOS;
   for (auto &&Arch : Archs)
     Targets.emplace_back(Target(Arch, Platform));
   Uuids = {
@@ -359,8 +359,8 @@ TEST(TBDv4, WriteFile) {
 
   InterfaceFile File;
   TargetList Targets = {
-      Target(AK_i386, PlatformKind::macOS),
-      Target(AK_x86_64, PlatformKind::iOSSimulator),
+      Target(AK_i386, PLATFORM_MACOS),
+      Target(AK_x86_64, PLATFORM_IOSSIMULATOR),
   };
   UUIDs uuids = {{Targets[0], "00000000-0000-0000-0000-000000000000"},
                  {Targets[1], "11111111-1111-1111-1111-111111111111"}};
@@ -425,7 +425,7 @@ TEST(TBDv4, WriteMultipleDocuments) {
       "...\n";
 
   InterfaceFile File;
-  PlatformKind Platform = PlatformKind::macCatalyst;
+  PlatformType Platform = PLATFORM_MACCATALYST;
   TargetList Targets = {
       Target(AK_i386, Platform),
       Target(AK_x86_64, Platform),
@@ -485,9 +485,9 @@ TEST(TBDv4, MultipleTargets) {
       TextAPIReader::get(MemoryBufferRef(TBDv4MultipleTargets, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   PlatformSet Platforms;
-  Platforms.insert(PlatformKind::macCatalyst);
-  Platforms.insert(PlatformKind::tvOS);
-  Platforms.insert(PlatformKind::iOS);
+  Platforms.insert(PLATFORM_MACCATALYST);
+  Platforms.insert(PLATFORM_TVOS);
+  Platforms.insert(PLATFORM_IOS);
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(AK_x86_64 | AK_arm64 | AK_i386, File->getArchitectures());
@@ -515,8 +515,8 @@ TEST(TBDv4, MultipleTargetsSameArch) {
       TextAPIReader::get(MemoryBufferRef(TBDv4TargetsSameArch, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   PlatformSet Platforms;
-  Platforms.insert(PlatformKind::tvOS);
-  Platforms.insert(PlatformKind::macCatalyst);
+  Platforms.insert(PLATFORM_TVOS);
+  Platforms.insert(PLATFORM_MACCATALYST);
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(ArchitectureSet(AK_x86_64), File->getArchitectures());
@@ -547,7 +547,7 @@ TEST(TBDv4, MultipleTargetsSamePlatform) {
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(AK_arm64 | AK_armv7k, File->getArchitectures());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
-  EXPECT_EQ(PlatformKind::iOS, *File->getPlatforms().begin());
+  EXPECT_EQ(PLATFORM_IOS, *File->getPlatforms().begin());
 
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
@@ -572,7 +572,7 @@ TEST(TBDv4, Target_maccatalyst) {
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(ArchitectureSet(AK_x86_64), File->getArchitectures());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
-  EXPECT_EQ(PlatformKind::macCatalyst, *File->getPlatforms().begin());
+  EXPECT_EQ(PLATFORM_MACCATALYST, *File->getPlatforms().begin());
 
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
@@ -596,7 +596,7 @@ TEST(TBDv4, Target_x86_ios) {
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(ArchitectureSet(AK_x86_64), File->getArchitectures());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
-  EXPECT_EQ(PlatformKind::iOS, *File->getPlatforms().begin());
+  EXPECT_EQ(PLATFORM_IOS, *File->getPlatforms().begin());
 
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
@@ -619,7 +619,7 @@ TEST(TBDv4, Target_arm_bridgeOS) {
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
-  EXPECT_EQ(PlatformKind::bridgeOS, *File->getPlatforms().begin());
+  EXPECT_EQ(PLATFORM_BRIDGEOS, *File->getPlatforms().begin());
   EXPECT_EQ(ArchitectureSet(AK_armv7k), File->getArchitectures());
 
   SmallString<4096> Buffer;
@@ -643,7 +643,7 @@ TEST(TBDv4, Target_arm_iOS) {
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
-  EXPECT_EQ(PlatformKind::iOS, *File->getPlatforms().begin());
+  EXPECT_EQ(PLATFORM_IOS, *File->getPlatforms().begin());
   EXPECT_EQ(ArchitectureSet(AK_arm64e), File->getArchitectures());
 
   SmallString<4096> Buffer;
@@ -667,7 +667,7 @@ TEST(TBDv4, Target_x86_macos) {
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(ArchitectureSet(AK_x86_64), File->getArchitectures());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
-  EXPECT_EQ(PlatformKind::macOS, *File->getPlatforms().begin());
+  EXPECT_EQ(PLATFORM_MACOS, *File->getPlatforms().begin());
 
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
@@ -692,7 +692,7 @@ TEST(TBDv4, Target_x86_ios_simulator) {
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(ArchitectureSet(AK_x86_64), File->getArchitectures());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
-  EXPECT_EQ(PlatformKind::iOSSimulator, *File->getPlatforms().begin());
+  EXPECT_EQ(PLATFORM_IOSSIMULATOR, *File->getPlatforms().begin());
 
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
@@ -716,7 +716,7 @@ TEST(TBDv4, Target_x86_tvos_simulator) {
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(ArchitectureSet(AK_x86_64), File->getArchitectures());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
-  EXPECT_EQ(PlatformKind::tvOSSimulator, *File->getPlatforms().begin());
+  EXPECT_EQ(PLATFORM_TVOSSIMULATOR, *File->getPlatforms().begin());
 
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
@@ -740,7 +740,7 @@ TEST(TBDv4, Target_i386_watchos_simulator) {
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(ArchitectureSet(AK_i386), File->getArchitectures());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
-  EXPECT_EQ(PlatformKind::watchOSSimulator, *File->getPlatforms().begin());
+  EXPECT_EQ(PLATFORM_WATCHOSSIMULATOR, *File->getPlatforms().begin());
 
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
@@ -764,7 +764,7 @@ TEST(TBDv4, Target_i386_driverkit) {
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(ArchitectureSet(AK_i386), File->getArchitectures());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
-  EXPECT_EQ(PlatformKind::driverKit, *File->getPlatforms().begin());
+  EXPECT_EQ(PLATFORM_DRIVERKIT, *File->getPlatforms().begin());
 
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
@@ -1134,7 +1134,7 @@ TEST(TBDv4, InterfaceInequality) {
   InterfaceFile FileB = std::move(*ResultB.get());
 
   EXPECT_TRUE(checkEqualityOnTransform(FileA, FileB, [](InterfaceFile *File) {
-    File->addTarget(Target(AK_x86_64, PlatformKind::iOS));
+    File->addTarget(Target(AK_x86_64, PLATFORM_IOS));
   }));
   EXPECT_TRUE(checkEqualityOnTransform(FileA, FileB, [](InterfaceFile *File) {
     File->setCurrentVersion(PackedVersion(1, 2, 3));
@@ -1151,22 +1151,23 @@ TEST(TBDv4, InterfaceInequality) {
     File->setApplicationExtensionSafe(false);
   }));
   EXPECT_TRUE(checkEqualityOnTransform(FileA, FileB, [](InterfaceFile *File) {
-    File->addParentUmbrella(Target(AK_x86_64, PlatformKind::macOS), "System.dylib");
+    File->addParentUmbrella(Target(AK_x86_64, PLATFORM_MACOS), "System.dylib");
   }));
   EXPECT_TRUE(checkEqualityOnTransform(FileA, FileB, [](InterfaceFile *File) {
-    File->addAllowableClient("ClientA", Target(AK_i386, PlatformKind::macOS));
+    File->addAllowableClient("ClientA", Target(AK_i386, PLATFORM_MACOS));
   }));
   EXPECT_TRUE(checkEqualityOnTransform(FileA, FileB, [](InterfaceFile *File) {
     File->addReexportedLibrary("/System/Library/Frameworks/A.framework/A",
-                               Target(AK_i386, PlatformKind::macOS));
+                               Target(AK_i386, PLATFORM_MACOS));
   }));
   EXPECT_TRUE(checkEqualityOnTransform(FileA, FileB, [](InterfaceFile *File) {
-    File->addSymbol(SymbolKind::GlobalSymbol, "_symA", {Target(AK_x86_64, PlatformKind::macOS)});
+    File->addSymbol(SymbolKind::GlobalSymbol, "_symA",
+                    {Target(AK_x86_64, PLATFORM_MACOS)});
   }));
   EXPECT_TRUE(checkEqualityOnTransform(FileA, FileB, [](InterfaceFile *File) {
     InterfaceFile Document;
-    Document.addTargets(TargetList {Target(AK_i386, PlatformKind::macOS),
-                      Target(AK_x86_64, PlatformKind::macOS)});
+    Document.addTargets(TargetList{Target(AK_i386, PLATFORM_MACOS),
+                                   Target(AK_x86_64, PLATFORM_MACOS)});
     Document.setInstallName("/System/Library/Frameworks/A.framework/A");
     File->addDocument(std::make_shared<InterfaceFile>(std::move(Document)));
   }));