| //===--- DarwinSDKInfo.cpp - SDK Information parser for darwin - ----------===// | |
| // | |
| // 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 | |
| // | |
| //===----------------------------------------------------------------------===// | |
| #include "clang/Basic/DarwinSDKInfo.h" | |
| #include "llvm/ADT/StringSwitch.h" | |
| #include "llvm/Support/ErrorOr.h" | |
| #include "llvm/Support/JSON.h" | |
| #include "llvm/Support/MemoryBuffer.h" | |
| #include "llvm/Support/Path.h" | |
| #include <optional> | |
| using namespace clang; | |
| std::optional<VersionTuple> DarwinSDKInfo::RelatedTargetVersionMapping::map( | |
| const VersionTuple &Key, const VersionTuple &MinimumValue, | |
| std::optional<VersionTuple> MaximumValue) const { | |
| if (Key < MinimumKeyVersion) | |
| return MinimumValue; | |
| if (Key > MaximumKeyVersion) | |
| return MaximumValue; | |
| auto KV = Mapping.find(Key.normalize()); | |
| if (KV != Mapping.end()) | |
| return KV->getSecond(); | |
| // If no exact entry found, try just the major key version. Only do so when | |
| // a minor version number is present, to avoid recursing indefinitely into | |
| // the major-only check. | |
| if (Key.getMinor()) | |
| return map(VersionTuple(Key.getMajor()), MinimumValue, MaximumValue); | |
| // If this a major only key, return std::nullopt for a missing entry. | |
| return std::nullopt; | |
| } | |
| std::optional<DarwinSDKInfo::RelatedTargetVersionMapping> | |
| DarwinSDKInfo::RelatedTargetVersionMapping::parseJSON( | |
| const llvm::json::Object &Obj, VersionTuple MaximumDeploymentTarget) { | |
| VersionTuple Min = VersionTuple(std::numeric_limits<unsigned>::max()); | |
| VersionTuple Max = VersionTuple(0); | |
| VersionTuple MinValue = Min; | |
| llvm::DenseMap<VersionTuple, VersionTuple> Mapping; | |
| for (const auto &KV : Obj) { | |
| if (auto Val = KV.getSecond().getAsString()) { | |
| llvm::VersionTuple KeyVersion; | |
| llvm::VersionTuple ValueVersion; | |
| if (KeyVersion.tryParse(KV.getFirst()) || ValueVersion.tryParse(*Val)) | |
| return std::nullopt; | |
| Mapping[KeyVersion.normalize()] = ValueVersion; | |
| if (KeyVersion < Min) | |
| Min = KeyVersion; | |
| if (KeyVersion > Max) | |
| Max = KeyVersion; | |
| if (ValueVersion < MinValue) | |
| MinValue = ValueVersion; | |
| } | |
| } | |
| if (Mapping.empty()) | |
| return std::nullopt; | |
| return RelatedTargetVersionMapping( | |
| Min, Max, MinValue, MaximumDeploymentTarget, std::move(Mapping)); | |
| } | |
| static std::optional<StringRef> | |
| parseXcodePlatform(const llvm::json::Object &Obj) { | |
| // The CanonicalName is the Xcode platform followed by a version, e.g. | |
| // macosx15.0. | |
| auto CanonicalName = Obj.getString("CanonicalName"); | |
| if (!CanonicalName) | |
| return std::nullopt; | |
| size_t VersionStart = CanonicalName->find_first_of("0123456789"); | |
| return CanonicalName->slice(0, VersionStart); | |
| } | |
| static std::pair<llvm::Triple::OSType, llvm::Triple::EnvironmentType> | |
| parseOSAndEnvironment(std::optional<StringRef> XcodePlatform) { | |
| if (!XcodePlatform) | |
| return {llvm::Triple::UnknownOS, llvm::Triple::UnknownEnvironment}; | |
| llvm::Triple::OSType OS = | |
| llvm::StringSwitch<llvm::Triple::OSType>(*XcodePlatform) | |
| .Case("macosx", llvm::Triple::MacOSX) | |
| .Cases({"iphoneos", "iphonesimulator"}, llvm::Triple::IOS) | |
| .Cases({"appletvos", "appletvsimulator"}, llvm::Triple::TvOS) | |
| .Cases({"watchos", "watchsimulator"}, llvm::Triple::WatchOS) | |
| .Case("bridgeos", llvm::Triple::BridgeOS) | |
| .Cases({"xros", "xrsimulator"}, llvm::Triple::XROS) | |
| .Case("driverkit", llvm::Triple::DriverKit) | |
| .Default(llvm::Triple::UnknownOS); | |
| llvm::Triple::EnvironmentType Environment = | |
| llvm::StringSwitch<llvm::Triple::EnvironmentType>(*XcodePlatform) | |
| .Cases({"iphonesimulator", "appletvsimulator", "watchsimulator", | |
| "xrsimulator"}, | |
| llvm::Triple::Simulator) | |
| .Default(llvm::Triple::UnknownEnvironment); | |
| return {OS, Environment}; | |
| } | |
| static DarwinSDKInfo::PlatformInfoStorageType parsePlatformInfos( | |
| const llvm::json::Object &Obj, std::optional<StringRef> XcodePlatform, | |
| llvm::Triple::OSType SDKOS, llvm::Triple::EnvironmentType SDKEnvironment, | |
| VersionTuple Version) { | |
| DarwinSDKInfo::PlatformInfoStorageType PlatformInfos; | |
| auto SupportedTargets = Obj.getObject("SupportedTargets"); | |
| if (!SupportedTargets) { | |
| // For older SDKs that don't have SupportedTargets, infer one from the SDK's | |
| // OS/Environment. | |
| StringRef PlatformPrefix; | |
| if (SDKOS == llvm::Triple::DriverKit) | |
| PlatformPrefix = "/System/DriverKit"; | |
| PlatformInfos.push_back({llvm::Triple::Apple, SDKOS, SDKEnvironment, | |
| llvm::Triple::MachO, PlatformPrefix}); | |
| return PlatformInfos; | |
| } | |
| for (auto SupportedTargetPair : *SupportedTargets) { | |
| llvm::json::Object *SupportedTarget = | |
| SupportedTargetPair.getSecond().getAsObject(); | |
| auto Vendor = SupportedTarget->getString("LLVMTargetTripleVendor"); | |
| auto OS = SupportedTarget->getString("LLVMTargetTripleSys"); | |
| if (!Vendor || !OS) | |
| continue; | |
| StringRef Arch = llvm::Triple::getArchName(llvm::Triple::UnknownArch); | |
| auto Environment = | |
| SupportedTarget->getString("LLVMTargetTripleEnvironment"); | |
| llvm::Triple Triple; | |
| if (Environment) | |
| Triple = llvm::Triple(Arch, *Vendor, *OS, *Environment); | |
| else | |
| Triple = llvm::Triple(Arch, *Vendor, *OS); | |
| // The key is either the Xcode platform, or a variant. The platform must be | |
| // the first entry in the returned PlatformInfoStorageType. | |
| StringRef PlatformOrVariant = SupportedTargetPair.getFirst(); | |
| StringRef EffectivePlatformPrefix; | |
| // Ignore iosmac value if it exists. | |
| if ((PlatformOrVariant != "iosmac") || (Version >= VersionTuple(99))) { | |
| auto PlatformPrefix = SupportedTarget->getString("SystemPrefix"); | |
| if (PlatformPrefix) { | |
| EffectivePlatformPrefix = *PlatformPrefix; | |
| } else { | |
| // Older SDKs don't have SystemPrefix in SupportedTargets, manually add | |
| // their prefixes. | |
| if ((Triple.getOS() == llvm::Triple::DriverKit) && | |
| (Version < VersionTuple(22, 1))) | |
| EffectivePlatformPrefix = "/System/DriverKit"; | |
| } | |
| } | |
| DarwinSDKInfo::SDKPlatformInfo PlatformInfo( | |
| Triple.getVendor(), Triple.getOS(), Triple.getEnvironment(), | |
| Triple.getObjectFormat(), EffectivePlatformPrefix); | |
| if (PlatformOrVariant == XcodePlatform) | |
| PlatformInfos.insert(PlatformInfos.begin(), PlatformInfo); | |
| else | |
| PlatformInfos.push_back(PlatformInfo); | |
| } | |
| return PlatformInfos; | |
| } | |
| static std::optional<VersionTuple> getVersionKey(const llvm::json::Object &Obj, | |
| StringRef Key) { | |
| auto Value = Obj.getString(Key); | |
| if (!Value) | |
| return std::nullopt; | |
| VersionTuple Version; | |
| if (Version.tryParse(*Value)) | |
| return std::nullopt; | |
| return Version; | |
| } | |
| std::optional<DarwinSDKInfo> | |
| DarwinSDKInfo::parseDarwinSDKSettingsJSON(std::string FilePath, | |
| const llvm::json::Object *Obj) { | |
| auto Version = getVersionKey(*Obj, "Version"); | |
| if (!Version) | |
| return std::nullopt; | |
| auto MaximumDeploymentVersion = | |
| getVersionKey(*Obj, "MaximumDeploymentTarget"); | |
| if (!MaximumDeploymentVersion) | |
| return std::nullopt; | |
| std::optional<StringRef> XcodePlatform = parseXcodePlatform(*Obj); | |
| std::pair<llvm::Triple::OSType, llvm::Triple::EnvironmentType> | |
| OSAndEnvironment = parseOSAndEnvironment(XcodePlatform); | |
| // DisplayName should always be present, but don't require it. | |
| StringRef DisplayName = | |
| Obj->getString("DisplayName") | |
| .value_or(Obj->getString("CanonicalName").value_or("<unknown>")); | |
| PlatformInfoStorageType PlatformInfos = | |
| parsePlatformInfos(*Obj, XcodePlatform, OSAndEnvironment.first, | |
| OSAndEnvironment.second, *Version); | |
| llvm::DenseMap<OSEnvPair::StorageType, | |
| std::optional<RelatedTargetVersionMapping>> | |
| VersionMappings; | |
| if (const auto *VM = Obj->getObject("VersionMap")) { | |
| // FIXME: Generalize this out beyond iOS-deriving targets. | |
| // Look for ios_<targetos> version mapping for targets that derive from ios. | |
| for (const auto &KV : *VM) { | |
| auto Pair = StringRef(KV.getFirst()).split("_"); | |
| if (Pair.first.compare_insensitive("ios") == 0) { | |
| llvm::Triple TT(llvm::Twine("--") + Pair.second.lower()); | |
| if (TT.getOS() != llvm::Triple::UnknownOS) { | |
| auto Mapping = RelatedTargetVersionMapping::parseJSON( | |
| *KV.getSecond().getAsObject(), *MaximumDeploymentVersion); | |
| if (Mapping) | |
| VersionMappings[OSEnvPair(llvm::Triple::IOS, | |
| llvm::Triple::UnknownEnvironment, | |
| TT.getOS(), | |
| llvm::Triple::UnknownEnvironment) | |
| .Value] = std::move(Mapping); | |
| } | |
| } | |
| } | |
| if (const auto *Mapping = VM->getObject("macOS_iOSMac")) { | |
| auto VersionMap = RelatedTargetVersionMapping::parseJSON( | |
| *Mapping, *MaximumDeploymentVersion); | |
| if (!VersionMap) | |
| return std::nullopt; | |
| VersionMappings[OSEnvPair::macOStoMacCatalystPair().Value] = | |
| std::move(VersionMap); | |
| } | |
| if (const auto *Mapping = VM->getObject("iOSMac_macOS")) { | |
| auto VersionMap = RelatedTargetVersionMapping::parseJSON( | |
| *Mapping, *MaximumDeploymentVersion); | |
| if (!VersionMap) | |
| return std::nullopt; | |
| VersionMappings[OSEnvPair::macCatalystToMacOSPair().Value] = | |
| std::move(VersionMap); | |
| } | |
| } | |
| return DarwinSDKInfo(std::move(FilePath), OSAndEnvironment.first, | |
| OSAndEnvironment.second, std::move(*Version), | |
| DisplayName, std::move(*MaximumDeploymentVersion), | |
| std::move(PlatformInfos), std::move(VersionMappings)); | |
| } | |
| Expected<std::optional<DarwinSDKInfo>> | |
| clang::parseDarwinSDKInfo(llvm::vfs::FileSystem &VFS, StringRef SDKRootPath) { | |
| llvm::SmallString<256> Filepath = SDKRootPath; | |
| llvm::sys::path::append(Filepath, "SDKSettings.json"); | |
| llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> File = | |
| VFS.getBufferForFile(Filepath); | |
| if (!File) { | |
| // If the file couldn't be read, assume it just doesn't exist. | |
| return std::nullopt; | |
| } | |
| Expected<llvm::json::Value> Result = | |
| llvm::json::parse(File.get()->getBuffer()); | |
| if (!Result) | |
| return Result.takeError(); | |
| if (const auto *Obj = Result->getAsObject()) { | |
| if (auto SDKInfo = DarwinSDKInfo::parseDarwinSDKSettingsJSON( | |
| Filepath.str().str(), Obj)) | |
| return std::move(SDKInfo); | |
| } | |
| return llvm::make_error<llvm::StringError>("invalid SDKSettings.json", | |
| llvm::inconvertibleErrorCode()); | |
| } |