[clang][darwin] add support for version remapping to the Darwin SDK Info class

[arphaman]

Summary

This patch is a pre-commit for https://reviews.llvm.org/D105257. It adds support for the macOS -> Mac Catalyst version mapping to the Darwin SDK Info class, alongside appropriate unit tests.

[arphaman]

fix typo

[arphaman]

This patch depends on a small NFC commit that moves DarwinSDKInfo over to lib/Basic from lib/Driver, which isn't up on phabricator.

[dexonsmith]

Thanks for splitting this out! It mostly looks good, just a few things inline.

clang/lib/Basic/DarwinSDKInfo.cpp

27–28

Your answer (https://reviews.llvm.org/D105257#inline-1007563) to @aaron.ballman's comment in the original patch was informative: this check is to avoid infinite recursion. That wasn't obvious to me either though. Might you add something to the comment for the benefit of other readers?

118

Nit: I'd suggest skipping the "in the next commit" part.

Instead, I'd suggest documenting in the commit message why this wasn't done here:

• This patch adds/tests new low-level functionality.
• Future commit will adopt it in parseDarwinSDKInfo and actually change the driver/frontend/whatever.

clang/unittests/Basic/DarwinSDKinfoTest.cpp

36–50

Can you add a couple of comments saying what the EXPECTs are testing? (Maybe not each one individually, but at least groups by what they're testing (maybe exists, fallback to major, infinite loop, big minimum value, etc., but in full sentences)).

Should there be a test that passes both minimum and maximum values?

[arphaman]

Addressed review comments.

[dexonsmith]

LGTM!

clang/include/clang/Basic/DarwinSDKInfo.h

 //===--- DarwinSDKInfo.h - SDK Information parser for darwin ----*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_BASIC_DARWIN_SDK_INFO_H
 #define LLVM_CLANG_BASIC_DARWIN_SDK_INFO_H
 
 #include "clang/Basic/LLVM.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/Triple.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/VersionTuple.h"
 #include "llvm/Support/VirtualFileSystem.h"
 
+namespace llvm {
+namespace json {
+class Object;
+} // end namespace json
+} // end namespace llvm
+
 namespace clang {
 
 /// The information about the darwin SDK that was used during this compilation.
 class DarwinSDKInfo {
 public:
-  DarwinSDKInfo(llvm::VersionTuple Version) : Version(Version) {}
+  /// A value that describes two os-environment pairs that can be used as a key
+  /// to the version map in the SDK.
+  struct OSEnvPair {
+  public:
+    using StorageType = uint64_t;
+
+    constexpr OSEnvPair(llvm::Triple::OSType FromOS,
+                        llvm::Triple::EnvironmentType FromEnv,
+                        llvm::Triple::OSType ToOS,
+                        llvm::Triple::EnvironmentType ToEnv)
+        : Value(((StorageType(FromOS) * StorageType(llvm::Triple::LastOSType) +
+                  StorageType(FromEnv))
+                 << 32ull) |
+                (StorageType(ToOS) * StorageType(llvm::Triple::LastOSType) +
+                 StorageType(ToEnv))) {}
+
+    /// Returns the os-environment mapping pair that's used to represent the
+    /// macOS -> Mac Catalyst version mapping.
+    static inline constexpr OSEnvPair macOStoMacCatalystPair() {
+      return OSEnvPair(llvm::Triple::MacOSX, llvm::Triple::UnknownEnvironment,
+                       llvm::Triple::IOS, llvm::Triple::MacABI);
+    }
+
+  private:
+    StorageType Value;
+
+    friend class DarwinSDKInfo;
+  };
+
+  /// Represents a version mapping that maps from a version of one target to a
+  /// version of a related target.
+  ///
+  /// e.g. "macOS_iOSMac":{"10.15":"13.1"} is an example of a macOS -> Mac
+  /// Catalyst version map.
+  class RelatedTargetVersionMapping {
+  public:
+    RelatedTargetVersionMapping(
+        VersionTuple MinimumKeyVersion, VersionTuple MaximumKeyVersion,
+        VersionTuple MinimumValue, VersionTuple MaximumValue,
+        llvm::DenseMap<VersionTuple, VersionTuple> Mapping)
+        : MinimumKeyVersion(MinimumKeyVersion),
+          MaximumKeyVersion(MaximumKeyVersion), MinimumValue(MinimumValue),
+          MaximumValue(MaximumValue), Mapping(Mapping) {
+      assert(!this->Mapping.empty() && "unexpected empty mapping");
+    }
+
+    /// Returns the value with the lowest version in the mapping.
+    const VersionTuple &getMinimumValue() const { return MinimumValue; }
+
+    /// Returns the mapped key, or the appropriate Minimum / MaximumValue if
+    /// they key is outside of the mapping bounds. If they key isn't mapped, but
+    /// within the minimum and maximum bounds, None is returned.
+    Optional<VersionTuple> map(const VersionTuple &Key,
+                               const VersionTuple &MinimumValue,
+                               Optional<VersionTuple> MaximumValue) const;
+
+    static Optional<RelatedTargetVersionMapping>
+    parseJSON(const llvm::json::Object &Obj,
+              VersionTuple MaximumDeploymentTarget);
+
+  private:
+    VersionTuple MinimumKeyVersion;
+    VersionTuple MaximumKeyVersion;
+    VersionTuple MinimumValue;
+    VersionTuple MaximumValue;
+    llvm::DenseMap<VersionTuple, VersionTuple> Mapping;
+  };
+
+  DarwinSDKInfo(VersionTuple Version, VersionTuple MaximumDeploymentTarget,
+                llvm::DenseMap<OSEnvPair::StorageType,
+                               Optional<RelatedTargetVersionMapping>>
+                    VersionMappings =
+                        llvm::DenseMap<OSEnvPair::StorageType,
+                                       Optional<RelatedTargetVersionMapping>>())
+      : Version(Version), MaximumDeploymentTarget(MaximumDeploymentTarget),
+        VersionMappings(std::move(VersionMappings)) {}
 
   const llvm::VersionTuple &getVersion() const { return Version; }
 
+  // Returns the optional, target-specific version mapping that maps from one
+  // target to another target.
+  //
+  // This mapping is constructed from an appropriate mapping in the SDKSettings,
+  // for instance, when building for Mac Catalyst, the mapping would contain the
+  // "macOS_iOSMac" mapping as it maps the macOS versions to the Mac Catalyst
+  // versions.
+  //
+  // This mapping does not exist when the target doesn't have an appropriate
+  // related version mapping, or when there was an error reading the mapping
+  // from the SDKSettings, or when it's missing in the SDKSettings.
+  const RelatedTargetVersionMapping *getVersionMapping(OSEnvPair Kind) const {
+    auto Mapping = VersionMappings.find(Kind.Value);
+    if (Mapping == VersionMappings.end())
+      return nullptr;
+    return Mapping->getSecond().hasValue() ? Mapping->getSecond().getPointer()
+                                           : nullptr;
+  }
+
+  static Optional<DarwinSDKInfo>
+  parseDarwinSDKSettingsJSON(const llvm::json::Object *Obj);
+
 private:
-  llvm::VersionTuple Version;
+  VersionTuple Version;
+  VersionTuple MaximumDeploymentTarget;
+  // Need to wrap the value in an optional here as the value has to be default
+  // constructible, and std::unique_ptr doesn't like DarwinSDKInfo being
+  // Optional as Optional is trying to copy it in emplace.
+  llvm::DenseMap<OSEnvPair::StorageType, Optional<RelatedTargetVersionMapping>>
+      VersionMappings;
 };
 
 /// Parse the SDK information from the SDKSettings.json file.
 ///
 /// \returns an error if the SDKSettings.json file is invalid, None if the
 /// SDK has no SDKSettings.json, or a valid \c DarwinSDKInfo otherwise.
 Expected<Optional<DarwinSDKInfo>> parseDarwinSDKInfo(llvm::vfs::FileSystem &VFS,
                                                      StringRef SDKRootPath);
 
 } // end namespace clang
 
 #endif // LLVM_CLANG_BASIC_DARWIN_SDK_INFO_H

clang/lib/Basic/DarwinSDKInfo.cpp

 //===--- 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/Support/ErrorOr.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 
 using namespace clang;
 
+Optional<VersionTuple> DarwinSDKInfo::RelatedTargetVersionMapping::map(
+    const VersionTuple &Key, const VersionTuple &MinimumValue,
+    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 None for a missing entry.
+  return None;
+}
+
+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 None;
+      Mapping[KeyVersion.normalize()] = ValueVersion;
+      if (KeyVersion < Min)
+        Min = KeyVersion;
+      if (KeyVersion > Max)
+        Max = KeyVersion;
+      if (ValueVersion < MinValue)
+        MinValue = ValueVersion;
+    }
+  }
+  if (Mapping.empty())
+    return None;
+  return RelatedTargetVersionMapping(
+      Min, Max, MinValue, MaximumDeploymentTarget, std::move(Mapping));
+}
+
+static Optional<VersionTuple> getVersionKey(const llvm::json::Object &Obj,
+                                            StringRef Key) {
+  auto Value = Obj.getString(Key);
+  if (!Value)
+    return None;
+  VersionTuple Version;
+  if (Version.tryParse(*Value))
+    return None;
+  return Version;
+}
+
+Optional<DarwinSDKInfo>
+DarwinSDKInfo::parseDarwinSDKSettingsJSON(const llvm::json::Object *Obj) {
+  auto Version = getVersionKey(*Obj, "Version");
+  if (!Version)
+    return None;
+  auto MaximumDeploymentVersion =
+      getVersionKey(*Obj, "MaximumDeploymentTarget");
+  if (!MaximumDeploymentVersion)
+    return None;
+  llvm::DenseMap<OSEnvPair::StorageType, Optional<RelatedTargetVersionMapping>>
+      VersionMappings;
+  if (const auto *VM = Obj->getObject("VersionMap")) {
+    if (const auto *Mapping = VM->getObject("macOS_iOSMac")) {
+      auto VersionMap = RelatedTargetVersionMapping::parseJSON(
+          *Mapping, *MaximumDeploymentVersion);
+      if (!VersionMap)
+        return None;
+      VersionMappings[OSEnvPair::macOStoMacCatalystPair().Value] =
+          std::move(VersionMap);
+    }
+  }
+
+  return DarwinSDKInfo(std::move(*Version),
+                       std::move(*MaximumDeploymentVersion),
+                       std::move(VersionMappings));
+}
+
 Expected<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 None;
   }
   Expected<llvm::json::Value> Result =
       llvm::json::parse(File.get()->getBuffer());
   if (!Result)
     return Result.takeError();
 
   if (const auto *Obj = Result->getAsObject()) {
+    // FIXME: Switch to use parseDarwinSDKSettingsJSON.
     auto VersionString = Obj->getString("Version");
     if (VersionString) {
       VersionTuple Version;
       if (!Version.tryParse(*VersionString))
-        return DarwinSDKInfo(Version);
+        return DarwinSDKInfo(Version, Version);
     }
   }
   return llvm::make_error<llvm::StringError>("invalid SDKSettings.json",
                                              llvm::inconvertibleErrorCode());
 }

