clang/lib/Basic/DarwinSDKInfo.cpp

   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/Support/ErrorOr.h"
  11 #include "llvm/Support/JSON.h"
  12 #include "llvm/Support/MemoryBuffer.h"
  13 #include "llvm/Support/Path.h"
  14 #include <optional>
  15
  16 using namespace clang;
  17
  18 std::optional<VersionTuple> DarwinSDKInfo::RelatedTargetVersionMapping::map(
  19     const VersionTuple &Key, const VersionTuple &MinimumValue,
  20     std::optional<VersionTuple> MaximumValue) const {
  21   if (Key < MinimumKeyVersion)
  22     return MinimumValue;
  23   if (Key > MaximumKeyVersion)
  24     return MaximumValue;
  25   auto KV = Mapping.find(Key.normalize());
  26   if (KV != Mapping.end())
  27     return KV->getSecond();
  28   // If no exact entry found, try just the major key version. Only do so when
  29   // a minor version number is present, to avoid recursing indefinitely into
  30   // the major-only check.
  31   if (Key.getMinor())
  32     return map(VersionTuple(Key.getMajor()), MinimumValue, MaximumValue);
  33   // If this a major only key, return std::nullopt for a missing entry.
  34   return std::nullopt;
  35 }
  36
  37 std::optional<DarwinSDKInfo::RelatedTargetVersionMapping>
  38 DarwinSDKInfo::RelatedTargetVersionMapping::parseJSON(
  39     const llvm::json::Object &Obj, VersionTuple MaximumDeploymentTarget) {
  40   VersionTuple Min = VersionTuple(std::numeric_limits<unsigned>::max());
  41   VersionTuple Max = VersionTuple(0);
  42   VersionTuple MinValue = Min;
  43   llvm::DenseMap<VersionTuple, VersionTuple> Mapping;
  44   for (const auto &KV : Obj) {
  45     if (auto Val = KV.getSecond().getAsString()) {
  46       llvm::VersionTuple KeyVersion;
  47       llvm::VersionTuple ValueVersion;
  48       if (KeyVersion.tryParse(KV.getFirst()) || ValueVersion.tryParse(*Val))
  49         return std::nullopt;
  50       Mapping[KeyVersion.normalize()] = ValueVersion;
  51       if (KeyVersion < Min)
  52         Min = KeyVersion;
  53       if (KeyVersion > Max)
  54         Max = KeyVersion;
  55       if (ValueVersion < MinValue)
  56         MinValue = ValueVersion;
  57     }
  58   }
  59   if (Mapping.empty())
  60     return std::nullopt;
  61   return RelatedTargetVersionMapping(
  62       Min, Max, MinValue, MaximumDeploymentTarget, std::move(Mapping));
  63 }
  64
  65 static std::optional<VersionTuple> getVersionKey(const llvm::json::Object &Obj,
  66                                                  StringRef Key) {
  67   auto Value = Obj.getString(Key);
  68   if (!Value)
  69     return std::nullopt;
  70   VersionTuple Version;
  71   if (Version.tryParse(*Value))
  72     return std::nullopt;
  73   return Version;
  74 }
  75
  76 std::optional<DarwinSDKInfo>
  77 DarwinSDKInfo::parseDarwinSDKSettingsJSON(const llvm::json::Object *Obj) {
  78   auto Version = getVersionKey(*Obj, "Version");
  79   if (!Version)
  80     return std::nullopt;
  81   auto MaximumDeploymentVersion =
  82       getVersionKey(*Obj, "MaximumDeploymentTarget");
  83   if (!MaximumDeploymentVersion)
  84     return std::nullopt;
  85   llvm::DenseMap<OSEnvPair::StorageType,
  86                  std::optional<RelatedTargetVersionMapping>>
  87       VersionMappings;
  88   if (const auto *VM = Obj->getObject("VersionMap")) {
  89     // FIXME: Generalize this out beyond iOS-deriving targets.
  90     // Look for ios_<targetos> version mapping for targets that derive from ios.
  91     for (const auto &KV : *VM) {
  92       auto Pair = StringRef(KV.getFirst()).split("_");
  93       if (Pair.first.compare_insensitive("ios") == 0) {
  94         llvm::Triple TT(llvm::Twine("--") + Pair.second.lower());
  95         if (TT.getOS() != llvm::Triple::UnknownOS) {
  96           auto Mapping = RelatedTargetVersionMapping::parseJSON(
  97               *KV.getSecond().getAsObject(), *MaximumDeploymentVersion);
  98           if (Mapping)
  99             VersionMappings[OSEnvPair(llvm::Triple::IOS,
 100                                       llvm::Triple::UnknownEnvironment,
 101                                       TT.getOS(),
 102                                       llvm::Triple::UnknownEnvironment)
 103                                 .Value] = std::move(Mapping);
 104         }
 105       }
 106     }
 107
 108     if (const auto *Mapping = VM->getObject("macOS_iOSMac")) {
 109       auto VersionMap = RelatedTargetVersionMapping::parseJSON(
 110           *Mapping, *MaximumDeploymentVersion);
 111       if (!VersionMap)
 112         return std::nullopt;
 113       VersionMappings[OSEnvPair::macOStoMacCatalystPair().Value] =
 114           std::move(VersionMap);
 115     }
 116     if (const auto *Mapping = VM->getObject("iOSMac_macOS")) {
 117       auto VersionMap = RelatedTargetVersionMapping::parseJSON(
 118           *Mapping, *MaximumDeploymentVersion);
 119       if (!VersionMap)
 120         return std::nullopt;
 121       VersionMappings[OSEnvPair::macCatalystToMacOSPair().Value] =
 122           std::move(VersionMap);
 123     }
 124   }
 125
 126   return DarwinSDKInfo(std::move(*Version),
 127                        std::move(*MaximumDeploymentVersion),
 128                        std::move(VersionMappings));
 129 }
 130
 131 Expected<std::optional<DarwinSDKInfo>>
 132 clang::parseDarwinSDKInfo(llvm::vfs::FileSystem &VFS, StringRef SDKRootPath) {
 133   llvm::SmallString<256> Filepath = SDKRootPath;
 134   llvm::sys::path::append(Filepath, "SDKSettings.json");
 135   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> File =
 136       VFS.getBufferForFile(Filepath);
 137   if (!File) {
 138     // If the file couldn't be read, assume it just doesn't exist.
 139     return std::nullopt;
 140   }
 141   Expected<llvm::json::Value> Result =
 142       llvm::json::parse(File.get()->getBuffer());
 143   if (!Result)
 144     return Result.takeError();
 145
 146   if (const auto *Obj = Result->getAsObject()) {
 147     if (auto SDKInfo = DarwinSDKInfo::parseDarwinSDKSettingsJSON(Obj))
 148       return std::move(SDKInfo);
 149   }
 150   return llvm::make_error<llvm::StringError>("invalid SDKSettings.json",
 151                                              llvm::inconvertibleErrorCode());
 152 }