[Runtime] Move conformance kind into low bits of witness table reference.

Move the 2-bit conformance reference kind from the conformance flags (which
is meant to go away) into the lower two bits of the witness table offset.

Author: DougGregor

docs/ABI/TypeMetadata.rst

@@ -417,21 +417,23 @@ section, which is scanned by the Swift runtime when needed (e.g., in response to
 a `swift_conformsToProtocol()` query). Each protocol conformance record
 contains:
 
-- The `protocol descriptor`_ describing the protocol of the conformance.
-- A reference to the metadata for the **conforming type**, whose form is
+- The `protocol descriptor`_ describing the protocol of the conformance,
+  represented as an indirect 32-bit offset relative to the field.
+- A reference to the metadata for the **conforming type**, represented as
+  an indirect 32-bit offset relative to the field, whose form is
   determined by the **protocol conformance flags** described below.
 - The **witness table field** that provides access to the witness table
-  describing the conformance itself; the form of this field is determined by the
-  **protocol conformance flags** described below.
-- The **protocol conformance flags** is a 32-bit field comprised of:
-
-  * **Bits 0-3** contain the type metadata record kind, which indicates how
-    the **conforming type** field is encoded.
-  * **Bits 4-5** contain the kind of witness table. The value can be one of:
-
+  describing the conformance itself; the form of this field is determined by
+  the lower two bits, and can be one of:
     0. The **witness table field** is a reference to a witness table.
     1. The **witness table field** is a reference to a **witness table
        accessor** function for an unconditional conformance.
     2. The **witness table field** is a reference to a **witness table
        accessor** function for a conditional conformance.
+    3. Reserved for future use.
+  All references are direct 32-bit offsets relative to the field.
+- The **protocol conformance flags** is a 32-bit field comprised of:
+
+  * **Bits 0-3** contain the type metadata record kind, which indicates how
+    the **conforming type** field is encoded.
 

include/swift/ABI/MetadataValues.h

