Platform.cpp

//===--- Platform.cpp - Implement platform-related helpers ----------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//

#include"swift/Basic/Assertions.h"
#include"swift/Basic/Pack.h"
#include"swift/Basic/Platform.h"
#include"llvm/ADT/StringExtras.h"
#include"llvm/ADT/StringSwitch.h"
#include"llvm/TargetParser/Triple.h"
#include"llvm/Support/VersionTuple.h"

usingnamespaceswift;

boolswift::tripleIsiOSSimulator(const llvm::Triple &triple) {
return (triple.isiOS() &&
 !tripleIsMacCatalystEnvironment(triple) &&
 triple.isSimulatorEnvironment());
}

boolswift::tripleIsAppleTVSimulator(const llvm::Triple &triple) {
return (triple.isTvOS() && triple.isSimulatorEnvironment());
}

boolswift::tripleIsWatchSimulator(const llvm::Triple &triple) {
return (triple.isWatchOS() && triple.isSimulatorEnvironment());
}

boolswift::tripleIsMacCatalystEnvironment(const llvm::Triple &triple) {
return triple.isiOS() && !triple.isTvOS() &&
 triple.getEnvironment() == llvm::Triple::MacABI;
}

boolswift::tripleIsVisionSimulator(const llvm::Triple &triple) {
return triple.isXROS() && triple.isSimulatorEnvironment();
}

boolswift::tripleInfersSimulatorEnvironment(const llvm::Triple &triple) {
switch (triple.getOS()) {
case llvm::Triple::IOS:
case llvm::Triple::TvOS:
case llvm::Triple::WatchOS:
return !triple.hasEnvironment() &&
 (triple.getArch() == llvm::Triple::x86 ||
 triple.getArch() == llvm::Triple::x86_64) &&
 !tripleIsMacCatalystEnvironment(triple);

default:
returnfalse;
 }
}

boolswift::triplesAreValidForZippering(const llvm::Triple &target,
const llvm::Triple &targetVariant) {
// The arch and vendor must match.
if (target.getArchName() != targetVariant.getArchName() ||
 target.getArch() != targetVariant.getArch() ||
 target.getSubArch() != targetVariant.getSubArch() ||
 target.getVendor() != targetVariant.getVendor()) {
returnfalse;
 }

// Allow a macOS target and an iOS-macabi target variant
// This is typically the case when zippering a library originally
// developed for macOS.
if (target.isMacOSX() && tripleIsMacCatalystEnvironment(targetVariant)) {
returntrue;
 }

// Allow an iOS-macabi target and a macOS target variant. This would
// be the case when zippering a library originally developed for
// iOS.
if (targetVariant.isMacOSX() && tripleIsMacCatalystEnvironment(target)) {
returntrue;
 }

returnfalse;
}

const std::optional<llvm::VersionTuple>
swift::minimumAvailableOSVersionForTriple(const llvm::Triple &triple) {
if (triple.isMacOSX())
returnllvm::VersionTuple(10, 10, 0);

// Mac Catalyst was introduced with an iOS deployment target of 13.1.
if (tripleIsMacCatalystEnvironment(triple))
returnllvm::VersionTuple(13, 1);

// Note: this must come before checking iOS since that returns true for
// both iOS and tvOS.
if (triple.isTvOS())
returnllvm::VersionTuple(9, 0);

if (triple.isiOS())
returnllvm::VersionTuple(8, 0);

if (triple.isWatchOS())
returnllvm::VersionTuple(2, 0);

if (triple.isXROS())
returnllvm::VersionTuple(1, 0);

return std::nullopt;
}

boolswift::tripleRequiresRPathForSwiftLibrariesInOS(
const llvm::Triple &triple) {
if (triple.isMacOSX()) {
// macOS versions before 10.14.4 don't have Swift in the OS
// (the linker still uses an rpath-based install name until 10.15).
// macOS versions before 12.0 don't have _Concurrency in the OS.
return triple.isMacOSXVersionLT(12, 0);
 }

if (triple.isiOS()) {
// iOS versions before 12.2 don't have Swift in the OS.
// iOS versions before 15.0 don't have _Concurrency in the OS.
return triple.isOSVersionLT(15, 0);
 }

if (triple.isWatchOS()) {
// watchOS versions before 5.2 don't have Swift in the OS.
// watchOS versions before 8.0 don't have _Concurrency in the OS.
return triple.isOSVersionLT(8, 0);
 }

if (triple.isXROS()) {
return triple.isOSVersionLT(1, 0);
 }

// Other platforms don't have Swift installed as part of the OS by default.
returnfalse;
}

