stdlib: Add backward deployment versions for the

aschwaighofer · aschwaighofer · commit 5003c15079bd · 2019-06-14T10:53:26.000-07:00
dynamic-replacement runtime functions.

The recent change of how we do dynamic replacements added 2 new runtime
functions. This patch adds those functions to the Compatibility50 static
archive.

This will allow backward deployment to a swift 5.0 runtime.

Patch by Erik Eckstein with a modification to call the standard
libraries implementation (marked as weak) when it is available.

This ensures we can change the implementation in the future and are not
ABI locked.

rdar://problem/51601233
diff --git a/include/swift/Runtime/Exclusivity.h b/include/swift/Runtime/Exclusivity.h
@@ -44,13 +44,19 @@ void swift_beginAccess(void *pointer, ValueBuffer *buffer,
 /// replacement function if it should be called.
 /// Returns null if the original function (which is passed in \p CurrFn) should
 /// be called.
+#ifdef __APPLE__
+__attribute__((weak))
+#endif
 SWIFT_RUNTIME_EXPORT
 char *swift_getFunctionReplacement(char **ReplFnPtr, char *CurrFn);
 
 /// Returns the original function of a replaced function, which is loaded from
 /// \p OrigFnPtr.
 /// This function is called from a replacement function to call the original
 /// function.
+#ifdef __APPLE__
+__attribute__((weak))
+#endif
 SWIFT_RUNTIME_EXPORT
 char *swift_getOrigOfReplaceable(char **OrigFnPtr);
 
diff --git a/include/swift/Runtime/RuntimeFunctions.def b/include/swift/Runtime/RuntimeFunctions.def
@@ -1225,12 +1225,26 @@ FUNCTION(EndAccess, swift_endAccess, C_CC, AlwaysAvailable,
          ARGS(getFixedBufferTy()->getPointerTo()),
          ATTRS(NoUnwind))
 
-FUNCTION(GetOrigOfReplaceable, swift_getOrigOfReplaceable, C_CC, AlwaysAvailable,
+FUNCTION(GetOrigOfReplaceable, swift_getOrigOfReplaceable, C_CC,
+         GetReplacementAvailability,
          RETURNS(FunctionPtrTy),
          ARGS(FunctionPtrTy->getPointerTo()),
          ATTRS(NoUnwind))
 
-FUNCTION(GetReplacement, swift_getFunctionReplacement, C_CC, AlwaysAvailable,
+FUNCTION(GetReplacement, swift_getFunctionReplacement, C_CC,
+         GetReplacementAvailability,
+         RETURNS(FunctionPtrTy),
+         ARGS(FunctionPtrTy->getPointerTo(), FunctionPtrTy),
+         ATTRS(NoUnwind))
+
+FUNCTION(GetOrigOfReplaceable50, swift_getOrigOfReplaceable50, C_CC,
+         AlwaysAvailable,
+         RETURNS(FunctionPtrTy),
+         ARGS(FunctionPtrTy->getPointerTo()),
+         ATTRS(NoUnwind))
+
+FUNCTION(GetReplacement50, swift_getFunctionReplacement50, C_CC,
+         AlwaysAvailable,
          RETURNS(FunctionPtrTy),
          ARGS(FunctionPtrTy->getPointerTo(), FunctionPtrTy),
          ATTRS(NoUnwind))
diff --git a/lib/IRGen/GenDecl.cpp b/lib/IRGen/GenDecl.cpp
@@ -2239,8 +2239,12 @@ void IRGenModule::createReplaceableProlog(IRGenFunction &IGF, SILFunction *f) {
     rhs = FnAddr;
   } else {
     // Call swift_getFunctionReplacement to check which function to call.
-    auto *callRTFunc = IGF.Builder.CreateCall(getGetReplacementFn(),
-                                             { ReplAddr, FnAddr });
+    auto *getReplacementFn = IRGenModule::isGetReplacementAvailable(Context)
+                                 ? getGetReplacementFn()
+                                 : getGetReplacement50Fn();
+
+    auto *callRTFunc =
+        IGF.Builder.CreateCall(getReplacementFn, {ReplAddr, FnAddr});
     callRTFunc->setDoesNotThrow();
     ReplFn = callRTFunc;
     rhs = llvm::ConstantExpr::getNullValue(ReplFn->getType());
@@ -2408,8 +2412,11 @@ void IRGenModule::emitDynamicReplacementOriginalFunctionThunk(SILFunction *f) {
       llvm::ConstantExpr::getInBoundsGetElementPtr(nullptr, linkEntry, indices),
       FunctionPtrTy->getPointerTo());
 
-  auto *OrigFn = IGF.Builder.CreateCall(getGetOrigOfReplaceableFn(),
-                                        { fnPtrAddr });
+  auto *getOrigOfReplaceableFn = IRGenModule::isGetReplacementAvailable(Context)
+                                     ? getGetOrigOfReplaceableFn()
+                                     : getGetOrigOfReplaceable50Fn();
+  auto *OrigFn = IGF.Builder.CreateCall(getOrigOfReplaceableFn, {fnPtrAddr});
+
   OrigFn->setDoesNotThrow();
 
   auto *typeFnPtr =
diff --git a/lib/IRGen/IRGenModule.cpp b/lib/IRGen/IRGenModule.cpp
@@ -527,6 +527,31 @@ IRGenModule::~IRGenModule() {
 
 static bool isReturnAttribute(llvm::Attribute::AttrKind Attr);
 
+static AvailabilityContext
+getGetReplacementAvailability(ASTContext &context) {
+  auto target = context.LangOpts.Target;
+
+  if (target.isMacOSX()) {
+    return AvailabilityContext(
+        VersionRange::allGTE(llvm::VersionTuple(10, 15, 0)));
+  } else if (target.isiOS()) {
+    return AvailabilityContext(
+        VersionRange::allGTE(llvm::VersionTuple(13, 0, 0)));
+  } else if (target.isWatchOS()) {
+    return AvailabilityContext(
+        VersionRange::allGTE(llvm::VersionTuple(6, 0, 0)));
+  } else {
+    return AvailabilityContext::alwaysAvailable();
+  }
+}
+
+bool IRGenModule::isGetReplacementAvailable(ASTContext &Context) {
+  auto deploymentAvailability =
+      AvailabilityContext::forDeploymentTarget(Context);
+  auto featureAvailability = getGetReplacementAvailability(Context);
+  return deploymentAvailability.isContainedIn(featureAvailability);
+}
+
 // Explicitly listing these constants is an unfortunate compromise for
 // making the database file much more compact.
 //
@@ -551,6 +576,10 @@ namespace RuntimeConstants {
     
     return !deploymentAvailability.isContainedIn(featureAvailability);
   }
+
+  bool GetReplacementAvailability(ASTContext &Context) {
+    return !IRGenModule::isGetReplacementAvailable(Context);
+  }
 } // namespace RuntimeConstants
 
 // We don't use enough attributes to justify generalizing the
diff --git a/lib/IRGen/IRGenModule.h b/lib/IRGen/IRGenModule.h
@@ -1441,6 +1441,7 @@ private:                            \
 
   void emitOpaqueTypeDescriptorAccessor(OpaqueTypeDecl *);
 
+  static bool isGetReplacementAvailable(ASTContext &context);
 private:
   llvm::Constant *
   getAddrOfSharedContextDescriptor(LinkEntity entity,
diff --git a/stdlib/public/Compatibility50/CMakeLists.txt b/stdlib/public/Compatibility50/CMakeLists.txt
@@ -3,6 +3,7 @@ set(swift_runtime_linker_flags ${SWIFT_RUNTIME_CORE_LINK_FLAGS})
 
 add_swift_target_library(swiftCompatibility50 TARGET_LIBRARY STATIC INSTALL_WITH_SHARED
   ProtocolConformance.cpp
+  DynamicReplaceable.cpp
   Overrides.cpp
   C_COMPILE_FLAGS ${swift_runtime_library_compile_flags}
   LINK_FLAGS ${swift_runtime_linker_flags}
diff --git a/stdlib/public/Compatibility50/DynamicReplaceable.cpp b/stdlib/public/Compatibility50/DynamicReplaceable.cpp
@@ -0,0 +1,72 @@
+//===--- ProtocolConformance.cpp - Swift protocol conformance checking ----===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2019 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Runtime support for dynamic replaceable functions.
+//
+// This implementation is intended to be backward-deployed into Swift 5.0
+// runtimes.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Overrides.h"
+#include "swift/Runtime/Once.h"
+#include "swift/Runtime/Exclusivity.h"
+#include "../runtime/ThreadLocalStorage.h"
+
+using namespace swift;
+
+// The thread-local key must be weak so that it is shared between different
+// binaries (e.g. shared libraries).
+__attribute__((weak)) __swift_thread_key_t _swift_dr_key;
+__attribute__((weak)) swift_once_t _swift_dr_Predicate;
+
+static void createSwiftThreadKey(void *) {
+  int result = SWIFT_THREAD_KEY_CREATE(&_swift_dr_key, nullptr);
+  if (result != 0)
+    abort();
+}
+
+static __swift_thread_key_t &getTLSKey() {
+  swift_once(&_swift_dr_Predicate, createSwiftThreadKey, nullptr);
+  return _swift_dr_key;
+}
+
+__attribute__((visibility("hidden"), weak))
+extern "C" char *swift_getFunctionReplacement50(char **ReplFnPtr, char *CurrFn) {
+  // Call the current implementation if it is available.
+  if (swift_getFunctionReplacement)
+    return swift_getFunctionReplacement(ReplFnPtr, CurrFn);
+
+  char *ReplFn = *ReplFnPtr;
+  char *RawReplFn = ReplFn;
+
+  if (RawReplFn == CurrFn)
+    return nullptr;
+
+  __swift_thread_key_t key = getTLSKey();
+  if ((intptr_t)SWIFT_THREAD_GETSPECIFIC(key) != 0) {
+    SWIFT_THREAD_SETSPECIFIC(key, (void *)0);
+    return nullptr;
+  }
+  return ReplFn;
+}
+
+__attribute__((visibility("hidden"), weak))
+extern "C" char *swift_getOrigOfReplaceable50(char **OrigFnPtr) {
+  // Call the current implementation if it is available.
+  if (swift_getOrigOfReplaceable)
+    return swift_getOrigOfReplaceable(OrigFnPtr);
+
+  char *OrigFn = *OrigFnPtr;
+  SWIFT_THREAD_SETSPECIFIC(getTLSKey(), (void *)-1);
+  return OrigFn;
+}
diff --git a/test/IRGen/dynamic_replaceable.sil b/test/IRGen/dynamic_replaceable.sil
@@ -1,4 +1,5 @@
-// RUN: %target-swift-frontend %s -emit-ir -disable-objc-interop | %FileCheck %s
+// RUN: %target-swift-frontend %s -emit-ir -disable-objc-interop | %FileCheck %s --check-prefix=CHECK --check-prefix=COMPAT
+// RUN: %target-swift-frontend %s -emit-ir -disable-objc-interop -target x86_64-apple-macosx10.15 | %FileCheck %s --check-prefix=CHECK --check-prefix=NONCOMPAT
 
 // REQUIRES: objc_interop
 
@@ -23,7 +24,8 @@
 
 // CHECK-LABEL: define swiftcc void @test_dynamically_replaceable()
 // CHECK-NEXT: entry:
-// CHECK-NEXT:   [[FUN_PTR:%.*]] =  call i8* @swift_getFunctionReplacement(i8** getelementptr inbounds (%swift.dyn_repl_link_entry, %swift.dyn_repl_link_entry* @test_dynamically_replaceableTX, i32 0, i32 0), i8* bitcast (void ()* @test_dynamically_replaceable to i8*))
+// COMPAT-NEXT:   [[FUN_PTR:%.*]] =  call i8* @swift_getFunctionReplacement50(i8** getelementptr inbounds (%swift.dyn_repl_link_entry, %swift.dyn_repl_link_entry* @test_dynamically_replaceableTX, i32 0, i32 0), i8* bitcast (void ()* @test_dynamically_replaceable to i8*))
+// NONCOMPAT-NEXT:   [[FUN_PTR:%.*]] =  call i8* @swift_getFunctionReplacement(i8** getelementptr inbounds (%swift.dyn_repl_link_entry, %swift.dyn_repl_link_entry* @test_dynamically_replaceableTX, i32 0, i32 0), i8* bitcast (void ()* @test_dynamically_replaceable to i8*))
 // CHECK-NEXT:   [[CMP:%.*]] = icmp eq i8* [[FUN_PTR]], null
 // CHECK-NEXT:   br i1 [[CMP]], label %[[ORIGBB:[a-z_]*]], label %[[FWBB:[a-z_]*]]
 // CHECK:      [[FWBB]]:
@@ -49,7 +51,8 @@ bb0:
 // The thunk that implement the prev_dynamic_function_ref lookup.
 // CHECK-LABEL: define swiftcc void @test_replacementTI()
 // CHECK: entry:
-// CHECK:   [[FUN_PTR:%.*]] = call i8* @swift_getOrigOfReplaceable(i8** getelementptr inbounds (%swift.dyn_repl_link_entry, %swift.dyn_repl_link_entry* @test_replacementTX, i32 0, i32 0))
+// COMPAT:   [[FUN_PTR:%.*]] = call i8* @swift_getOrigOfReplaceable50(i8** getelementptr inbounds (%swift.dyn_repl_link_entry, %swift.dyn_repl_link_entry* @test_replacementTX, i32 0, i32 0))
+// NONCOMPAT:   [[FUN_PTR:%.*]] = call i8* @swift_getOrigOfReplaceable(i8** getelementptr inbounds (%swift.dyn_repl_link_entry, %swift.dyn_repl_link_entry* @test_replacementTX, i32 0, i32 0))
 // CHECK:   [[TYPED_PTR:%.*]] = bitcast i8* [[FUN_PTR]] to void ()*
 // CHECK:   call swiftcc void [[TYPED_PTR]]()
 // CHECK:   ret void