@@ -253,13 +253,6 @@ struct TypeMetadataRecordFlags {
 
 // Protocol conformance discriminant
 struct ProtocolConformanceFlags : public TypeMetadataRecordFlags {
-private:
-  enum : int_type {
-    ConformanceKindMask = 0x00000030U,
-    ConformanceKindShift = 4,
-  };
-
-public:
   constexpr ProtocolConformanceFlags() : TypeMetadataRecordFlags(0) {}
   constexpr ProtocolConformanceFlags(int_type Data) : TypeMetadataRecordFlags(Data) {}
 
@@ -268,15 +261,6 @@ struct ProtocolConformanceFlags : public TypeMetadataRecordFlags {
     return ProtocolConformanceFlags(
                      (Data & ~TypeKindMask) | (int_type(ptk) << TypeKindShift));
   }
-  constexpr ProtocolConformanceReferenceKind getConformanceKind() const {
-    return ProtocolConformanceReferenceKind((Data & ConformanceKindMask)
-                                     >> ConformanceKindShift);
-  }
-  constexpr ProtocolConformanceFlags withConformanceKind(
-                                  ProtocolConformanceReferenceKind pck) const {
-    return ProtocolConformanceFlags(
-       (Data & ~ConformanceKindMask) | (int_type(pck) << ConformanceKindShift));
-  }
 };
 
 /// Flag that indicates whether an existential type is class-constrained or not.

include/swift/Basic/RelativePointer.h

@@ -398,9 +398,6 @@ class RelativeDirectPointerIntPair {
     = delete;
 
   static Offset getMask() {
-    static_assert(alignof(PointeeTy) >= alignof(Offset),
-                 "pointee alignment must be at least as strict as offset type");
-
     return alignof(Offset) - 1;
   }
 

include/swift/Runtime/Metadata.h

@@ -2555,11 +2555,15 @@ struct TargetProtocolConformanceRecord {
   // The conformance, or a generator function for the conformance.
   union {
     /// A direct reference to the witness table for the conformance.
-    RelativeDirectPointer<const WitnessTable> WitnessTable;
+    RelativeDirectPointerIntPair<const WitnessTable,
+                                 ProtocolConformanceReferenceKind>
+      WitnessTable;
 
     /// A function that produces the witness table given an instance of the
     /// type.
-    RelativeDirectPointer<WitnessTableAccessorFn> WitnessTableAccessor;
+    RelativeDirectPointerIntPair<WitnessTableAccessorFn,
+                                 ProtocolConformanceReferenceKind>
+      WitnessTableAccessor;
   };
 
   /// Flags describing the protocol conformance.
@@ -2569,16 +2573,17 @@ struct TargetProtocolConformanceRecord {
   const ProtocolDescriptor *getProtocol() const {
     return Protocol;
   }
-  
+
   ProtocolConformanceFlags getFlags() const {
     return Flags;
   }
 
   TypeMetadataRecordKind getTypeKind() const {
     return Flags.getTypeKind();
   }
+
   ProtocolConformanceReferenceKind getConformanceKind() const {
-    return Flags.getConformanceKind();
+    return WitnessTable.getInt();
   }
 
   const TargetMetadata<Runtime> *getDirectType() const {
@@ -2658,7 +2663,7 @@ struct TargetProtocolConformanceRecord {
 
   /// Get the directly-referenced static witness table.
   const swift::WitnessTable *getStaticWitnessTable() const {
-    switch (Flags.getConformanceKind()) {
+    switch (getConformanceKind()) {
     case ProtocolConformanceReferenceKind::WitnessTable:
       break;
 
@@ -2669,11 +2674,11 @@ struct TargetProtocolConformanceRecord {
     case ProtocolConformanceReferenceKind::Reserved:
       break;
     }
-    return WitnessTable;
+    return WitnessTable.getPointer();
   }
 
   WitnessTableAccessorFn *getWitnessTableAccessor() const {
-    switch (Flags.getConformanceKind()) {
+    switch (getConformanceKind()) {
     case ProtocolConformanceReferenceKind::WitnessTableAccessor:
     case ProtocolConformanceReferenceKind::ConditionalWitnessTableAccessor:
     case ProtocolConformanceReferenceKind::Reserved:
@@ -2682,7 +2687,7 @@ struct TargetProtocolConformanceRecord {
     case ProtocolConformanceReferenceKind::WitnessTable:
       assert(false && "not witness table accessor");
     }
-    return WitnessTableAccessor;
+    return WitnessTableAccessor.getPointer();
   }
 
   /// Get the canonical metadata for the type referenced by this record, or

lib/IRGen/GenDecl.cpp

@@ -2340,33 +2340,32 @@ llvm::Constant *IRGenModule::emitProtocolConformances() {
     // Figure out what kind of witness table we have.
     auto flags = typeEntity.flags;
     llvm::Constant *witnessTableVar;
+    ProtocolConformanceReferenceKind conformanceKind;
     if (!isResilient(conformance->getProtocol(),
                      ResilienceExpansion::Maximal) &&
         conformance->getConditionalRequirements().empty()) {
-      flags = flags.withConformanceKind(
-          ProtocolConformanceReferenceKind::WitnessTable);
+      conformanceKind = ProtocolConformanceReferenceKind::WitnessTable;
 
       // If the conformance is in this object's table, then the witness table
       // should also be in this object file, so we can always directly reference
       // it.
       witnessTableVar = getAddrOfWitnessTable(conformance);
     } else {
       if (conformance->getConditionalRequirements().empty()) {
-        flags = flags.withConformanceKind(
-            ProtocolConformanceReferenceKind::WitnessTableAccessor);
+        conformanceKind =
+          ProtocolConformanceReferenceKind::WitnessTableAccessor;
       } else {
-        flags = flags.withConformanceKind(
-            ProtocolConformanceReferenceKind::ConditionalWitnessTableAccessor);
+        conformanceKind =
+          ProtocolConformanceReferenceKind::ConditionalWitnessTableAccessor;
       }
 
       witnessTableVar = getAddrOfWitnessTableAccessFunction(
           conformance, ForDefinition);
     }
 
     // Relative reference to the witness table.
-    auto witnessTableRef =
-      ConstantReference(witnessTableVar, ConstantReference::Direct);
-    record.addRelativeAddress(witnessTableRef);
+    record.addTaggedRelativeOffset(RelativeAddressTy, witnessTableVar,
+                                   static_cast<unsigned>(conformanceKind));
 
     // Flags.
     record.addInt(Int32Ty, flags.getValue());

test/IRGen/protocol_conformance_records.swift

@@ -93,9 +93,9 @@ public protocol Spoon { }
 // -- nominal type descriptor
 // CHECK-SAME:           @_T028protocol_conformance_records17NativeGenericTypeVMn
 // -- witness table accessor
-// CHECK-SAME:           @_T028protocol_conformance_records17NativeGenericTypeVyxGAA5SpoonA2aERzlWa
-// -- flags 0x04: unique nominal type descriptor + conditional accessor
-// CHECK-SAME:           i32 36
+// CHECK-SAME:           i32 add{{.*}}@_T028protocol_conformance_records17NativeGenericTypeVyxGAA5SpoonA2aERzlWa{{.*}}i32 2),
+// -- flags 0x04: unique nominal type descriptor
+// CHECK-SAME:           i32 4
 // CHECK-SAME:         }
 extension NativeGenericType : Spoon where T: Spoon {
   public func runce() {}