boolswift::tripleBTCFIByDefaultInOpenBSD(const llvm::Triple &triple) {
return triple.isOSOpenBSD() && triple.getArch() == llvm::Triple::aarch64;
}

DarwinPlatformKind swift::getDarwinPlatformKind(const llvm::Triple &triple) {
if (triple.isiOS()) {
if (triple.isTvOS()) {
if (tripleIsAppleTVSimulator(triple))
return DarwinPlatformKind::TvOSSimulator;
return DarwinPlatformKind::TvOS;
 }

if (tripleIsiOSSimulator(triple))
return DarwinPlatformKind::IPhoneOSSimulator;

return DarwinPlatformKind::IPhoneOS;
 }

if (triple.isWatchOS()) {
if (tripleIsWatchSimulator(triple))
return DarwinPlatformKind::WatchOSSimulator;
return DarwinPlatformKind::WatchOS;
 }

if (triple.isMacOSX())
return DarwinPlatformKind::MacOS;

if (triple.isXROS()) {
if (tripleIsVisionSimulator(triple))
return DarwinPlatformKind::VisionOSSimulator;
return DarwinPlatformKind::VisionOS;
 }

llvm_unreachable("Unsupported Darwin platform");
}

static StringRef getPlatformNameForDarwin(const DarwinPlatformKind platform) {
switch (platform) {
case DarwinPlatformKind::MacOS:
return"macosx";
case DarwinPlatformKind::IPhoneOS:
return"iphoneos";
case DarwinPlatformKind::IPhoneOSSimulator:
return"iphonesimulator";
case DarwinPlatformKind::TvOS:
return"appletvos";
case DarwinPlatformKind::TvOSSimulator:
return"appletvsimulator";
case DarwinPlatformKind::WatchOS:
return"watchos";
case DarwinPlatformKind::WatchOSSimulator:
return"watchsimulator";
case DarwinPlatformKind::VisionOS:
return"xros";
case DarwinPlatformKind::VisionOSSimulator:
return"xrsimulator";
 }
llvm_unreachable("Unsupported Darwin platform");
}

StringRef swift::getPlatformNameForTriple(const llvm::Triple &triple) {
switch (triple.getOS()) {
case llvm::Triple::AIX:
case llvm::Triple::AMDHSA:
case llvm::Triple::AMDPAL:
case llvm::Triple::BridgeOS:
case llvm::Triple::CUDA:
case llvm::Triple::DragonFly:
case llvm::Triple::DriverKit:
case llvm::Triple::ELFIAMCU:
case llvm::Triple::Emscripten:
case llvm::Triple::Fuchsia:
case llvm::Triple::HermitCore:
case llvm::Triple::Hurd:
case llvm::Triple::KFreeBSD:
case llvm::Triple::Lv2:
case llvm::Triple::Mesa3D:
case llvm::Triple::NaCl:
case llvm::Triple::NetBSD:
case llvm::Triple::NVCL:
case llvm::Triple::PS5:
case llvm::Triple::RTEMS:
case llvm::Triple::Serenity:
case llvm::Triple::ShaderModel:
case llvm::Triple::Solaris:
case llvm::Triple::Vulkan:
case llvm::Triple::ZOS:
return"";
case llvm::Triple::Darwin:
case llvm::Triple::MacOSX:
case llvm::Triple::IOS:
case llvm::Triple::TvOS:
case llvm::Triple::WatchOS:
case llvm::Triple::XROS:
returngetPlatformNameForDarwin(getDarwinPlatformKind(triple));
case llvm::Triple::Linux:
if (triple.isAndroid())
return"android";
elseif (triple.isMusl()) {
// The triple for linux-static is <arch>-swift-linux-musl, to distinguish
// it from a "normal" musl set-up (ala Alpine).
if (triple.getVendor() == llvm::Triple::Swift)
return"linux-static";
else
return"musl";
 } else
return"linux";
case llvm::Triple::FreeBSD:
return"freebsd";
case llvm::Triple::OpenBSD:
return"openbsd";
case llvm::Triple::Win32:
switch (triple.getEnvironment()) {
case llvm::Triple::Cygnus:
return"cygwin";
case llvm::Triple::GNU:
return"mingw";
case llvm::Triple::MSVC:
case llvm::Triple::Itanium:
return"windows";
default:
return"none";
 }
case llvm::Triple::PS4:
return"ps4";
case llvm::Triple::Haiku:
return"haiku";
case llvm::Triple::WASI:
return"wasi";
case llvm::Triple::UnknownOS:
return"none";
case llvm::Triple::UEFI:
case llvm::Triple::LiteOS:
llvm_unreachable("unsupported OS");
 }
llvm_unreachable("unsupported OS");
}

