Make the caches be uintptr_t

This simplified a lot of things.  (Thanks @mikeash for the
suggestion!)

Also reorganized the code a bit.

Author: tbkka

stdlib/public/runtime/SwiftValue.mm

@@ -67,13 +67,18 @@ - (id)copyWithZone:(NSZone *)zone;
   /// The base type that introduces the `Hashable` or `Equatable` conformance.
   /// This member is lazily-initialized.
   /// Instead of using it directly, call `getHashableBaseType()` or `getEquatableBaseType()`
-  mutable std::atomic<const Metadata *> cachedBaseType;
+  /// Value here is encoded:
+  /// * Least-significant bit set: This is an Equatable base type
+  /// * Least-significant bit not set: This is a Hashable base type
+  mutable std::atomic<uintptr_t> cachedBaseType;
 
   /// The witness table for `Hashable` conformance.
-  /// This member is only available for native Swift errors.
   /// This member is lazily-initialized.
   /// Instead of using it directly, call `getHashableConformance()`.
-  mutable std::atomic<const void *> cachedConformance;
+  /// Value here is encoded:
+  /// * Least-significant bit set: This is an Equatable conformance
+  /// * Least-significant bit not set: This is a Hashable conformance
+  mutable std::atomic<uintptr_t> cachedConformance;
 
   /// Get the base type that conforms to `Hashable`.
   /// Returns NULL if the type does not conform.
@@ -93,101 +98,114 @@ - (id)copyWithZone:(NSZone *)zone;
 
   /// Populate the `cachedConformance` with the Hashable conformance
   /// (if there is one), else the Equatable conformance.
-  const void * cacheHashableEquatableConformance() const;
+  /// Returns the encoded conformance:  least-significant
+  /// bit is set if this is an Equatable conformance,
+  /// else it is a Hashable conformance.  0 (or 1) indicates
+  /// neither was found.
+  uintptr_t cacheHashableEquatableConformance() const;
 
 
   SwiftValueHeader()
-      : cachedBaseType(nullptr), cachedConformance((void *)nullptr) {}
+      : cachedBaseType(0), cachedConformance(0) {}
 };
 
-const Metadata *SwiftValueHeader::getHashableBaseType() const {
-  auto type = cachedBaseType.load(std::memory_order_acquire);
-  if (type == nullptr) {
-    cacheHashableEquatableConformance();
-    type = cachedBaseType.load(std::memory_order_acquire);
-  }
-  if ((reinterpret_cast<uintptr_t>(type) & 1) == 0) {
-    return type;
-  } else {
-    return nullptr;
-  }
-}
-
-const Metadata *SwiftValueHeader::getEquatableBaseType() const {
-  auto type = cachedBaseType.load(std::memory_order_acquire);
-  if (type == nullptr) {
-    cacheHashableEquatableConformance();
-    type = cachedBaseType.load(std::memory_order_acquire);
-  }
-  if ((reinterpret_cast<uintptr_t>(type) & 1) == 0) {
-    // A Hashable conformance was found
-    return nullptr;
-  } else {
-    // An Equatable conformance (or neither) was found
-    return reinterpret_cast<const Metadata *>(reinterpret_cast<uintptr_t>(type) & ~1ULL);
-  }
-}
-
 // Set cachedConformance to the Hashable conformance if
 // there is one, else the Equatable conformance.
 // Also set cachedBaseType to the parent type that
 // introduced the Hashable/Equatable conformance.
-// The cached conformance and type set the LSbit to indicate
-// which conformance is present:
+// The cached conformance and type are encoded:
 // * If the LSbit is not set, it's the Hashable conformance
 // * If the value is exactly 1, neither conformance is present
 // * If the LSbit is 1, strip it and you'll have the Equatable conformance
-// (Null indicates the cache has not been initialized yet)
-const void *
+// (Null indicates the cache has not been initialized yet;
+// that will never be true on exit of this function.)
+// Return: encoded cachedConformance value
+uintptr_t
 SwiftValueHeader::cacheHashableEquatableConformance() const {
     // Relevant conformance and baseType
-    const void * conformance;
-    const Metadata * baseType;
+    uintptr_t conformance;
+    uintptr_t baseType;
 
     // First, see if it's Hashable
     const HashableWitnessTable *hashable =
       reinterpret_cast<const HashableWitnessTable *>(
 	swift_conformsToProtocolCommon(type, &HashableProtocolDescriptor));
     if (hashable != nullptr) {
-      conformance = hashable;
-      baseType = findHashableBaseType(type);
+      conformance = reinterpret_cast<uintptr_t>(hashable);
+      baseType = reinterpret_cast<uintptr_t>(findHashableBaseType(type));
     } else {
       // If not Hashable, maybe Equatable?
       auto equatable = 
 	swift_conformsToProtocolCommon(type, &equatable_support::EquatableProtocolDescriptor);
-      conformance = reinterpret_cast<const void *>(reinterpret_cast<uintptr_t>(equatable) | 1);
+      // Encode the equatable conformance
+      conformance = reinterpret_cast<uintptr_t>(equatable) | 1;
 
-      // Find equatable base type
+      if (equatable != nullptr) {
+	// Find equatable base type
 #if SWIFT_STDLIB_USE_RELATIVE_PROTOCOL_WITNESS_TABLES
-      const auto *conformance = lookThroughOptionalConditionalWitnessTable(
-	reinterpret_cast<const RelativeWitnessTable*>(equatable))
-	->getDescription();
+	const auto *description = lookThroughOptionalConditionalWitnessTable(
+	  reinterpret_cast<const RelativeWitnessTable*>(equatable))
+	  ->getDescription();
 #else
-      const auto *conformance = equatable->getDescription();
+	const auto *description = equatable->getDescription();
 #endif
-      const Metadata *baseTypeThatConformsToEquatable =
-	findConformingSuperclass(type, conformance);
-      baseType = reinterpret_cast<const Metadata *>(reinterpret_cast<uintptr_t>(baseTypeThatConformsToEquatable) | 1);
+	const Metadata *baseTypeThatConformsToEquatable =
+	  findConformingSuperclass(type, description);
+	// Encode the equatable base type
+	baseType = reinterpret_cast<uintptr_t>(baseTypeThatConformsToEquatable) | 1;
+      } else {
+	baseType = 1; // Neither equatable nor hashable
+      }
     }
 
     // Set the conformance/baseType caches atomically
-    const void * expectedConformance = nullptr;
+    uintptr_t expectedConformance = 0;
     cachedConformance.compare_exchange_strong(
       expectedConformance, conformance, std::memory_order_acq_rel);
-    const Metadata * expectedType = (const Metadata *)nullptr;
+    uintptr_t expectedType = 0;
     cachedBaseType.compare_exchange_strong(
       expectedType, baseType, std::memory_order_acq_rel);
 
     return conformance;
 }
 