clang/lib/Driver/ToolChains/Darwin.cpp

struct DarwinPlatform {
   /// the SDK path itself. Only works for values that were created by inferring
   /// the platform from the SDKPath.
   DarwinSDKInfo inferSDKInfo() {
     assert(Kind == InferredFromSDK && "can infer SDK info only");
     llvm::VersionTuple Version;
     bool IsValid = !Version.tryParse(OSVersion);
     (void)IsValid;
     assert(IsValid && "invalid SDK version");
-    return DarwinSDKInfo(Version);
+    return DarwinSDKInfo(
+        Version,
+        /*MaximumDeploymentTarget=*/VersionTuple(Version.getMajor(), 0, 99));
   }
 
 private:
   DarwinPlatform(SourceKind Kind, DarwinPlatformKind Platform, Arg *Argument)
       : Kind(Kind), Platform(Platform), Argument(Argument) {}
   DarwinPlatform(SourceKind Kind, DarwinPlatformKind Platform, StringRef Value,
                  Arg *Argument = nullptr)
       : Kind(Kind), Platform(Platform), OSVersion(Value), Argument(Argument) {}

clang/unittests/Basic/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Support
   )
 
 add_clang_unittest(BasicTests
   CharInfoTest.cpp
+  DarwinSDKInfoTest.cpp
   DiagnosticTest.cpp
   FileEntryTest.cpp
   FileManagerTest.cpp
   LineOffsetMappingTest.cpp
   SanitizersTest.cpp
   SourceManagerTest.cpp
   )
 
 clang_target_link_libraries(BasicTests
   PRIVATE
   clangAST
   clangBasic
   clangLex
   )

