Revert "Runtime: Remove retainCount entry points."

This reverts 51e0594. The corelibs are using this entry point.

Author: jckarter

docs/Runtime.md

@@ -89,6 +89,17 @@ Rename with a non-`stdlib` naming scheme.
 
 ## Reference counting
 
+### swift\_retainCount
+
+```
+@convention(c) (@unowned NativeObject) -> UInt
+```
+
+Returns a random number.
+
+**ABI TODO**: Only used by runtime tests and `SwiftObject.mm`. Should be
+internalized.
+
 ### TODO
 
 ```
@@ -101,6 +112,7 @@ Rename with a non-`stdlib` naming scheme.
 000000000001ce30 T _swift_retain
 000000000001ce50 T _swift_retain_n
 000000000001d140 T _swift_tryPin
+000000000001d240 T _swift_tryRetain
 0000000000027b10 T _swift_unknownRelease
 0000000000027a70 T _swift_unknownRelease_n
 0000000000027ad0 T _swift_unknownRetain
@@ -127,6 +139,7 @@ Rename with a non-`stdlib` naming scheme.
 000000000001cfb0 T _swift_unownedRelease
 000000000001d0a0 T _swift_unownedRelease_n
 000000000001cf70 T _swift_unownedRetain
+000000000001cf60 T _swift_unownedRetainCount
 000000000001d2b0 T _swift_unownedRetainStrong
 000000000001d310 T _swift_unownedRetainStrongAndRelease
 000000000001d060 T _swift_unownedRetain_n
@@ -150,6 +163,7 @@ Rename with a non-`stdlib` naming scheme.
 000000000002b290 T _swift_isUniquelyReferencedOrPinned_nonNull_native
 000000000002af00 T _swift_isUniquelyReferenced_native
 000000000002aea0 T _swift_isUniquelyReferenced_nonNull_native
+000000000001d280 T _swift_isDeallocating
 ```
 
 **ABI TODO**: `_unsynchronized` r/r entry points
@@ -332,8 +346,6 @@ runtime.
 ```
 0000000000023e60 T _swift_demangleSimpleClass
 0000000000028770 T _swift_objcRespondsToSelector
-000000000001d280 T _swift_isDeallocating
-000000000001d240 T _swift_tryRetain
 ```
 
 ## Metatypes

include/swift/Runtime/HeapObject.h

@@ -206,6 +206,10 @@ extern "C" void swift_release(HeapObject *object);
 /// count reaches zero, the object is destroyed
 extern "C" void swift_release_n(HeapObject *object, uint32_t n);
 
+/// ObjC compatibility. Never call this.
+extern "C" size_t swift_retainCount(HeapObject *object);
+extern "C" size_t swift_unownedRetainCount(HeapObject *object);
+
 /// Is this pointer a non-null unique reference to an object
 /// that uses Swift reference counting?
 extern "C" bool swift_isUniquelyReferencedNonObjC(const void *);

stdlib/public/runtime/HeapObject.cpp

@@ -309,6 +309,14 @@ static void _swift_release_n_(HeapObject *object, uint32_t n) {
 }
 auto swift::_swift_release_n = _swift_release_n_;
 
