DNM: stdlib: Add backward deployment versions for the dynamic-replacement runtime functions - version 2

include/swift/Runtime/DynamicReplaceable.h

@@ -0,0 +1,40 @@
+//===--- DynamicReplaceable.h - dynamic replaceable support -----*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Swift runtime support for dynamic replaceable functions.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_RUNTIME_DYNAMIC_REPLACEABLE_H
+#define SWIFT_RUNTIME_DYNAMIC_REPLACEABLE_H
+
+#include "swift/Runtime/Config.h"
+
+namespace swift {
+
+/// Loads the replacement function pointer from \p ReplFnPtr and returns the
+/// replacement function if it should be called.
+/// Returns null if the original function (which is passed in \p CurrFn) should
+/// be called.
+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.
+SWIFT_RUNTIME_EXPORT
+char *swift_getOrigOfReplaceable(char **OrigFnPtr);
+
+} // end namespace swift
+
+#endif

include/swift/Runtime/Exclusivity.h

@@ -40,20 +40,6 @@ SWIFT_RUNTIME_EXPORT
 void swift_beginAccess(void *pointer, ValueBuffer *buffer,
                        ExclusivityFlags flags, void *pc);
 
-/// Loads the replacement function pointer from \p ReplFnPtr and returns the
-/// replacement function if it should be called.
-/// Returns null if the original function (which is passed in \p CurrFn) should
-/// be called.
-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.
-SWIFT_RUNTIME_EXPORT
-char *swift_getOrigOfReplaceable(char **OrigFnPtr);
-
 /// Stop dynamically tracking an access.
 SWIFT_RUNTIME_EXPORT
 void swift_endAccess(ValueBuffer *buffer);

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}

stdlib/public/Compatibility50/DynamicReplaceable.cpp

@@ -0,0 +1,88 @@
+//===--- ProtocolConformance.cpp - Swift protocol conformance checking ----===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 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/Exclusivity.h"
+#include "swift/Runtime/Metadata.h"
+#include "../runtime/ThreadLocalStorage.h"
+
+using namespace swift;
+
+// Mirror the SwiftTLSContext, which is defined in the runtime.
+// This is a hack: the layout must match with SwiftTLSContext defined in
+// Exclusivity.cpp. Fortunately it contains only a single pointer (the head of
+// the access list).
+class SwiftTLSContext {
+  void *AccessHead;
+
+public:
+  void *getHead() const { return AccessHead; }
+
+  void setExtraBit() {
+    AccessHead = (void *)((intptr_t)AccessHead | 1);
+  }
+
+  void clearExtraBit() {
+    AccessHead = (void *)((intptr_t)AccessHead & ~1);
+  }
+
+  bool testExtraBit() const {
+    return (bool)((intptr_t)AccessHead & 1);
+  }
+};
+
+__attribute__((visibility("hidden"), weak))
+extern "C" char *swift_getFunctionReplacement(char **ReplFnPtr, char *CurrFn) {
+  char *ReplFn = *ReplFnPtr;
+  char *RawReplFn = ReplFn;
+
+  if (RawReplFn == CurrFn)
+    return nullptr;
+
+  void *tlsStorage = SWIFT_THREAD_GETSPECIFIC(SWIFT_RUNTIME_TLS_KEY);
+  if (tlsStorage) {
+    SwiftTLSContext *ctx = static_cast<SwiftTLSContext*>(tlsStorage);
+
+    if (ctx->testExtraBit()) {
+      ctx->clearExtraBit();
+      return nullptr;
+    }
+  }
+  return ReplFn;
+}
+
+__attribute__((visibility("hidden"), weak))
+extern "C" char *swift_getOrigOfReplaceable(char **OrigFnPtr) {
+  void *tlsStorage = SWIFT_THREAD_GETSPECIFIC(SWIFT_RUNTIME_TLS_KEY);
+  if (!tlsStorage) {
+    ValueBuffer dummyAccess;
+    int dummyValue = 0;
+    swift_beginAccess(&dummyValue, &dummyAccess, ExclusivityFlags::Read, nullptr);
+    swift_endAccess(&dummyAccess);
+    tlsStorage = SWIFT_THREAD_GETSPECIFIC(SWIFT_RUNTIME_TLS_KEY);
+    if (!tlsStorage)
+      abort();
+  }
+  SwiftTLSContext *ctx = static_cast<SwiftTLSContext*>(tlsStorage);
+  void *pr = ctx->getHead();
+  ctx->setExtraBit();
+  char *OrigFn = *OrigFnPtr;
+  return OrigFn;
+}
+

