[Compatibility53] Add compatibility library for 5.3 and backport tuple Equatable conformance

Fix some comments

Unnecessary cast

Author: Azoy

include/swift/Frontend/BackDeploymentLibs.def

@@ -26,6 +26,7 @@
 
 BACK_DEPLOYMENT_LIB((5, 0), all, "swiftCompatibility50")
 BACK_DEPLOYMENT_LIB((5, 1), all, "swiftCompatibility51")
+BACK_DEPLOYMENT_LIB((5, 3), all, "swiftCompatibility53")
 BACK_DEPLOYMENT_LIB((5, 0), executable, "swiftCompatibilityDynamicReplacements")
 
 #undef BACK_DEPLOYMENT_LIB

lib/Basic/Platform.cpp

@@ -378,8 +378,10 @@ swift::getSwiftRuntimeCompatibilityVersionForTarget(
       } else if (Minor <= 15) {
         if (Micro <= 3) {
           return llvm::VersionTuple(5, 1);
-        } else {
+        } else if (Micro <= 4) {
           return llvm::VersionTuple(5, 2);
+        } else {
+          return llvm::VersionTuple(5, 3);
         }
       }
     } else if (Major == 11) {
@@ -399,8 +401,10 @@ swift::getSwiftRuntimeCompatibilityVersionForTarget(
     } else if (Major <= 13) {
       if (Minor <= 3) {
         return llvm::VersionTuple(5, 1);
-      } else {
+      } else if (Minor <= 4) {
         return llvm::VersionTuple(5, 2);
+      } else {
+        return llvm::VersionTuple(5, 3);
       }
     }
   } else if (Triple.isWatchOS()) {
@@ -410,8 +414,10 @@ swift::getSwiftRuntimeCompatibilityVersionForTarget(
     } else if (Major <= 6) {
       if (Minor <= 1) {
         return llvm::VersionTuple(5, 1);
-      } else {
+      } else if (Minor <= 2) {
         return llvm::VersionTuple(5, 2);
+      } else {
+        return llvm::VersionTuple(5, 3);
       }
     }
   }

lib/Driver/DarwinToolChains.cpp