+size_t swift::swift_retainCount(HeapObject *object) {
+  return object->refCount.getCount();
+}
+
+size_t swift::swift_unownedRetainCount(HeapObject *object) {
+  return object->weakRefCount.getCount();
+}
+
 void swift::swift_unownedRetain(HeapObject *object) {
   if (!object) return;
 

stdlib/public/runtime/SwiftObject.mm

@@ -262,7 +262,7 @@ - (id)autorelease {
   return _objc_rootAutorelease(self);
 }
 - (NSUInteger)retainCount {
-  return reinterpret_cast<HeapObject *>(self)->refCount.getCount();
+  return swift::swift_retainCount(reinterpret_cast<HeapObject *>(self));
 }
 - (BOOL)_isDeallocating {
   return swift_isDeallocating(reinterpret_cast<HeapObject *>(self));

unittests/runtime/Refcounting.cpp

@@ -98,30 +98,23 @@ TEST(RefcountingTest, pin_pin_unpin_unpin) {
   EXPECT_EQ(1u, value);
 }
 
-static uintptr_t retainCount(HeapObject *obj) {
-  return obj->refCount.getCount();
-}
-static uintptr_t unownedRetainCount(HeapObject *obj) {
-  return obj->weakRefCount.getCount();
-}
-
 TEST(RefcountingTest, retain_release_n) {
   size_t value = 0;
   auto object = allocTestObject(&value, 1);
   EXPECT_EQ(0u, value);
   swift_retain_n(object, 32);
   swift_retain(object);
   EXPECT_EQ(0u, value);
-  EXPECT_EQ(34u, retainCount(object));
+  EXPECT_EQ(34u, swift_retainCount(object));
   swift_release_n(object, 31);
   EXPECT_EQ(0u, value);
-  EXPECT_EQ(3u, retainCount(object));
+  EXPECT_EQ(3u, swift_retainCount(object));
   swift_release(object);
   EXPECT_EQ(0u, value);
-  EXPECT_EQ(2u, retainCount(object));
+  EXPECT_EQ(2u, swift_retainCount(object));
   swift_release_n(object, 1);
   EXPECT_EQ(0u, value);
-  EXPECT_EQ(1u, retainCount(object));
+  EXPECT_EQ(1u, swift_retainCount(object));
   swift_release(object);
   EXPECT_EQ(1u, value);
 }
@@ -133,16 +126,16 @@ TEST(RefcountingTest, unknown_retain_release_n) {
   swift_unknownRetain_n(object, 32);
   swift_unknownRetain(object);
   EXPECT_EQ(0u, value);
-  EXPECT_EQ(34u, retainCount(object));
+  EXPECT_EQ(34u, swift_retainCount(object));
   swift_unknownRelease_n(object, 31);
   EXPECT_EQ(0u, value);
-  EXPECT_EQ(3u, retainCount(object));
+  EXPECT_EQ(3u, swift_retainCount(object));
   swift_unknownRelease(object);
   EXPECT_EQ(0u, value);
-  EXPECT_EQ(2u, retainCount(object));
+  EXPECT_EQ(2u, swift_retainCount(object));
   swift_unknownRelease_n(object, 1);
   EXPECT_EQ(0u, value);
-  EXPECT_EQ(1u, retainCount(object));
+  EXPECT_EQ(1u, swift_retainCount(object));
   swift_unknownRelease(object);
   EXPECT_EQ(1u, value);
 }
@@ -153,13 +146,13 @@ TEST(RefcountingTest, unowned_retain_release_n) {
   EXPECT_EQ(0u, value);
   swift_unownedRetain_n(object, 32);
   swift_unownedRetain(object);
-  EXPECT_EQ(34u, unownedRetainCount(object));
+  EXPECT_EQ(34u, swift_unownedRetainCount(object));
   swift_unownedRelease_n(object, 31);
-  EXPECT_EQ(3u, unownedRetainCount(object));
+  EXPECT_EQ(3u, swift_unownedRetainCount(object));
   swift_unownedRelease(object);
-  EXPECT_EQ(2u, unownedRetainCount(object));
+  EXPECT_EQ(2u, swift_unownedRetainCount(object));
   swift_unownedRelease_n(object, 1);
-  EXPECT_EQ(1u, unownedRetainCount(object));
+  EXPECT_EQ(1u, swift_unownedRetainCount(object));
   swift_release(object);
   EXPECT_EQ(1u, value);
 }

unittests/runtime/weak.mm

@@ -40,7 +40,7 @@ - (void) dealloc {
 extern "C" HeapObject *make_swift_object();
 
 static unsigned getUnownedRetainCount(HeapObject *object) {
-  return object->weakRefCount.getCount() - 1;
+  return swift_unownedRetainCount(object) - 1;
 }
 
 static void unknown_release(void *value) {