StringRef swift::getMajorArchitectureName(const llvm::Triple &Triple) {
if (Triple.isOSLinux()) {
switch (Triple.getSubArch()) {
case llvm::Triple::SubArchType::ARMSubArch_v7:
return"armv7";
case llvm::Triple::SubArchType::ARMSubArch_v6:
return"armv6";
case llvm::Triple::SubArchType::ARMSubArch_v5:
return"armv5";
default:
break;
 }
 }

if (Triple.isOSOpenBSD()) {
if (Triple.getArchName() == "amd64") {
return"x86_64";
 }
 }

return Triple.getArchName();
}

// The code below is responsible for normalizing target triples into the form
// used to name target-specific swiftmodule, swiftinterface, and swiftdoc files.
// If two triples have incompatible ABIs or can be distinguished by Swift #if
// declarations, they should normalize to different values.
//
// This code is only really used on platforms with toolchains supporting fat
// binaries (a single binary containing multiple architectures). On these
// platforms, this code should strip unnecessary details from target triple
// components and map synonyms to canonical values. Even values which don't need
// any special canonicalization should be documented here as comments.
//
// (Fallback behavior does not belong here; it should be implemented in code
// that calls this function, most importantly in SerializedModuleLoaderBase.)
//
// If you're trying to refer to this code to understand how Swift behaves and
// you're unfamiliar with LLVM internals, here's a cheat sheet for reading it:
//
// * llvm::Triple is the type for a target name. It's a bit of a misnomer,
// because it can contain three or four values: arch-vendor-os[-environment].
//
// * In .Cases and .Case, the last argument is the value the arguments before it
// map to. That is, `.Cases("bar", "baz", "foo")` will return "foo" if it sees
// "bar" or "baz".
//
// * std::optional is similar to a Swift Optional: it either contains a value
// or represents the absence of one. `None` is equivalent to `nil`; leading
// `*` is equivalent to trailing `!`; conversion to `bool` is a not-`None`
// check.

static StringRef
getArchForAppleTargetSpecificModuleTriple(const llvm::Triple &triple) {
auto tripleArchName = triple.getArchName();

return llvm::StringSwitch<StringRef>(tripleArchName)
 .Cases("arm64", "aarch64", "arm64")
 .Cases("arm64_32", "aarch64_32", "arm64_32")
 .Cases("x86_64", "amd64", "x86_64")
 .Cases("i386", "i486", "i586", "i686", "i786", "i886", "i986",
"i386")
 .Cases("unknown", "", "unknown")
// These values are also supported, but are handled by the default case below:
// .Case ("armv7s", "armv7s")
// .Case ("armv7k", "armv7k")
// .Case ("armv7", "armv7")
// .Case ("arm64e", "arm64e")
 .Default(tripleArchName);
}

static StringRef
getVendorForAppleTargetSpecificModuleTriple(const llvm::Triple &triple) {
// We unconditionally normalize to "apple" because it's relatively common for
// build systems to omit the vendor name or use an incorrect one like
// "unknown". Most parts of the compiler ignore the vendor, so you might not
// notice such a mistake.
//
// Please don't depend on this behavior--specify 'apple' if you're building
// for an Apple platform.

assert(triple.isOSDarwin() &&
"shouldn't normalize non-Darwin triple to 'apple'");

return"apple";
}