stdlib/public/runtime/Exclusivity.cpp

@@ -17,6 +17,7 @@
 #include "swift/Basic/Lazy.h"
 #include "swift/Runtime/Config.h"
 #include "swift/Runtime/Debug.h"
+#include "swift/Runtime/DynamicReplaceable.h"
 #include "swift/Runtime/Exclusivity.h"
 #include "swift/Runtime/Metadata.h"
 #include "ThreadLocalStorage.h"
@@ -158,13 +159,21 @@ static_assert(sizeof(Access) <= sizeof(ValueBuffer) &&
 
 /// A set of accesses that we're tracking.  Just a singly-linked list.
 class AccessSet {
+
+  // Bit 0 stores an extra bit which is used by the dynamic-replaceable runtime.
+  // It is an "implicit" boolean parameter which is passed to a dynamically
+  // replaceable function.
+  // If true, the original function should be executed instead of the
+  // replacement function.
   Access *Head = nullptr;
+
 public:
   constexpr AccessSet() {}
 
   bool insert(Access *access, void *pc, void *pointer, ExclusivityFlags flags) {
     auto action = getAccessAction(flags);
 
+    assert(!testExtraBit());
     for (Access *cur = Head; cur != nullptr; cur = cur->getNext()) {
       // Ignore accesses to different values.
       if (cur->Pointer != pointer)
@@ -192,6 +201,7 @@ class AccessSet {
   }
 
   void remove(Access *access) {
+    assert(!testExtraBit());
     auto cur = Head;
     // Fast path: stack discipline.
     if (cur == access) {
@@ -212,6 +222,18 @@ class AccessSet {
     swift_runtime_unreachable("access not found in set");
   }
 
+  void setExtraBit() {
+    Head = (Access *)((intptr_t)Head | 1);
+  }
+
+  void clearExtraBit() {
+    Head = (Access *)((intptr_t)Head & ~1);
+  }
+
+  bool testExtraBit() const {
+    return (bool)((intptr_t)Head & 1);
+  }
+
 #ifndef NDEBUG
   /// Only available with asserts. Intended to be used with
   /// swift_dumpTrackedAccess().
@@ -227,12 +249,6 @@ class SwiftTLSContext {
 public:
   /// The set of tracked accesses.
   AccessSet accessSet;
-
-  // The "implicit" boolean parameter which is passed to a dynamically
-  // replaceable function.
-  // If true, the original function should be executed instead of the
-  // replacement function.
-  bool CallOriginalOfReplacedFunction = false;
 };
 
 } // end anonymous namespace
@@ -343,17 +359,25 @@ char *swift::swift_getFunctionReplacement(char **ReplFnPtr, char *CurrFn) {
   char *ReplFn = *ReplFnPtr;
   if (ReplFn == CurrFn)
     return nullptr;
+
+  // The "implicit" boolean parameter, which inidicates if the original function
+  // should be called, is passed in the extra bit of the AccessSet.
   SwiftTLSContext &ctx = getTLSContext();
-  if (ctx.CallOriginalOfReplacedFunction) {
-    ctx.CallOriginalOfReplacedFunction = false;
+  if (ctx.accessSet.testExtraBit()) {
+    ctx.accessSet.clearExtraBit();
     return nullptr;
   }
   return ReplFn;
 }
 
 char *swift::swift_getOrigOfReplaceable(char **OrigFnPtr) {
   char *OrigFn = *OrigFnPtr;
-  getTLSContext().CallOriginalOfReplacedFunction = true;
+
+  // Use the extra bit of the AccessSet to pass the "implicit" parameter.
+  SwiftTLSContext &ctx = getTLSContext();
+  assert(!ctx.accessSet.testExtraBit());
+  ctx.accessSet.setExtraBit();
+
   return OrigFn;
 }