clang/unittests/Basic/DarwinSDKinfoTest.cpp

+//===- unittests/Basic/DarwinSDKInfoTest.cpp -- SDKSettings.json test -----===//
+//
+// 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/Support/JSON.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+using namespace clang;
+
+TEST(DarwinSDKInfoTest, ParseAndTestMapping) {
+  llvm::json::Object Obj;
+  Obj["Version"] = "11.0";
+  Obj["MaximumDeploymentTarget"] = "11.99";
+  llvm::json::Object VersionMap;
+  VersionMap["10.15"] = "13.1";
+  VersionMap["11.0"] = "14.0";
+  VersionMap["11.2"] = "14.2";
+  llvm::json::Object MacOS2iOSMac;
+  MacOS2iOSMac["macOS_iOSMac"] = std::move(VersionMap);
+  Obj["VersionMap"] = std::move(MacOS2iOSMac);
+
+  auto SDKInfo = DarwinSDKInfo::parseDarwinSDKSettingsJSON(&Obj);
+  ASSERT_TRUE(SDKInfo);
+  EXPECT_EQ(SDKInfo->getVersion(), VersionTuple(11, 0));
+
+  auto Mapping = SDKInfo->getVersionMapping(
+      DarwinSDKInfo::OSEnvPair::macOStoMacCatalystPair());
+  ASSERT_TRUE(Mapping);
+  // Verify that the macOS versions that are present in the map are translated
+  // directly to their corresponding Mac Catalyst versions.
+  EXPECT_EQ(*Mapping->map(VersionTuple(10, 15), VersionTuple(), None),
+            VersionTuple(13, 1));
+  EXPECT_EQ(*Mapping->map(VersionTuple(11, 0), VersionTuple(), None),
+            VersionTuple(14, 0));
+  EXPECT_EQ(*Mapping->map(VersionTuple(11, 2), VersionTuple(), None),
+            VersionTuple(14, 2));
+
+  // Verify that a macOS version that's not present in the map is translated
+  // like the nearest major OS version.
+  EXPECT_EQ(*Mapping->map(VersionTuple(11, 1), VersionTuple(), None),
+            VersionTuple(14, 0));
+
+  // Verify that the macOS versions that are outside of the mapped version
+  // range map to the min/max values passed to the `map` call.
+  EXPECT_EQ(*Mapping->map(VersionTuple(10, 14), VersionTuple(99, 99), None),
+            VersionTuple(99, 99));
+  EXPECT_EQ(
+      *Mapping->map(VersionTuple(11, 5), VersionTuple(), VersionTuple(99, 99)),
+      VersionTuple(99, 99));
+  EXPECT_EQ(*Mapping->map(VersionTuple(11, 5), VersionTuple(99, 98),
+                          VersionTuple(99, 99)),
+            VersionTuple(99, 99));
+}
+
+TEST(DarwinSDKInfoTest, MissingKeys) {
+  llvm::json::Object Obj;
+  ASSERT_FALSE(DarwinSDKInfo::parseDarwinSDKSettingsJSON(&Obj));
+  Obj["Version"] = "11.0";
+  ASSERT_FALSE(DarwinSDKInfo::parseDarwinSDKSettingsJSON(&Obj));
+}