static StringRef
getOSForAppleTargetSpecificModuleTriple(const llvm::Triple &triple) {
auto tripleOSName = triple.getOSName();

// Truncate the OS name before the first digit. "Digit" here is ASCII '0'-'9'.
auto tripleOSNameNoVersion = tripleOSName.take_until(llvm::isDigit);

return llvm::StringSwitch<StringRef>(tripleOSNameNoVersion)
 .Cases("macos", "macosx", "darwin", "macos")
 .Cases("unknown", "", "unknown")
// These values are also supported, but are handled by the default case below:
// .Case ("ios", "ios")
// .Case ("tvos", "tvos")
// .Case ("watchos", "watchos")
 .Default(tripleOSNameNoVersion);
}

static std::optional<StringRef>
getEnvironmentForAppleTargetSpecificModuleTriple(const llvm::Triple &triple) {
auto tripleEnvironment = triple.getEnvironmentName();
return llvm::StringSwitch<std::optional<StringRef>>(tripleEnvironment)
 .Cases("unknown", "", std::nullopt)
// These values are also supported, but are handled by the default case
// below:
// .Case ("simulator", StringRef("simulator"))
// .Case ("macabi", StringRef("macabi"))
 .Default(tripleEnvironment);
}

llvm::Triple swift::getTargetSpecificModuleTriple(const llvm::Triple &triple) {
// isOSDarwin() returns true for all Darwin-style OSes, including macOS, iOS,
// etc.
if (triple.isOSDarwin()) {
 StringRef newArch = getArchForAppleTargetSpecificModuleTriple(triple);

 StringRef newVendor = getVendorForAppleTargetSpecificModuleTriple(triple);

 StringRef newOS = getOSForAppleTargetSpecificModuleTriple(triple);

 std::optional<StringRef> newEnvironment =
getEnvironmentForAppleTargetSpecificModuleTriple(triple);

if (!newEnvironment)
// Generate an arch-vendor-os triple.
returnllvm::Triple(newArch, newVendor, newOS);

// Generate an arch-vendor-os-environment triple.
returnllvm::Triple(newArch, newVendor, newOS, *newEnvironment);
 }

// android - drop the API level. That is not pertinent to the module; the API
// availability is handled by the clang importer.
if (triple.isAndroid()) {
 StringRef environment =
llvm::Triple::getEnvironmentTypeName(triple.getEnvironment());

returnllvm::Triple(triple.getArchName(), triple.getVendorName(),
 triple.getOSName(), environment);
 }

if (triple.isOSFreeBSD()) {
returnswift::getUnversionedTriple(triple);
 }

if (triple.isOSOpenBSD()) {
 StringRef arch = swift::getMajorArchitectureName(triple);
returnllvm::Triple(arch, triple.getVendorName(), triple.getOSName());
 }

// Other platforms get no normalization.
return triple;
}

llvm::Triple swift::getUnversionedTriple(const llvm::Triple &triple) {
 StringRef unversionedOSName = triple.getOSName().take_until(llvm::isDigit);
if (triple.getEnvironment()) {
 StringRef environment =
llvm::Triple::getEnvironmentTypeName(triple.getEnvironment());

returnllvm::Triple(triple.getArchName(), triple.getVendorName(),
 unversionedOSName, environment);
 }

returnllvm::Triple(triple.getArchName(), triple.getVendorName(),
 unversionedOSName);
}

