Runtime: Remove retainCount entry points.

They're only used for testing and ObjC interop, so don't need to be exported from the runtime.

Author: jckarter

Diff for: docs/Runtime.md

@@ -89,17 +89,6 @@ 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
 
 ```
@@ -112,7 +101,6 @@ internalized.
 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
@@ -139,7 +127,6 @@ internalized.
 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
@@ -163,7 +150,6 @@ internalized.
 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
@@ -346,6 +332,8 @@ runtime.
 ```
 0000000000023e60 T _swift_demangleSimpleClass
 0000000000028770 T _swift_objcRespondsToSelector
+000000000001d280 T _swift_isDeallocating
+000000000001d240 T _swift_tryRetain
 ```
 
 ## Metatypes

Diff for: include/swift/Runtime/HeapObject.h

@@ -206,10 +206,6 @@ 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 *);

Diff for: stdlib/public/runtime/HeapObject.cpp

@@ -309,14 +309,6 @@ 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;
 

Diff for: stdlib/public/runtime/SwiftObject.mm

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

Diff for: unittests/runtime/Refcounting.cpp

@@ -98,23 +98,30 @@ 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, swift_retainCount(object));
+  EXPECT_EQ(34u, retainCount(object));
   swift_release_n(object, 31);
   EXPECT_EQ(0u, value);
-  EXPECT_EQ(3u, swift_retainCount(object));
+  EXPECT_EQ(3u, retainCount(object));
   swift_release(object);
   EXPECT_EQ(0u, value);
-  EXPECT_EQ(2u, swift_retainCount(object));
+  EXPECT_EQ(2u, retainCount(object));
   swift_release_n(object, 1);
   EXPECT_EQ(0u, value);
-  EXPECT_EQ(1u, swift_retainCount(object));
+  EXPECT_EQ(1u, retainCount(object));
   swift_release(object);
   EXPECT_EQ(1u, value);
 }
@@ -126,16 +133,16 @@ TEST(RefcountingTest, unknown_retain_release_n) {
   swift_unknownRetain_n(object, 32);
   swift_unknownRetain(object);
   EXPECT_EQ(0u, value);
-  EXPECT_EQ(34u, swift_retainCount(object));
+  EXPECT_EQ(34u, retainCount(object));
   swift_unknownRelease_n(object, 31);
   EXPECT_EQ(0u, value);
-  EXPECT_EQ(3u, swift_retainCount(object));
+  EXPECT_EQ(3u, retainCount(object));
   swift_unknownRelease(object);
   EXPECT_EQ(0u, value);
-  EXPECT_EQ(2u, swift_retainCount(object));
+  EXPECT_EQ(2u, retainCount(object));
   swift_unknownRelease_n(object, 1);
   EXPECT_EQ(0u, value);
-  EXPECT_EQ(1u, swift_retainCount(object));
+  EXPECT_EQ(1u, retainCount(object));
   swift_unknownRelease(object);
   EXPECT_EQ(1u, value);
 }
@@ -146,13 +153,13 @@ TEST(RefcountingTest, unowned_retain_release_n) {
   EXPECT_EQ(0u, value);
   swift_unownedRetain_n(object, 32);
   swift_unownedRetain(object);
-  EXPECT_EQ(34u, swift_unownedRetainCount(object));
+  EXPECT_EQ(34u, unownedRetainCount(object));
   swift_unownedRelease_n(object, 31);
-  EXPECT_EQ(3u, swift_unownedRetainCount(object));
+  EXPECT_EQ(3u, unownedRetainCount(object));
   swift_unownedRelease(object);
-  EXPECT_EQ(2u, swift_unownedRetainCount(object));
+  EXPECT_EQ(2u, unownedRetainCount(object));
   swift_unownedRelease_n(object, 1);
-  EXPECT_EQ(1u, swift_unownedRetainCount(object));
+  EXPECT_EQ(1u, unownedRetainCount(object));
   swift_release(object);
   EXPECT_EQ(1u, value);
 }

Diff for: unittests/runtime/weak.mm

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