@@ -378,19 +378,18 @@ toolchains::Darwin::addArgsToLinkStdlib(ArgStringList &Arguments,
   // have an older Swift runtime.
   SmallString<128> SharedResourceDirPath;
   getResourceDirPath(SharedResourceDirPath, context.Args, /*Shared=*/true);
-  Optional<llvm::VersionTuple> runtimeCompatibilityVersion;
+  Optional<llvm::VersionTuple> runtimeCompatibilityVersion 
+      = llvm::VersionTuple();
 
   if (context.Args.hasArg(options::OPT_runtime_compatibility_version)) {
     auto value = context.Args.getLastArgValue(
                                     options::OPT_runtime_compatibility_version);
-    if (value.equals("5.0")) {
-      runtimeCompatibilityVersion = llvm::VersionTuple(5, 0);
-    } else if (value.equals("5.1")) {
-      runtimeCompatibilityVersion = llvm::VersionTuple(5, 1);
-    } else if (value.equals("none")) {
-      runtimeCompatibilityVersion = None;
-    } else {
-      // TODO: diagnose unknown runtime compatibility version?
+    if (runtimeCompatibilityVersion->tryParse(value)) {
+      if (value.equals("none")) {
+        runtimeCompatibilityVersion = None;
+      } else {
+        // TODO: diagnose unknown runtime compatibility version?
+      }
     }
   } else if (job.getKind() == LinkKind::Executable) {
     runtimeCompatibilityVersion

lib/Frontend/CompilerInvocation.cpp

@@ -1598,6 +1598,8 @@ static bool ParseIRGenArgs(IRGenOptions &Opts, ArgList &Args,
         runtimeCompatibilityVersion = llvm::VersionTuple(5, 0);
       } else if (version.equals("5.1")) {
         runtimeCompatibilityVersion = llvm::VersionTuple(5, 1);
+      } else if (version.equals("5.3")) {
+        runtimeCompatibilityVersion = llvm::VersionTuple(5, 3);
       } else {
         Diags.diagnose(SourceLoc(), diag::error_invalid_arg_value,
                        versionArg->getAsString(Args), version);

stdlib/toolchain/CMakeLists.txt

@@ -53,4 +53,5 @@ set(COMPATIBILITY_MINIMUM_DEPLOYMENT_VERSION_WATCHOS "2.0")
 add_subdirectory(legacy_layouts)
 add_subdirectory(Compatibility50)
 add_subdirectory(Compatibility51)
+add_subdirectory(Compatibility53)
 add_subdirectory(CompatibilityDynamicReplacements)

stdlib/toolchain/Compatibility50/ProtocolConformance.cpp

@@ -18,6 +18,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "Overrides.h"
+#include "../Compatibility53/Overrides.h"
 #include "../../public/runtime/Private.h"
 #include "swift/Basic/Lazy.h"
 #include <dlfcn.h>
@@ -94,6 +95,13 @@ swift::swift50override_conformsToProtocol(const Metadata *type,
   static OnceToken_t token;
   SWIFT_ONCE_F(token, registerAddImageCallback, nullptr);
 
+  // The Swift 5.4 runtime added support for builtin conformances. Call 5.3's
+  // backported implementation to handle that here.
+  if (auto result =
+        swift53override_conformsToProtocol(type, protocol,
+                                           original_conformsToProtocol))
+    return result;
+
   // The implementation of swift_conformsToProtocol in Swift 5.0 would return
   // a false negative answer when asking whether a subclass conforms using
   // a conformance from a superclass. Work around this by walking up the

stdlib/toolchain/Compatibility51/Overrides.cpp

@@ -16,6 +16,7 @@
 
 #include "CompatibilityOverride.h"
 #include "Overrides.h"
+#include "../Compatibility53/Overrides.h"
 
 #include <dlfcn.h>
 #include <mach-o/dyld.h>
@@ -33,6 +34,11 @@ struct OverrideSection {
 OverrideSection Swift51Overrides
 __attribute__((used, section("__DATA,__swift51_hooks"))) = {
   .version = 0,
+  // We use the same hook for conformsToProtocol as we do for a 5.3
+  // runtime, so reference the override from the Compatibility53 library.
+  // If we're back deploying to Swift 5.1, we also have to support 5.3, so
+  // the Compatibility53 library is always linked when the 51 library is.
+  .conformsToProtocol = swift53override_conformsToProtocol,
   .conformsToSwiftProtocol = swift51override_conformsToSwiftProtocol,
 };
 

stdlib/toolchain/Compatibility53/BuiltinProtocolConformances.cpp

@@ -0,0 +1,137 @@
+//===--- BuiltinProtocolConformances.cpp ----------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// Definitions of some builtin protocol witnesses.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Overrides.h"
+#include "swift/Basic/Lazy.h"
+#include "swift/Runtime/BuiltinProtocolConformances.h"
+#include "swift/Runtime/Casting.h"
+#include <dlfcn.h>
+#include <mach-o/dyld.h>
+
+using namespace swift;
+
+static const ProtocolDescriptor *getEquatableDescriptor() {
+  auto descriptor = SWIFT_LAZY_CONSTANT(
+    reinterpret_cast<const ProtocolDescriptor *>(
+                     dlsym(RTLD_DEFAULT, "$sSQMp")));
+  return descriptor;
+}
+
+static const WitnessTable *conformsToProtocol(const Metadata *type,
+                                        const ProtocolDescriptor *protocol) {
+  using Fn = const WitnessTable *(const Metadata *, const ProtocolDescriptor *);
+  auto func = SWIFT_LAZY_CONSTANT(
+    reinterpret_cast<Fn *>(
+      dlsym(RTLD_DEFAULT, "swift_conformsToProtocol")));
+  return func(type, protocol);
+}
+
+#define TUPLE_EQUATABLE_WT SYMBOL("_swift_tupleEquatable_wt")
+
+// Define the conformance descriptor for tuple Equatable. We do this in
+// assembly to work around relative reference issues.
+__asm(
+  "  .section __DATA,__data\n"
+  "  .globl " TUPLE_EQUATABLE_CONF "\n"
+  "  .p2align 2\n"
+  TUPLE_EQUATABLE_CONF ":\n"
+  // This is an indirectable relative reference to the Equatable protocol
+  // descriptor. However, this is 0 here because the compatibility libraries
+  // can't have a dependency on libswiftCore (which is where Equatable lives).
+  "  .long 0\n"
+  // 769 is the MetadataKind::Tuple
+  "  .long 769\n"
+  // This is a direct relative reference to the witness table defined below.
+  "  .long ((" TUPLE_EQUATABLE_WT ") - (" TUPLE_EQUATABLE_CONF ")) - 8\n"
+  // 32 are the ConformanceFlags with the type reference bit set to MetadataKind.
+  "  .long 32\n"
+);
+
+extern const ProtocolConformanceDescriptor _swift_tupleEquatable_conf;
+
+// Due to the fact that the compatibility libraries can't have a hard
+// dependency to libswiftCore (which is where the Equatable protocol desciptor
+// lives), we have to manually implant this before calling any user code.
+__attribute__((constructor))
+void _emplaceEquatableDescriptor() {
+  auto tupleEquatableConf = const_cast<int32_t *>(
+    reinterpret_cast<const int32_t *>(&_swift_tupleEquatable_conf));
+  auto equatable = getEquatableDescriptor();
+
+  // This is an indirectable pointer.
+  *tupleEquatableConf = intptr_t(equatable) - intptr_t(tupleEquatableConf);
+}
+
+template<unsigned int NumWitnesses>
+struct _WitnessTable {
+  const ProtocolConformanceDescriptor *Conformance;
+  const void *Witnesses[NumWitnesses];
+};
+
+SWIFT_RUNTIME_EXPORT
+const _WitnessTable<1> _swift_tupleEquatable_wt = {
+  &_swift_tupleEquatable_conf,
+  {
+    reinterpret_cast<void *>(_swift_tupleEquatable_equals)
+  }
+};
+
+SWIFT_RUNTIME_EXPORT SWIFT_CC(swift)
+bool swift::_swift_tupleEquatable_equals(OpaqueValue *tuple1,
+                                         OpaqueValue *tuple2,
+                                         SWIFT_CONTEXT Metadata *swiftSelf,
+                                         Metadata *Self, void *witnessTable) {
+  auto tuple = cast<TupleTypeMetadata>(Self);
+
+  // Loop through all elements, and check if both tuples element is equal.
+  for (size_t i = 0; i != tuple->NumElements; i += 1) {
+    auto elt = tuple->getElement(i);
+
+    // Ensure we actually have a conformance to Equatable for this element type.
+    auto equatable = getEquatableDescriptor();
+    auto conformance = conformsToProtocol(elt.Type, equatable);
+
+    // If we don't have a conformance then something somewhere messed up in
+    // deciding that this tuple type was Equatable...??
+    if (!conformance)
+      swift_unreachable("Tuple equality requires that all elements be \
+        Equatable.");
+
+    // Get the respective values from both tuples.
+    auto value1 = reinterpret_cast<OpaqueValue *>(
+                    reinterpret_cast<char *>(tuple1) + elt.Offset);
+    auto value2 = reinterpret_cast<OpaqueValue *>(
+                    reinterpret_cast<char *>(tuple2) + elt.Offset);
+
+    // Grab the specific witness for this element type.
+    auto equatableTable = reinterpret_cast<void * const *>(conformance);
+    auto equalsWitness = equatableTable[WitnessTableFirstRequirementOffset];
+    using Fn = SWIFT_CC(swift) bool(OpaqueValue *, OpaqueValue *,
+                                    SWIFT_CONTEXT const Metadata *,
+                                    const Metadata *, const WitnessTable *);
+    auto equals = reinterpret_cast<Fn *>(equalsWitness);
+
+    // Call the equal function.
+    auto result = equals(value1, value2, elt.Type, elt.Type, conformance);
+
+    // If the values aren't equal, this tuple isn't equal. :)
+    if (!result)
+      return false;
+  }
+
+  // Otherwise this tuple has value equality with all elements.
+  return true;
+}

stdlib/toolchain/Compatibility53/CMakeLists.txt

@@ -0,0 +1,34 @@
+set(library_name "swiftCompatibility53")
+
+add_swift_target_library("${library_name}" STATIC
+  BuiltinProtocolConformances.cpp
+  Overrides.cpp
+  ProtocolConformance.cpp
+
+  TARGET_SDKS ${SWIFT_APPLE_PLATFORMS}
+
+  C_COMPILE_FLAGS ${CXX_COMPILE_FLAGS}
+  LINK_FLAGS ${CXX_LINK_FLAGS}
+  SWIFT_COMPILE_FLAGS ${SWIFT_STANDARD_LIBRARY_SWIFT_FLAGS}
+  DEPLOYMENT_VERSION_OSX ${COMPATIBILITY_MINIMUM_DEPLOYMENT_VERSION_OSX}
+  DEPLOYMENT_VERSION_IOS ${COMPATIBILITY_MINIMUM_DEPLOYMENT_VERSION_IOS}
+  DEPLOYMENT_VERSION_TVOS ${COMPATIBILITY_MINIMUM_DEPLOYMENT_VERSION_TVOS}
+  DEPLOYMENT_VERSION_WATCHOS ${COMPATIBILITY_MINIMUM_DEPLOYMENT_VERSION_WATCHOS}
+
+  INSTALL_IN_COMPONENT compiler
+  INSTALL_WITH_SHARED)
+
+
+# FIXME: We need a more flexible mechanism to add lipo targets generated by
+# add_swift_target_library to the ALL target. Until then this hack is necessary
+# to ensure these libraries build.
+foreach(sdk ${SWIFT_SDKS})
+  set(target_name "${library_name}-${SWIFT_SDK_${sdk}_LIB_SUBDIR}")
+  if(NOT TARGET "${target_name}")
+    continue()
+  endif()
+
+  set_target_properties("${target_name}"
+    PROPERTIES
+      EXCLUDE_FROM_ALL FALSE)
+endforeach()