namespace {

// Here, we statically reflect the entire contents of RuntimeVersions.def
// into the template-argument structure of the type AllStaticSwiftReleases.
// We then use template metaprogramming on this type to synthesize arrays
// of PlatformSwiftRelease for each of the target platforms with
// deployment restrictions. This would be much simpler with the recent
// generalizations of constexpr and non-type template parameters, but
// those remain above our baseline for now, so we have to do this the
// old way.

/// A specific release of a platform that provides a specific Swift
/// runtime version. Ultimately, all the variadic goop below is just
/// building an array of these for each platform, which is what we'll
/// use at runtime.
structPlatformSwiftRelease {
 llvm::VersionTuple swiftVersion;
 llvm::VersionTuple platformVersion;
};

/// A deployment-restricted platform.
enumclassPlatformKind {
 macOS,
 iOS,
 watchOS,
 visionOS
};

/// A template which statically reflects a version tuple. Generalized
/// template parameters would theoretically let us just use
/// llvm::VersionTuple.
template <unsigned... Components>
structStaticVersion;

/// A template which statically reflects a single PLATFORM in
/// RuntimeVersions.def.
template <PlatformKind Kind, classVersion>
structStaticPlatformRelease;

/// A template which statically reflects a single RUNTIME_VERSION in
/// RuntimeVersions.def.
template <classSwiftVersion, classPlatformReleases>
structStaticSwiftRelease;

/// In the assumed context of a particular platform, the release
/// of the platform that first provided a particular Swift version.
template <classSwiftVersion, classPlatformVersion>
structStaticPlatformSwiftRelease;

// C++ does not allow template argument lists to have trailing commas,
// so to make the macro metaprogramming side of this work, we have to
// include an extra type here (and special-case it in the transforms
// below) for the sole purpose of terminating the list without a comma.
structTerminal;

#defineUNPARENTHESIZE(...) __VA_ARGS__

using AllStaticSwiftReleases =
 packs::Pack<
#definePLATFORM(NAME, VERSION) \
 StaticPlatformRelease< \
 PlatformKind::NAME, \
 StaticVersion<UNPARENTHESIZE VERSION> \
 >,
#defineFUTURE
#defineRUNTIME_VERSION(SWIFT_TUPLE, PROVIDERS) \
 StaticSwiftRelease<StaticVersion<UNPARENTHESIZE SWIFT_TUPLE>, \
 packs::Pack<PROVIDERS Terminal>>,
#include"swift/AST/RuntimeVersions.def"
 Terminal
 >;

#undef UNPARENTHESIZE

/// A template for comparing two StaticVersion type values.
template <classA, classB>
structStaticVersionGT;
// 0.0 is not strictly greater than any version.
template <classSecond>
structStaticVersionGT<
 StaticVersion<>,
 Second
 > {
staticconstexprbool value = false;
};
// A version is strictly greater than 0.0 if it has any nonzero component.
template <unsigned FirstHead, unsigned... FirstTail>
structStaticVersionGT<
 StaticVersion<FirstHead, FirstTail...>,
 StaticVersion<>
 > {
staticconstexprbool value =
 (FirstHead > 0) ? true :
 StaticVersionGT<StaticVersion<FirstTail...>,
 StaticVersion<>>::value;
};
// a.b is strictly greater than c.d if (a > c || (a == c && b > d)).
template <unsigned FirstHead, unsigned... FirstTail,
unsigned SecondHead, unsigned... SecondTail>
structStaticVersionGT<
 StaticVersion<FirstHead, FirstTail...>,
 StaticVersion<SecondHead, SecondTail...>
 > {
staticconstexprbool value =
 (FirstHead > SecondHead) ? true :
 (FirstHead < SecondHead) ? false :
 StaticVersionGT<StaticVersion<FirstTail...>,
 StaticVersion<SecondTail...>>::value;
};

/// A template for turning a StaticVersion into an llvm::VersionTuple.
template <class>
structBuildVersionTuple;

template <unsigned... Components>
structBuildVersionTuple<StaticVersion<Components...>> {
staticconstexpr llvm::VersionTuple get() {
returnllvm::VersionTuple(Components...);
 }
};

/// A transform that takes a StaticPlatformRelease, checks if it
/// matches the given platform, and turns it into a
/// StaticPlatformSwiftRelease if so. The result is returned as an
/// optional pack which will be empty if the release is for a different
/// platform.
template <class, class>
structBuildStaticPlatformSwiftReleaseHelper;
template <PlatformKind Platform, classSwiftVersion>
structBuildStaticPlatformSwiftReleaseHelper_Arg;

// Matching case.
template <PlatformKind Platform, classSwiftVersion, classPlatformVersion>
structBuildStaticPlatformSwiftReleaseHelper<
 BuildStaticPlatformSwiftReleaseHelper_Arg<Platform, SwiftVersion>,
 StaticPlatformRelease<Platform, PlatformVersion>> {
using result = packs::Pack<
 StaticPlatformSwiftRelease<SwiftVersion, PlatformVersion>
 >;
};

// Non-matching case.
template <PlatformKind Platform, classSwiftVersion,
 PlatformKind OtherPlatform, classPlatformVersion>
structBuildStaticPlatformSwiftReleaseHelper<
 BuildStaticPlatformSwiftReleaseHelper_Arg<Platform, SwiftVersion>,
 StaticPlatformRelease<OtherPlatform, PlatformVersion>> {
using result = packs::Pack<>;
};

// Terminal case (see above).
template <PlatformKind Platform, classSwiftVersion>
structBuildStaticPlatformSwiftReleaseHelper<
 BuildStaticPlatformSwiftReleaseHelper_Arg<Platform, SwiftVersion>,
 Terminal> {
using result = packs::Pack<>;
};


/// A transform that takes a StaticSwiftRelease, finds the platform
/// release in it that matches the given platform, and turns it into
/// StaticPlatformSwiftRelease. The result is returned as an optional
/// pack which will be empty if there is no release for the given
/// platform in this SSR.
template <class, class>
structBuildStaticPlatformSwiftRelease;
template <PlatformKind Platform>
structBuildStaticPlatformSwiftRelease_Arg;

// Main case: destructure the arguments, then flat-map our helper
// transform above. Note that we assume that there aren't multiple
// entries for the same platform in the platform releases of a given
// Swift release.
template <PlatformKind Platform, classSwiftVersion,
classStaticPlatformReleases>
structBuildStaticPlatformSwiftRelease<
 BuildStaticPlatformSwiftRelease_Arg<Platform>,
 StaticSwiftRelease<SwiftVersion, StaticPlatformReleases>>
 : packs::PackFlatMap<
 BuildStaticPlatformSwiftReleaseHelper,
 BuildStaticPlatformSwiftReleaseHelper_Arg<Platform, SwiftVersion>,
 StaticPlatformReleases> {};

// Terminal case (see above).
template <PlatformKind Platform>
structBuildStaticPlatformSwiftRelease<
 BuildStaticPlatformSwiftRelease_Arg<Platform>,
 Terminal> {
using result = packs::Pack<>;
};

/// A template for generating a PlatformSwiftRelease array element
/// from a StaticPlatformSwiftRelease type value.
template <class>
structBuildPlatformSwiftRelease;

template <classSwiftVersion, classPlatformVersion>
structBuildPlatformSwiftRelease<
 StaticPlatformSwiftRelease<SwiftVersion, PlatformVersion>
 > {
staticconstexpr PlatformSwiftRelease get() {
return { BuildVersionTuple<SwiftVersion>::get(),
 BuildVersionTuple<PlatformVersion>::get() };
 }
};

/// A template for comparing two StaticPlatformSwiftRelease type values,
/// for the purposes of a well-ordered assertion we want to make:
/// We don't call this GT because it's not really a general-purpose
/// comparison.
template <class, class>
structStaticPlatformSwiftReleaseStrictlyDescend;

template <classFirstSwift, classFirstPlatform,
classSecondSwift, classSecondPlatform>
structStaticPlatformSwiftReleaseStrictlyDescend<
 StaticPlatformSwiftRelease<FirstSwift, FirstPlatform>,
 StaticPlatformSwiftRelease<SecondSwift, SecondPlatform>
 > {
staticconstexprbool value =
 StaticVersionGT<FirstSwift, SecondSwift>::value &&
 StaticVersionGT<FirstPlatform, SecondPlatform>::value;
};

/// A helper template for BuildPlatformSwiftReleaseArray, below.
template <classP>
structBuildPlatformSwiftReleaseArrayHelper;

template <class... StaticPlatformSwiftReleases>
structBuildPlatformSwiftReleaseArrayHelper<
 packs::Pack<StaticPlatformSwiftReleases...>
 > {
// After we reverse the entries, we expect them to strictly
// descend in both the Swift version and the platform version.
static_assert(packs::PackComponentsAreOrdered<
 StaticPlatformSwiftReleaseStrictlyDescend,
 StaticPlatformSwiftReleases...
 >::value,
"RuntimeVersions.def is not properly ordered?");
staticconstexpr PlatformSwiftRelease releases[] = {
 BuildPlatformSwiftRelease<StaticPlatformSwiftReleases>::get()...
 };
};

/// Build a static constexpr array of PlatformRelease objects matching
/// the given platform.
template <PlatformKind Platform>
structBuildPlatformSwiftReleaseArray
 : BuildPlatformSwiftReleaseArrayHelper<
// Turn each entry in AllStaticSwiftReleases into an optional
// StaticPlatformSwiftRelease representing whether there is a
// platform release providing that Swift release for the given
// platform. Flatten that pack, then reverse it so that it's in
// order of descending release versions. Finally, build an array
// of PlatformRelease objects for the remaining values.
typename packs::PackReverse<
typename packs::PackFlatMap<
 BuildStaticPlatformSwiftRelease,
 BuildStaticPlatformSwiftRelease_Arg<Platform>,
 AllStaticSwiftReleases
 >::result
 >::result
 > {};

} // end anonymous namespace

