DarwinSDKInfo.cpp

Go to the documentation of this file.

//===--- 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 "llvm/TargetParser/ARMTargetParser.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
legacyPlatformInfos(llvm::Triple::OSType SDKOS,
                    llvm::Triple::EnvironmentType SDKEnvironment) {
  DarwinSDKInfo::PlatformInfoStorageType PlatformInfos;
  // Synthesize platform infos for older SDKs from the first SDKs with
  // SupportedTargets: macOS 10.15 (DriverKit 19.0), iOS 13.0, tvOS 13.0,
  // watchOS 6.0. Older macOS SDKs supported ppc and i386 architectures, and
  // maybe ppc64. Support for those is difficult to identify from the SDK, and
  // so aren't listed here. Other older SDKs (especially iOS) most likely
  // supported armv6 and armv7 architectures that aren't listed here either.
  switch (SDKOS) {
  case llvm::Triple::MacOSX:
    PlatformInfos.push_back({{llvm::Triple("x86_64-apple-macosx")}, ""});
    // macOS 10.15 also has a Mac Catalyst supported target, but Mac Catalyst
    // was new in that version so omit it for older versions.
    break;
  case llvm::Triple::DriverKit:
    // DriverKit 19.0 only had SDKSettings.plist, which isn't used. So this code
    // path is used in 19.x as well, not just earlier versions.
    PlatformInfos.push_back(
        {{llvm::Triple("x86_64-apple-driverkit")}, "/System/DriverKit"});
    break;
  case llvm::Triple::IOS:
    switch (SDKEnvironment) {
    case llvm::Triple::UnknownEnvironment:
      PlatformInfos.push_back(
          {{llvm::Triple("armv7-apple-ios"), llvm::Triple("armv7s-apple-ios"),
            llvm::Triple("arm64-apple-ios")},
           ""});
      break;
    case llvm::Triple::Simulator:
      PlatformInfos.push_back(
          {{llvm::Triple("x86_64-apple-ios-simulator")}, ""});
      break;
    default:
      break;
    }
    break;
  case llvm::Triple::TvOS:
    switch (SDKEnvironment) {
    case llvm::Triple::UnknownEnvironment:
      PlatformInfos.push_back({{llvm::Triple("arm64-apple-tvos")}, ""});
      break;
    case llvm::Triple::Simulator:
      PlatformInfos.push_back(
          {{llvm::Triple("x86_64-apple-tvos-simulator")}, ""});
      break;
    default:
      break;
    }
    break;
  case llvm::Triple::WatchOS:
    switch (SDKEnvironment) {
    case llvm::Triple::UnknownEnvironment:
      PlatformInfos.push_back({{llvm::Triple("armv7k-apple-watchos"),
                                llvm::Triple("arm64_32-apple-watchos")},
                               ""});
      break;
    case llvm::Triple::Simulator:
      PlatformInfos.push_back(
          {{llvm::Triple("x86_64-apple-watchos-simulator")}, ""});
      break;
    default:
      break;
    }
    break;
  case llvm::Triple::BridgeOS:
    PlatformInfos.push_back({{llvm::Triple("armv7-apple-bridgeos"),
                              llvm::Triple("armv7s-apple-bridgeos"),
                              llvm::Triple("arm64-apple-bridgeos")},
                             ""});
    break;
  default:
    break;
  }
  return PlatformInfos;
}
 
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)
    return legacyPlatformInfos(SDKOS, SDKEnvironment);
 
  for (const auto &SupportedTargetPair : *SupportedTargets) {
    const llvm::json::Object *SupportedTarget =
        SupportedTargetPair.getSecond().getAsObject();
    if (!SupportedTarget)
      continue;
 
    auto Archs = SupportedTarget->getArray("Archs");
    auto Vendor = SupportedTarget->getString("LLVMTargetTripleVendor");
    auto OS = SupportedTarget->getString("LLVMTargetTripleSys");
    if (!Archs || !Vendor || !OS)
      continue;
 
    DarwinSDKInfo::SDKPlatformInfo::TripleStorageType Triples;
    auto Environment =
        SupportedTarget->getString("LLVMTargetTripleEnvironment");
    for (const auto &ArchValue : *Archs) {
      if (auto Arch = ArchValue.getAsString()) {
        if (Environment && !Environment->empty())
          Triples.emplace_back(*Arch, *Vendor, *OS, *Environment);
        else
          Triples.emplace_back(*Arch, *Vendor, *OS);
      }
    }
    if (Triples.empty())
      continue;
 
    // 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 ((Triples[0].getOS() == llvm::Triple::DriverKit) &&
            (Version < VersionTuple(22, 1)))
          EffectivePlatformPrefix = "/System/DriverKit";
      }
    }
 
    if (PlatformOrVariant == XcodePlatform)
      PlatformInfos.insert(PlatformInfos.begin(),
                           {std::move(Triples), EffectivePlatformPrefix});
    else
      PlatformInfos.emplace_back(std::move(Triples), EffectivePlatformPrefix);
  }
  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);
  if (PlatformInfos.empty())
    return std::nullopt;
  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());
}
 
