Introduce a flag to mark classes with Swift-native

refcounting and take advantage of it.

Also, set the Swift1 flag in classes we generate.

Also, initialize a global cache of the non-pointer-isa
mask and use that instead of object_getClass, at least
within the runtime.

Also, centralize the runtime on a _swift_getSuperclass
function and make that use a direct access while we
await word from Greg on the desired ABI requirements.

Swift SVN r21077

Author: rjmccall

include/swift/ABI/Class.h

@@ -22,9 +22,9 @@
 
 namespace swift {
 
-/// Flags which 
-enum class ClassFlags : uint32_t {
-  /// This class is a meta-class.
+/// Objetive-C class flags, stored in the ro-data.
+enum class ObjCClassFlags : uint32_t {
+  /// This class is a metaclass.
   Meta                 = 0x00001,
 
   /// This class is a root class.
@@ -51,11 +51,11 @@ enum class ClassFlags : uint32_t {
   /// when setting this flag, HasCXXStructors must be set as well.
   HasCXXDestructorOnly = 0x00100
 };
-inline ClassFlags &operator|=(ClassFlags &lhs, ClassFlags rhs) {
-  lhs = ClassFlags(uint32_t(lhs) | uint32_t(rhs));
+inline ObjCClassFlags &operator|=(ObjCClassFlags &lhs, ObjCClassFlags rhs) {
+  lhs = ObjCClassFlags(uint32_t(lhs) | uint32_t(rhs));
   return lhs;
 }
-inline ClassFlags operator|(ClassFlags lhs, ClassFlags rhs) {
+inline ObjCClassFlags operator|(ObjCClassFlags lhs, ObjCClassFlags rhs) {
   return (lhs |= rhs);
 }
 

include/swift/ABI/MetadataValues.h

@@ -125,6 +125,9 @@ inline DynamicCastFlags &operator|=(DynamicCastFlags &a, DynamicCastFlags b) {
 enum class ClassFlags : uint32_t {
   /// Is this a Swift 1 class?
   IsSwift1 = 0x1,
+
+  /// Does this class use Swift 1.0 refcounting?
+  UsesSwift1Refcounting = 0x2,
 };
 inline bool operator&(ClassFlags a, ClassFlags b) {
   return (uint32_t(a) & uint32_t(b)) != 0;

include/swift/ABI/System.h

@@ -67,6 +67,7 @@
 #define SWIFT_ABI_X86_64_SWIFT_SPARE_BITS_MASK 0xFFFF800000000007ULL
 
 // Objective-C reserves the high and low bits for tagged pointers.
+// Systems exist which use either bit.
 #define SWIFT_ABI_X86_64_OBJC_RESERVED_BITS_MASK 0x8000000000000001ULL
 #define SWIFT_ABI_X86_64_OBJC_NUM_RESERVED_LOW_BITS 1
 
@@ -80,9 +81,9 @@
 // Heap objects are eight-byte aligned.
 #define SWIFT_ABI_ARM64_SWIFT_SPARE_BITS_MASK 0xFF00000000000007ULL
 
-// Objective-C reserves the high and low bits for tagged pointers.
-#define SWIFT_ABI_ARM64_OBJC_RESERVED_BITS_MASK 0x8000000000000001ULL
-#define SWIFT_ABI_ARM64_OBJC_NUM_RESERVED_LOW_BITS 1
+// Objective-C reserves just the high bit for tagged pointers.
+#define SWIFT_ABI_ARM64_OBJC_RESERVED_BITS_MASK 0x8000000000000000ULL
+#define SWIFT_ABI_ARM64_OBJC_NUM_RESERVED_LOW_BITS 0
 
 
 #endif /* SWIFT_ABI_SYSTEM_H */

lib/IRGen/GenClass.cpp

@@ -1159,21 +1159,21 @@ namespace {
 
   private:
     llvm::Constant *buildFlags(ForMetaClass_t forMeta) {
-      ClassFlags flags = ClassFlags::CompiledByARC;
+      ObjCClassFlags flags = ObjCClassFlags::CompiledByARC;
 
       // Mark metaclasses as appropriate.
       if (forMeta) {
-        flags |= ClassFlags::Meta;
+        flags |= ObjCClassFlags::Meta;
 
       // Non-metaclasses need us to record things whether primitive
       // construction/destructor is trivial.
       } else if (HasNonTrivialDestructor || HasNonTrivialConstructor) {
-        flags |= ClassFlags::HasCXXStructors;
+        flags |= ObjCClassFlags::HasCXXStructors;
         if (!HasNonTrivialConstructor)
-          flags |= ClassFlags::HasCXXDestructorOnly;
+          flags |= ObjCClassFlags::HasCXXDestructorOnly;
       }
 
-      // FIXME: set ClassFlags::Hidden when appropriate
+      // FIXME: set ObjCClassFlags::Hidden when appropriate
       return llvm::ConstantInt::get(IGM.Int32Ty, uint32_t(flags));
     }
 

lib/IRGen/GenMeta.cpp

@@ -2149,10 +2149,16 @@ namespace {
     }
 
     void addClassFlags() {
-      // Right now, we are not setting any flags.
-      // TODO: flag meaning "Swift 1.0"?
-      // TODO: flag saying "uses Swift refcounting"?
-      addConstantInt32(0);
+      // Always set a flag saying that this is a Swift 1.0 class.
+      ClassFlags flags = ClassFlags::IsSwift1;
+
+      // Set a flag if the class uses Swift 1.0 refcounting.
+      if (getReferenceCountingForClass(IGM, Target)
+            == ReferenceCounting::Native) {
+        flags |= ClassFlags::UsesSwift1Refcounting;
+      }
+
+      addConstantInt32((uint32_t) flags);
     }
 
     void addInstanceAddressPoint() {

stdlib/runtime/Casting.cpp

@@ -34,9 +34,7 @@ using namespace swift;
 using namespace metadataimpl;
 
 // Objective-C runtime entry points.
-extern "C" const ClassMetadata* object_getClass(const void *);
 extern "C" const char* class_getName(const ClassMetadata*);
-extern "C" const ClassMetadata* class_getSuperclass(const ClassMetadata*);
 
 // Aliases for Swift runtime entry points for Objective-C types.
 extern "C" const void *swift_dynamicCastObjCProtocolConditional(
@@ -114,14 +112,6 @@ _setupClassMask() {
 size_t swift::swift_classMask = _setupClassMask();
 uint8_t swift::swift_classShift = 0;
 
-#if SWIFT_OBJC_INTEROP
-/// Does this object use a tagged-pointer representation?
-static bool isTaggedPointerOrNull(const void *object) {
-  return ((uintptr_t)object & heap_object_abi::ObjCReservedBitsMask) || 
-         object == nullptr;
-}
-#endif
-
 /// Dynamically cast a class object to a Swift class type.
 const void *
 swift::swift_dynamicCastClass(const void *object,
@@ -130,20 +120,18 @@ swift::swift_dynamicCastClass(const void *object,
   assert(!targetType->isPureObjC());
 
   // Swift native classes never have a tagged-pointer representation.
-  if (isTaggedPointerOrNull(object)) {
+  if (isObjCTaggedPointerOrNull(object)) {
     return NULL;
   }
-
-  auto isa = reinterpret_cast<const ClassMetadata *>(object_getClass(object));
-#else
-  auto isa = *reinterpret_cast<const ClassMetadata *const*>(object);
 #endif
 
+  auto isa = _swift_getClassOfAllocated(object);
+
   do {
     if (isa == targetType) {
       return object;
     }
-    isa = isa->SuperClass;
+    isa = _swift_getSuperclass(isa);
   } while (isa);
 
   return NULL;
@@ -1477,7 +1465,7 @@ const void *swift::swift_conformsToProtocol(const Metadata *type,
   }
   case MetadataKind::ObjCClassWrapper: {
     auto wrapper = static_cast<const ObjCClassWrapperMetadata *>(type);
-    auto super = class_getSuperclass(wrapper->Class);
+    auto super = _swift_getSuperclass(wrapper->Class);
     if (!super)
       return cacheResult(nullptr);
 

stdlib/runtime/KnownMetadata.cpp

@@ -17,6 +17,7 @@
 #include "swift/Runtime/Metadata.h"
 #include "swift/Runtime/HeapObject.h"
 #include "MetadataImpl.h"
+#include "Private.h"
 #include <cstring>
 #include <climits>
 
@@ -120,7 +121,7 @@ int swift::swift_getHeapObjectExtraInhabitantIndex(HeapObject * const* src) {
 
   // Return -1 for ObjC tagged pointers.
   // FIXME: This check is unnecessary for known-Swift types.
-  if (val & ObjCReservedBitsMask)
+  if (isObjCTaggedPointer((const void*) val))
     return -1;
 
   return (int)(val >> ObjCReservedLowBits);

stdlib/runtime/NSSwiftXXXBase.mm.gyb

@@ -85,9 +85,6 @@ using namespace swift;
 }
 #pragma clang diagnostic pop
 
-- (bool) __usesNativeSwiftReferenceCounting {
-  return true;
-}
 @end
 % end
 

stdlib/runtime/Private.h

@@ -19,11 +19,15 @@
 
 #include "swift/Runtime/Config.h"
 #include "swift/Runtime/FastEntryPoints.h"
+#include "swift/Runtime/Metadata.h"
 #include "llvm/Support/Compiler.h"
 
 namespace swift {
   struct ProtocolDescriptor;
 
+  LLVM_LIBRARY_VISIBILITY
+  extern uintptr_t ISAMask;
+
   extern "C" LLVM_LIBRARY_VISIBILITY
   bool _swift_classConformsToObjCProtocol(const void *theClass,
                                     const ProtocolDescriptor *theProtocol);
@@ -44,6 +48,44 @@ namespace swift {
     return (mask & (mask + 1)) == 0;
   }
 
+  /// Return the class of an object which is known to be an allocated
+  /// heap object.
+  static inline const ClassMetadata *_swift_getClassOfAllocated(const void *object) {
+    // Load the isa field.
+    uintptr_t bits = *reinterpret_cast<const uintptr_t*>(object);
+    // Apply the mask.
+    bits &= ISAMask;
+    // The result is a class pointer.
+    return reinterpret_cast<const ClassMetadata *>(bits);
+  }
+
+#if SWIFT_OBJC_INTEROP
+  /// Is the given value an Objective-C tagged pointer?
+  static inline bool isObjCTaggedPointer(const void *object) {
+    return (((uintptr_t) object) & heap_object_abi::ObjCReservedBitsMask);
+  }
+
+  static inline bool isObjCTaggedPointerOrNull(const void *object) {
+    return object == nullptr || isObjCTaggedPointer(object);
+  }
+
+  LLVM_LIBRARY_VISIBILITY
+  const ClassMetadata *_swift_getClass(const void *object);
+#else
+  static inline const ClassMetadata *_swift_getClass(const void *object) {
+    return _swift_getClassOfAllocated(object);
+  }  
+#endif
+
+  static inline
+  const ClassMetadata *_swift_getSuperclass(const ClassMetadata *theClass) {
+    // This is kosher under the ABI.
+    return theClass->SuperClass;
+  }
+
+  LLVM_LIBRARY_VISIBILITY
+  bool usesNativeSwiftReferenceCounting(const ClassMetadata *theClass);
+
 } // end namespace swift
 
 #endif /* SWIFT_RUNTIME_PRIVATE_H */

stdlib/runtime/Reflection.mm

@@ -17,6 +17,7 @@
 #include "swift/Runtime/Metadata.h"
 #include "swift/Basic/Demangle.h"
 #include "Debug.h"
+#include "Private.h"
 #include <cassert>
 #include <cstring>
 #include <new>
@@ -32,8 +33,6 @@
 @interface DeclareSelectors
 
 - (id)debugQuickLookObject;
-- (bool) __usesNativeSwiftReferenceCounting;
-
 @end
 
 @class SwiftObject;
@@ -265,10 +264,10 @@ Any swift_MagicMirrorData_objcValue(HeapObject *owner,
                                     const Metadata *type) {
   Any result;
 
-  id object = *reinterpret_cast<const id *>(value);
-  auto isa = reinterpret_cast<const ClassMetadata *>(object_getClass(object));
+  void *object = *reinterpret_cast<void * const *>(value);
+  auto isa = _swift_getClass(object);
   result.Type = swift_getObjCClassMetadata(isa);
-  *reinterpret_cast<id *>(&result.Buffer) = [object retain];
+  *reinterpret_cast<void **>(&result.Buffer) = swift_unknownRetain(object);
   swift_release(owner);
   return result;
 }
@@ -328,8 +327,8 @@ void swift_MagicMirrorData_summary(const Metadata *T, String *result) {
 const Metadata *swift_MagicMirrorData_objcValueType(HeapObject *owner,
                                                     const OpaqueValue *value,
                                                     const Metadata *type) {
-  id object = *reinterpret_cast<const id *>(value);
-  auto isa = reinterpret_cast<const ClassMetadata *>(object_getClass(object));
+  void *object = *reinterpret_cast<void * const *>(value);
+  auto isa = _swift_getClass(object);
   swift_release(owner);
   return swift_getObjCClassMetadata(isa);
 }
@@ -447,14 +446,6 @@ intptr_t swift_ClassMirror_count(HeapObject *owner,
   return count;
 }
 
-/// Decide dynamically whether the given object uses native Swift
-/// reference-counting.
-static bool usesNativeSwiftReferenceCounting(void *object) {
-  // This could be *much* faster if it were integrated into the ObjC runtime.
-  assert(object);
-  return [(id) object __usesNativeSwiftReferenceCounting];
-}
-
 /// \param owner passed at +1, consumed.
 /// \param value passed unowned.
 extern "C"
@@ -489,8 +480,7 @@ StringMirrorTuple swift_ClassMirror_subscript(intptr_t i,
   // metadata, because we don't update the field offsets in the face of
   // resilient base classes.
   uintptr_t fieldOffset;
-  if (usesNativeSwiftReferenceCounting(*(void * const *)value)) {
-    
+  if (usesNativeSwiftReferenceCounting(Clas)) {
     fieldOffset = Clas->getFieldOffsets()[i];
   } else {
     Ivar *ivars = class_copyIvarList((Class)Clas, nullptr);
@@ -595,7 +585,7 @@ intptr_t swift_ObjCMirror_count(HeapObject *owner,
   }
 
   // The superobject counts as a child.
-  if (class_getSuperclass(isa))
+  if (_swift_getSuperclass((const ClassMetadata*) isa))
     count += 1;
 
   swift_release(owner);
@@ -623,7 +613,7 @@ StringMirrorTuple swift_ObjCMirror_subscript(intptr_t i,
   auto isa = (Class)type;
 
   // If there's a superclass, it becomes the first child.
-  if (auto sup = class_getSuperclass(isa)) {
+  if (auto sup = (Class) _swift_getSuperclass((const ClassMetadata*) isa)) {
     if (i == 0) {
       StringMirrorTuple result;
       const char *supName = class_getName(sup);
@@ -716,8 +706,7 @@ OptionalQuickLookObject swift_ClassMirror_quickLookObject(HeapObject *owner,
 
   /// Store an ObjC reference into an Any.
   auto setAnyToObject = [](Any &any, id obj) {
-    any.Type = swift_getObjCClassMetadata(
-                  reinterpret_cast<const ClassMetadata*>(object_getClass(obj)));
+    any.Type = swift_getObjCClassMetadata(_swift_getClass((const void*) obj));
     *reinterpret_cast<id *>(&any.Buffer) = [obj retain];
   };
 
@@ -862,8 +851,8 @@ static Mirror ObjC_getMirrorForSuperclass(Class sup,
 static MirrorTriple
 getImplementationForClass(const OpaqueValue *Value) {
   // Get the runtime type of the object.
-  id obj = *reinterpret_cast<const id *>(Value);
-  auto isa = reinterpret_cast<const ClassMetadata*>(object_getClass(obj));
+  const void *obj = *reinterpret_cast<const void * const *>(Value);
+  auto isa = _swift_getClass(obj);
 
   // If this is a pure ObjC class, reflect it using ObjC's runtime facilities.
   if (!isa->isTypeMetadata())