static std::optional<llvm::VersionTuple>
findSwiftRuntimeVersionHelper(llvm::VersionTuple targetPlatformVersion,
 llvm::VersionTuple minimumSwiftVersion,
 ArrayRef<PlatformSwiftRelease> allReleases) {
 #defineMAX(a, b) ((a) > (b) ? (a) : (b))

// Scan forward in our filtered platform release array for the given
// platform.
for (auto &release : allReleases) {
// If the provider version is <= the deployment target, then
// the deployment target includes support for the given Swift
// release. Since we're scanning in reverse order of Swift
// releases (because of the order of entries in RuntimeVersions.def),
// this must be the highest supported Swift release.
if (release.platformVersion <= targetPlatformVersion) {
returnstd::max(release.swiftVersion, minimumSwiftVersion);
 }
 }

// If we didn't find anything, but the target release is at least the
// notional future-release version, return that we aren't
// deployment-limited.
if (targetPlatformVersion >= llvm::VersionTuple(99, 99))
return std::nullopt;

// Otherwise, return the minimum Swift version.
return minimumSwiftVersion;
}

/// Return the highest Swift release that matches the given platform and
/// has a version no greater than the target version. Don't return a version
/// older that the minimum. Returns null if the target version matches the
/// notional future release version.
template <PlatformKind TargetPlatform>
static std::optional<llvm::VersionTuple>
findSwiftRuntimeVersion(llvm::VersionTuple targetPlatformVersion,
 llvm::VersionTuple minimumSwiftVersion) {
auto &allReleases =
 BuildPlatformSwiftReleaseArray<TargetPlatform>::releases;

returnfindSwiftRuntimeVersionHelper(targetPlatformVersion,
 minimumSwiftVersion,
 allReleases);
}

