1//===--- DarwinSDKInfo.cpp - SDK Information parser for darwin - ----------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "clang/Basic/DarwinSDKInfo.h"
10#include "llvm/ADT/StringSwitch.h"
11#include "llvm/Support/ErrorOr.h"
12#include "llvm/Support/JSON.h"
13#include "llvm/Support/MemoryBuffer.h"
14#include "llvm/Support/Path.h"
15#include <optional>
16
17using namespace clang;
18
19std::optional<VersionTuple> DarwinSDKInfo::RelatedTargetVersionMapping::map(
20 const VersionTuple &Key, const VersionTuple &MinimumValue,
21 std::optional<VersionTuple> MaximumValue) const {
22 if (Key < MinimumKeyVersion)
23 return MinimumValue;
24 if (Key > MaximumKeyVersion)
25 return MaximumValue;
26 auto KV = Mapping.find(Val: Key.normalize());
27 if (KV != Mapping.end())
28 return KV->getSecond();
29 // If no exact entry found, try just the major key version. Only do so when
30 // a minor version number is present, to avoid recursing indefinitely into
31 // the major-only check.
32 if (Key.getMinor())
33 return map(Key: VersionTuple(Key.getMajor()), MinimumValue, MaximumValue);
34 // If this a major only key, return std::nullopt for a missing entry.
35 return std::nullopt;
36}
37
38std::optional<DarwinSDKInfo::RelatedTargetVersionMapping>
39DarwinSDKInfo::RelatedTargetVersionMapping::parseJSON(
40 const llvm::json::Object &Obj, VersionTuple MaximumDeploymentTarget) {
41 VersionTuple Min = VersionTuple(std::numeric_limits<unsigned>::max());
42 VersionTuple Max = VersionTuple(0);
43 VersionTuple MinValue = Min;
44 llvm::DenseMap<VersionTuple, VersionTuple> Mapping;
45 for (const auto &KV : Obj) {
46 if (auto Val = KV.getSecond().getAsString()) {
47 llvm::VersionTuple KeyVersion;
48 llvm::VersionTuple ValueVersion;
49 if (KeyVersion.tryParse(string: KV.getFirst()) || ValueVersion.tryParse(string: *Val))
50 return std::nullopt;
51 Mapping[KeyVersion.normalize()] = ValueVersion;
52 if (KeyVersion < Min)
53 Min = KeyVersion;
54 if (KeyVersion > Max)
55 Max = KeyVersion;
56 if (ValueVersion < MinValue)
57 MinValue = ValueVersion;
58 }
59 }
60 if (Mapping.empty())
61 return std::nullopt;
62 return RelatedTargetVersionMapping(
63 Min, Max, MinValue, MaximumDeploymentTarget, std::move(Mapping));
64}
65
66static llvm::Triple::OSType parseOS(const llvm::json::Object &Obj) {
67 // The CanonicalName is the Xcode platform followed by a version, e.g.
68 // macosx16.0.
69 auto CanonicalName = Obj.getString(K: "CanonicalName");
70 if (!CanonicalName)
71 return llvm::Triple::UnknownOS;
72 size_t VersionStart = CanonicalName->find_first_of(Chars: "0123456789");
73 StringRef XcodePlatform = CanonicalName->slice(Start: 0, End: VersionStart);
74 return llvm::StringSwitch<llvm::Triple::OSType>(XcodePlatform)
75 .Case(S: "macosx", Value: llvm::Triple::MacOSX)
76 .Case(S: "iphoneos", Value: llvm::Triple::IOS)
77 .Case(S: "iphonesimulator", Value: llvm::Triple::IOS)
78 .Case(S: "appletvos", Value: llvm::Triple::TvOS)
79 .Case(S: "appletvsimulator", Value: llvm::Triple::TvOS)
80 .Case(S: "watchos", Value: llvm::Triple::WatchOS)
81 .Case(S: "watchsimulator", Value: llvm::Triple::WatchOS)
82 .Case(S: "xros", Value: llvm::Triple::XROS)
83 .Case(S: "xrsimulator", Value: llvm::Triple::XROS)
84 .Case(S: "driverkit", Value: llvm::Triple::DriverKit)
85 .Default(Value: llvm::Triple::UnknownOS);
86}
87
88static std::optional<VersionTuple> getVersionKey(const llvm::json::Object &Obj,
89 StringRef Key) {
90 auto Value = Obj.getString(K: Key);
91 if (!Value)
92 return std::nullopt;
93 VersionTuple Version;
94 if (Version.tryParse(string: *Value))
95 return std::nullopt;
96 return Version;
97}
98
99std::optional<DarwinSDKInfo>
100DarwinSDKInfo::parseDarwinSDKSettingsJSON(const llvm::json::Object *Obj) {
101 auto Version = getVersionKey(Obj: *Obj, Key: "Version");
102 if (!Version)
103 return std::nullopt;
104 auto MaximumDeploymentVersion =
105 getVersionKey(Obj: *Obj, Key: "MaximumDeploymentTarget");
106 if (!MaximumDeploymentVersion)
107 return std::nullopt;
108 llvm::Triple::OSType OS = parseOS(Obj: *Obj);
109 llvm::DenseMap<OSEnvPair::StorageType,
110 std::optional<RelatedTargetVersionMapping>>
111 VersionMappings;
112 if (const auto *VM = Obj->getObject(K: "VersionMap")) {
113 // FIXME: Generalize this out beyond iOS-deriving targets.
114 // Look for ios_<targetos> version mapping for targets that derive from ios.
115 for (const auto &KV : *VM) {
116 auto Pair = StringRef(KV.getFirst()).split(Separator: "_");
117 if (Pair.first.compare_insensitive(RHS: "ios") == 0) {
118 llvm::Triple TT(llvm::Twine("--") + Pair.second.lower());
119 if (TT.getOS() != llvm::Triple::UnknownOS) {
120 auto Mapping = RelatedTargetVersionMapping::parseJSON(
121 Obj: *KV.getSecond().getAsObject(), MaximumDeploymentTarget: *MaximumDeploymentVersion);
122 if (Mapping)
123 VersionMappings[OSEnvPair(llvm::Triple::IOS,
124 llvm::Triple::UnknownEnvironment,
125 TT.getOS(),
126 llvm::Triple::UnknownEnvironment)
127 .Value] = std::move(Mapping);
128 }
129 }
130 }
131
132 if (const auto *Mapping = VM->getObject(K: "macOS_iOSMac")) {
133 auto VersionMap = RelatedTargetVersionMapping::parseJSON(
134 Obj: *Mapping, MaximumDeploymentTarget: *MaximumDeploymentVersion);
135 if (!VersionMap)
136 return std::nullopt;
137 VersionMappings[OSEnvPair::macOStoMacCatalystPair().Value] =
138 std::move(VersionMap);
139 }
140 if (const auto *Mapping = VM->getObject(K: "iOSMac_macOS")) {
141 auto VersionMap = RelatedTargetVersionMapping::parseJSON(
142 Obj: *Mapping, MaximumDeploymentTarget: *MaximumDeploymentVersion);
143 if (!VersionMap)
144 return std::nullopt;
145 VersionMappings[OSEnvPair::macCatalystToMacOSPair().Value] =
146 std::move(VersionMap);
147 }
148 }
149
150 return DarwinSDKInfo(std::move(*Version),
151 std::move(*MaximumDeploymentVersion), OS,
152 std::move(VersionMappings));
153}
154
155Expected<std::optional<DarwinSDKInfo>>
156clang::parseDarwinSDKInfo(llvm::vfs::FileSystem &VFS, StringRef SDKRootPath) {
157 llvm::SmallString<256> Filepath = SDKRootPath;
158 llvm::sys::path::append(path&: Filepath, a: "SDKSettings.json");
159 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> File =
160 VFS.getBufferForFile(Name: Filepath);
161 if (!File) {
162 // If the file couldn't be read, assume it just doesn't exist.
163 return std::nullopt;
164 }
165 Expected<llvm::json::Value> Result =
166 llvm::json::parse(JSON: File.get()->getBuffer());
167 if (!Result)
168 return Result.takeError();
169
170 if (const auto *Obj = Result->getAsObject()) {
171 if (auto SDKInfo = DarwinSDKInfo::parseDarwinSDKSettingsJSON(Obj))
172 return std::move(SDKInfo);
173 }
174 return llvm::make_error<llvm::StringError>(Args: "invalid SDKSettings.json",
175 Args: llvm::inconvertibleErrorCode());
176}
177