From 845d12f797f9bf861eb2cc335c45c25131831ff6 Mon Sep 17 00:00:00 2001
From: Kuba Mracek <mracek@apple.com>
Date: Wed, 26 Aug 2020 09:16:13 -0700
Subject: [PATCH] Respect SWIFT_STDLIB_SINGLE_THREADED_RUNTIME and use
 nonatomic refcounting in swift_retain, swift_release, etc.

---
 stdlib/public/runtime/HeapObject.cpp | 45 ++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)

diff --git a/stdlib/public/runtime/HeapObject.cpp b/stdlib/public/runtime/HeapObject.cpp
index c409c23731e16..fc644c7a110c4 100644
--- a/stdlib/public/runtime/HeapObject.cpp
+++ b/stdlib/public/runtime/HeapObject.cpp
@@ -336,7 +336,11 @@ static HeapObject *_swift_retain_(HeapObject *object) {
 }
 
 HeapObject *swift::swift_retain(HeapObject *object) {
+#ifdef SWIFT_STDLIB_SINGLE_THREADED_RUNTIME
+  return swift_nonatomic_retain(object);
+#else
   CALL_IMPL(swift_retain, (object));
+#endif
 }
 
 SWIFT_RUNTIME_EXPORT
@@ -358,7 +362,11 @@ static HeapObject *_swift_retain_n_(HeapObject *object, uint32_t n) {
 }
 
 HeapObject *swift::swift_retain_n(HeapObject *object, uint32_t n) {
+#ifdef SWIFT_STDLIB_SINGLE_THREADED_RUNTIME
+  return swift_nonatomic_retain_n(object, n);
+#else
   CALL_IMPL(swift_retain_n, (object, n));
+#endif
 }
 
 SWIFT_RUNTIME_EXPORT
@@ -379,7 +387,11 @@ static void _swift_release_(HeapObject *object) {
 }
 
 void swift::swift_release(HeapObject *object) {
+#ifdef SWIFT_STDLIB_SINGLE_THREADED_RUNTIME
+  swift_nonatomic_release(object);
+#else
   CALL_IMPL(swift_release, (object));
+#endif
 }
 
 SWIFT_RUNTIME_EXPORT
@@ -399,7 +411,11 @@ static void _swift_release_n_(HeapObject *object, uint32_t n) {
 }
 
 void swift::swift_release_n(HeapObject *object, uint32_t n) {
+#ifdef SWIFT_STDLIB_SINGLE_THREADED_RUNTIME
+  swift_nonatomic_release_n(object, n);
+#else
   CALL_IMPL(swift_release_n, (object, n));
+#endif
 }
 
 SWIFT_RUNTIME_EXPORT