llvm/include/llvm/Support/VersionTuple.h

 //===- VersionTuple.h - Version Number Handling -----------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// Defines the llvm::VersionTuple class, which represents a version in
 /// the form major[.minor[.subminor]].
 ///
 //===----------------------------------------------------------------------===//
 #ifndef LLVM_SUPPORT_VERSIONTUPLE_H
 #define LLVM_SUPPORT_VERSIONTUPLE_H
 
+#include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/Optional.h"
 #include <string>
 #include <tuple>
 
 namespace llvm {
 class raw_ostream;
 class StringRef;
public:
 
   /// Return a version tuple that contains only the first 3 version components.
   VersionTuple withoutBuild() const {
     if (HasBuild)
       return VersionTuple(Major, Minor, Subminor);
     return *this;
   }
 
+  /// Return a version tuple that contains only components that are non-zero.
+  VersionTuple normalize() const {
+    VersionTuple Result = *this;
+    if (Result.Build == 0) {
+      Result.HasBuild = false;
+      if (Result.Subminor == 0) {
+        Result.HasSubminor = false;
+        if (Result.Minor == 0)
+          Result.HasMinor = false;
+      }
+    }
+    return Result;
+  }
+
   /// Determine if two version numbers are equivalent. If not
   /// provided, minor and subminor version numbers are considered to be zero.
   friend bool operator==(const VersionTuple &X, const VersionTuple &Y) {
     return X.Major == Y.Major && X.Minor == Y.Minor &&
            X.Subminor == Y.Subminor && X.Build == Y.Build;
   }
 
   /// Determine if two version numbers are not equivalent.
public:
   /// \returns \c true if the string does not match the regular expression
   ///   [0-9]+(\.[0-9]+){0,3}
   bool tryParse(StringRef string);
 };
 
 /// Print a version number.
 raw_ostream &operator<<(raw_ostream &Out, const VersionTuple &V);
 
+// Provide DenseMapInfo for version tuples.
+template <> struct DenseMapInfo<VersionTuple> {
+  static inline VersionTuple getEmptyKey() { return VersionTuple(0x7FFFFFFF); }
+  static inline VersionTuple getTombstoneKey() {
+    return VersionTuple(0x7FFFFFFE);
+  }
+  static unsigned getHashValue(const VersionTuple &Value) {
+    unsigned Result = Value.getMajor();
+    if (auto Minor = Value.getMinor())
+      Result = detail::combineHashValue(Result, *Minor);
+    if (auto Subminor = Value.getSubminor())
+      Result = detail::combineHashValue(Result, *Subminor);
+    if (auto Build = Value.getBuild())
+      Result = detail::combineHashValue(Result, *Build);
+
+    return Result;
+  }
+
+  static bool isEqual(const VersionTuple &LHS, const VersionTuple &RHS) {
+    return LHS == RHS;
+  }
+};
+
 } // end namespace llvm
 #endif // LLVM_SUPPORT_VERSIONTUPLE_H