+const Metadata *SwiftValueHeader::getHashableBaseType() const {
+  auto type = cachedBaseType.load(std::memory_order_acquire);
+  if (type == 0) {
+    cacheHashableEquatableConformance();
+    type = cachedBaseType.load(std::memory_order_acquire);
+  }
+  if ((type & 1) == 0) {
+    // A Hashable conformance was found
+    return reinterpret_cast<const Metadata *>(type);
+  } else {
+    // Equatable conformance (or no conformance) found
+    return nullptr;
+  }
+}
+
+const Metadata *SwiftValueHeader::getEquatableBaseType() const {
+  auto type = cachedBaseType.load(std::memory_order_acquire);
+  if (type == 0) {
+    cacheHashableEquatableConformance();
+    type = cachedBaseType.load(std::memory_order_acquire);
+  }
+  if ((type & 1) == 0) {
+    // A Hashable conformance was found
+    return nullptr;
+  } else {
+    // An Equatable conformance (or neither) was found
+    return reinterpret_cast<const Metadata *>(type & ~1ULL);
+  }
+}
+
 const hashable_support::HashableWitnessTable *
 SwiftValueHeader::getHashableConformance() const {
-  const void * wt = cachedConformance.load(std::memory_order_acquire);
-  if (wt == nullptr) {
+  uintptr_t wt = cachedConformance.load(std::memory_order_acquire);
+  if (wt == 0) {
     wt = cacheHashableEquatableConformance();
   }
-  if ((reinterpret_cast<uintptr_t>(wt) & 1) == 0) {
+  if ((wt & 1) == 0) {
     // Hashable conformance found
     return reinterpret_cast<const hashable_support::HashableWitnessTable *>(wt);
   } else {
@@ -198,16 +216,16 @@ - (id)copyWithZone:(NSZone *)zone;
 
 const equatable_support::EquatableWitnessTable *
 SwiftValueHeader::getEquatableConformance() const {
-  const void * wt = cachedConformance.load(std::memory_order_acquire);
-  if (wt == nullptr) {
+  uintptr_t wt = cachedConformance.load(std::memory_order_acquire);
+  if (wt == 0) {
     wt = cacheHashableEquatableConformance();
   }
-  if ((reinterpret_cast<uintptr_t>(wt) & 1) == 0) {
+  if ((wt & 1) == 0) {
     // Hashable conformance found
     return nullptr;
   } else {
     // Equatable conformance (or no conformance) found
-    return reinterpret_cast<const equatable_support::EquatableWitnessTable *>(reinterpret_cast<uintptr_t>(wt) & ~1ULL);
+    return reinterpret_cast<const equatable_support::EquatableWitnessTable *>(wt & ~1ULL);
   }
 }
 
@@ -395,10 +413,8 @@ - (BOOL)isEqual:(id)other {
   auto selfHeader = getSwiftValueHeader(self);
   auto otherHeader = getSwiftValueHeader(other);
 
-  auto hashableConformance = selfHeader->getHashableConformance();
-  if (hashableConformance) {
-    auto selfHashableBaseType = selfHeader->getHashableBaseType();
-    if (selfHashableBaseType) {
+  if (auto hashableConformance = selfHeader->getHashableConformance()) {
+    if (auto selfHashableBaseType = selfHeader->getHashableBaseType()) {
       auto otherHashableBaseType = otherHeader->getHashableBaseType();
       if (selfHashableBaseType == otherHashableBaseType) {
         return _swift_stdlib_Hashable_isEqual_indirect(
@@ -411,10 +427,8 @@ - (BOOL)isEqual:(id)other {
     }
   }
 
-  auto equatableConformance = selfHeader->getEquatableConformance();
-  if (equatableConformance) {
-    auto selfEquatableBaseType = selfHeader->getEquatableBaseType();
-    if (selfEquatableBaseType) {
+  if (auto equatableConformance = selfHeader->getEquatableConformance()) {
+    if (auto selfEquatableBaseType = selfHeader->getEquatableBaseType()) {
       auto otherEquatableBaseType = otherHeader->getEquatableBaseType();
       if (selfEquatableBaseType == otherEquatableBaseType) {
         return _swift_stdlib_Equatable_isEqual_indirect(