@@ -427,15 +443,22 @@ size_t swift::swift_weakRetainCount(HeapObject *object) {
 }
 
 HeapObject *swift::swift_unownedRetain(HeapObject *object) {
+#ifdef SWIFT_STDLIB_SINGLE_THREADED_RUNTIME
+  return static_cast<HeapObject *>(swift_nonatomic_unownedRetain(object));
+#else
   SWIFT_RT_TRACK_INVOCATION(object, swift_unownedRetain);
   if (!isValidPointerForNativeRetain(object))
     return object;
 
   object->refCounts.incrementUnowned(1);
   return object;
+#endif
 }
 
 void swift::swift_unownedRelease(HeapObject *object) {
+#ifdef SWIFT_STDLIB_SINGLE_THREADED_RUNTIME
+  swift_nonatomic_unownedRelease(object);
+#else
   SWIFT_RT_TRACK_INVOCATION(object, swift_unownedRelease);
   if (!isValidPointerForNativeRetain(object))
     return;
@@ -450,6 +473,7 @@ void swift::swift_unownedRelease(HeapObject *object) {
     swift_slowDealloc(object, classMetadata->getInstanceSize(),
                       classMetadata->getInstanceAlignMask());
   }
+#endif
 }
 
 void *swift::swift_nonatomic_unownedRetain(HeapObject *object) {
@@ -479,15 +503,22 @@ void swift::swift_nonatomic_unownedRelease(HeapObject *object) {
 }
 
 HeapObject *swift::swift_unownedRetain_n(HeapObject *object, int n) {
+#ifdef SWIFT_STDLIB_SINGLE_THREADED_RUNTIME
+  return swift_nonatomic_unownedRetain_n(object, n);
+#else
   SWIFT_RT_TRACK_INVOCATION(object, swift_unownedRetain_n);
   if (!isValidPointerForNativeRetain(object))
     return object;
 
   object->refCounts.incrementUnowned(n);
   return object;
+#endif
 }
 
 void swift::swift_unownedRelease_n(HeapObject *object, int n) {
+#ifdef SWIFT_STDLIB_SINGLE_THREADED_RUNTIME
+  swift_nonatomic_unownedRelease_n(object, n);
+#else
   SWIFT_RT_TRACK_INVOCATION(object, swift_unownedRelease_n);
   if (!isValidPointerForNativeRetain(object))
     return;
@@ -501,6 +532,7 @@ void swift::swift_unownedRelease_n(HeapObject *object, int n) {
     swift_slowDealloc(object, classMetadata->getInstanceSize(),
                       classMetadata->getInstanceAlignMask());
   }
+#endif
 }
 
 HeapObject *swift::swift_nonatomic_unownedRetain_n(HeapObject *object, int n) {
@@ -533,8 +565,13 @@ static HeapObject *_swift_tryRetain_(HeapObject *object) {
   if (!isValidPointerForNativeRetain(object))
     return nullptr;
 
+#ifdef SWIFT_STDLIB_SINGLE_THREADED_RUNTIME
+  if (object->refCounts.tryIncrementNonAtomic()) return object;
+  else return nullptr;
+#else
   if (object->refCounts.tryIncrement()) return object;
   else return nullptr;
+#endif
 }
 
 HeapObject *swift::swift_tryRetain(HeapObject *object) {
@@ -557,6 +594,9 @@ void swift::swift_setDeallocating(HeapObject *object) {
 }
 
 HeapObject *swift::swift_unownedRetainStrong(HeapObject *object) {
+#ifdef SWIFT_STDLIB_SINGLE_THREADED_RUNTIME
+  return swift_nonatomic_unownedRetainStrong(object);
+#else
   SWIFT_RT_TRACK_INVOCATION(object, swift_unownedRetainStrong);
   if (!isValidPointerForNativeRetain(object))
     return object;
@@ -566,6 +606,7 @@ HeapObject *swift::swift_unownedRetainStrong(HeapObject *object) {
   if (! object->refCounts.tryIncrement())
     swift::swift_abortRetainUnowned(object);
   return object;
+#endif
 }
 
 HeapObject *swift::swift_nonatomic_unownedRetainStrong(HeapObject *object) {
@@ -581,6 +622,9 @@ HeapObject *swift::swift_nonatomic_unownedRetainStrong(HeapObject *object) {
 }
 
 void swift::swift_unownedRetainStrongAndRelease(HeapObject *object) {
+#ifdef SWIFT_STDLIB_SINGLE_THREADED_RUNTIME
+  swift_nonatomic_unownedRetainStrongAndRelease(object);
+#else
   SWIFT_RT_TRACK_INVOCATION(object, swift_unownedRetainStrongAndRelease);
   if (!isValidPointerForNativeRetain(object))
     return;
@@ -594,6 +638,7 @@ void swift::swift_unownedRetainStrongAndRelease(HeapObject *object) {
   bool dealloc = object->refCounts.decrementUnownedShouldFree(1);
   assert(!dealloc && "retain-strong-and-release caused dealloc?");
   (void) dealloc;
+#endif
 }
 
 void swift::swift_nonatomic_unownedRetainStrongAndRelease(HeapObject *object) {