DarwinSDKInfo::DarwinSDKInfo(llvm::Triple::OSType OS,
                             llvm::Triple::EnvironmentType Environment,
                             VersionTuple Version, StringRef DisplayName,
                             VersionTuple MaximumDeploymentTarget)
    : DarwinSDKInfo("", OS, Environment, Version, DisplayName,
                    MaximumDeploymentTarget,
                    legacyPlatformInfos(OS, Environment)) {}
 
static DarwinSDKInfo::PlatformInfoStorageType::const_iterator
findPlatformInfo(const DarwinSDKInfo::PlatformInfoStorageType &PlatformInfos,
                 const llvm::Triple &Triple) {
  auto PlatformInfoIt = llvm::find_if(
      PlatformInfos,
      [&Triple](const DarwinSDKInfo::SDKPlatformInfo &PlatformInfo) {
        const auto &Triples = PlatformInfo.getTriples();
        return llvm::find(Triples, Triple) != Triples.end();
      });
 
  // The SDK specifies values for Xcode to use for the -target argument. It's
  // hard to perfectly match the triple passed to this function against those
  // values though. The passed in triple might have been computed from just
  // -arch, or it might have been modified by -march and several other arguments
  // that can effect any of the triple components. It's not really possible to
  // account for all of the triple variations, but one common modification is
  // that "arm" gets changed to "thumb". If the passed in triple is "thumb", try
  // mapping it back to an "arm" triple since that's what the SDK will specify.
  if (PlatformInfoIt == PlatformInfos.end() &&
      Triple.getArch() == llvm::Triple::thumb) {
    StringRef ARMArch = llvm::Triple::getArchName(llvm::Triple::arm);
 
    // Preserve the sub-arch from the triple.
    llvm::ARM::ArchKind ArchKind = llvm::ARM::parseArch(Triple.getArchName());
    StringRef SubArch = llvm::ARM::getSubArch(ArchKind);
 
    llvm::Triple ARMTriple(Triple);
    ARMTriple.setArchName((ARMArch + SubArch).str());
    if (ARMTriple.getArch() != llvm::Triple::thumb) {
      // Sometimes changing the architecture name in the triple doesn't change
      // its parsed architecture. e.g. armv6m parses as thumb, so it won't help
      // to search for armv6m if thumbv6m already failed.
      PlatformInfoIt = findPlatformInfo(PlatformInfos, ARMTriple);
    }
  }
 
  return PlatformInfoIt;
}
 
bool DarwinSDKInfo::supportsTriple(const llvm::Triple &Triple) const {
  return findPlatformInfo(PlatformInfos, Triple) != PlatformInfos.end();
}
 
StringRef DarwinSDKInfo::getPlatformPrefix(const llvm::Triple &Triple) const {
  auto PlatformInfoIt = findPlatformInfo(PlatformInfos, Triple);
  if (PlatformInfoIt != PlatformInfos.end())
    return PlatformInfoIt->getPlatformPrefix();
 
  // This triple probably isn't supported by the SDK. However, almost every SDK
  // just has a single prefix where all of its contents are, so return that.
  StringRef PlatformPrefix = PlatformInfos[0].getPlatformPrefix();
  for (PlatformInfoIt = std::next(PlatformInfos.begin());
       PlatformInfoIt != PlatformInfos.end(); ++PlatformInfoIt) {
    if (PlatformInfoIt->getPlatformPrefix() != PlatformPrefix) {
      // This SDK has multiple prefixes, give up and return nothing.
      return StringRef();
    }
  }
  return PlatformPrefix;
}