std::optional<llvm::VersionTuple>
swift::getSwiftRuntimeCompatibilityVersionForTarget(
const llvm::Triple &Triple) {

if (Triple.isMacOSX()) {
 llvm::VersionTuple OSVersion;
 Triple.getMacOSXVersion(OSVersion);

// macOS releases predate the stable ABI, so use Swift 5.0 as our base.
auto baseRelease = llvm::VersionTuple(5, 0);

// macOS got its first arm64(e) support in 11.0, which included Swift 5.3.
if (Triple.isAArch64())
 baseRelease = llvm::VersionTuple(5, 3);

return findSwiftRuntimeVersion<PlatformKind::macOS>(OSVersion, baseRelease);

 } elseif (Triple.isiOS()) { // includes tvOS
 llvm::VersionTuple OSVersion = Triple.getiOSVersion();

// iOS releases predate the stable ABI, so use Swift 5.0 as our base.
auto baseRelease = llvm::VersionTuple(5, 0);

// arm64 simulators and macCatalyst were introduced in iOS 14.0/tvOS 14.0,
// which included Swift 5.3.
if (Triple.isAArch64() &&
 (Triple.isSimulatorEnvironment() ||
 Triple.isMacCatalystEnvironment()))
 baseRelease = llvm::VersionTuple(5, 3);

// iOS first got arm64e support in 12.0, which did not yet support the
// Swift stable ABI, so it does not provide a useful version bump.

return findSwiftRuntimeVersion<PlatformKind::iOS>(OSVersion, baseRelease);

 } elseif (Triple.isWatchOS()) {
 llvm::VersionTuple OSVersion = Triple.getWatchOSVersion();

// watchOS releases predate the stable ABI, so use Swift 5.0 as our base.
auto baseRelease = llvm::VersionTuple(5, 0);

// 64-bit watchOS was first supported by watchOS 7, which provided
// Swift 5.3.
if (Triple.isArch64Bit())
 baseRelease = llvm::VersionTuple(5, 3);

return findSwiftRuntimeVersion<PlatformKind::watchOS>(OSVersion, baseRelease);

 } elseif (Triple.isXROS()) {
 llvm::VersionTuple OSVersion = Triple.getOSVersion();

// visionOS 1.0 provided Swift 5.9.
auto baseRelease = llvm::VersionTuple(5, 9);

return findSwiftRuntimeVersion<PlatformKind::visionOS>(OSVersion, baseRelease);
 }

return std::nullopt;
}

staticconst llvm::VersionTuple minimumMacCatalystDeploymentTarget() {
returnllvm::VersionTuple(13, 1);
}

llvm::VersionTuple swift::getTargetSDKVersion(clang::DarwinSDKInfo &SDKInfo,
const llvm::Triple &triple) {
// Retrieve the SDK version.
auto SDKVersion = SDKInfo.getVersion();

// For the Mac Catalyst environment, we have a macOS SDK with a macOS
// SDK version. Map that to the corresponding iOS version number to pass
// down to the linker.
if (tripleIsMacCatalystEnvironment(triple)) {
if (constauto *MacOStoMacCatalystMapping = SDKInfo.getVersionMapping(
clang::DarwinSDKInfo::OSEnvPair::macOStoMacCatalystPair())) {
return MacOStoMacCatalystMapping
 ->map(SDKVersion, minimumMacCatalystDeploymentTarget(), std::nullopt)
 .value_or(llvm::VersionTuple(0, 0, 0));
 }
returnllvm::VersionTuple(0, 0, 0);
 }

return SDKVersion;
}

static std::string getPlistEntry(const llvm::Twine &Path, StringRef KeyName) {
auto BufOrErr = llvm::MemoryBuffer::getFile(Path);
if (!BufOrErr) {
// FIXME: diagnose properly
return {};
 }

 std::string Key = "<key>";
 Key += KeyName;
 Key += "</key>";

 StringRef Lines = BufOrErr.get()->getBuffer();
while (!Lines.empty()) {
 StringRef CurLine;
std::tie(CurLine, Lines) = Lines.split('\n');
if (CurLine.find(Key) != StringRef::npos) {
std::tie(CurLine, Lines) = Lines.split('\n');
unsigned Begin = CurLine.find("<string>") + strlen("<string>");
unsigned End = CurLine.find("</string>");
return CurLine.substr(Begin, End - Begin).str();
 }
 }

return {};
}

std::string swift::getSDKBuildVersionFromPlist(StringRef Path) {
returngetPlistEntry(Path, "ProductBuildVersion");
}

std::string swift::getSDKBuildVersion(StringRef Path) {
returngetSDKBuildVersionFromPlist((llvm::Twine(Path) +
"/System/Library/CoreServices/SystemVersion.plist").str());
}

std::string swift::getSDKName(StringRef Path) {
 std::string Name = getPlistEntry(llvm::Twine(Path)+"/SDKSettings.plist",
"CanonicalName");
if (Name.empty() && Path.ends_with(".sdk")) {
 Name = llvm::sys::path::filename(Path).drop_back(strlen(".sdk")).str();
 }
return Name;
}