[ABI] Put mangled inherited protocol witnesses into the resilient witness table

Emit mangled inherited protocol witnesses into the resilient witness table,
and realize them when we instantiate the resilient witness table. Don’t
put mangled inherited protocol witnesses into non-resilient witness tables:
there is no efficient way to make sure they are realized, so keep the
previous instantiation-function approach.

Implements the rest of rdar://problem/46282080.




(cherry picked from commit c0519c7)

Author: DougGregor

lib/IRGen/GenProto.cpp

@@ -1320,17 +1320,23 @@ class AccessorConformanceInfo : public ConformanceInfo {
     void addOutOfLineBaseProtocol(ProtocolDecl *baseProto) {
 #ifndef NDEBUG
       auto &entry = SILEntries.front();
+#endif
+      SILEntries = SILEntries.slice(1);
+
+      // Resilient conformances get a resilient witness table.
+      if (ResilientConformance)
+        return;
+
+#ifndef NDEBUG
       assert(entry.getKind() == SILWitnessTable::BaseProtocol
              && "sil witness table does not match protocol");
       assert(entry.getBaseProtocolWitness().Requirement == baseProto
              && "sil witness table does not match protocol");
       auto piIndex = PI.getBaseIndex(baseProto);
       assert((size_t)piIndex.getValue() ==
-              Table.size() - WitnessTableFirstRequirementOffset &&
+             Table.size() - WitnessTableFirstRequirementOffset &&
              "offset doesn't match ProtocolInfo layout");
 #endif
-      
-      SILEntries = SILEntries.slice(1);
 
       // TODO: Use the witness entry instead of falling through here.
 
@@ -1346,18 +1352,10 @@ class AccessorConformanceInfo : public ConformanceInfo {
         return;
       }
 
-      // Emit a mangled name.
-      if (isDependentConformance(astConf->getRootConformance(),
-                                 /*considerResilience=*/false))
-        RequiresSpecialization = true;
-
-      auto proto = Conformance.getProtocol();
-      CanType selfType = proto->getProtocolSelfType()->getCanonicalType();
-      AssociatedConformance requirement(proto, selfType, baseProto);
-      llvm::Constant *witnessEntry =
-        getAssociatedConformanceWitness(requirement, ConcreteType,
-                                        ProtocolConformanceRef(astConf));
-      Table.addBitCast(witnessEntry, IGM.Int8PtrTy);
+      // Otherwise, we'll need to derive it at instantiation time.
+      RequiresSpecialization = true;
+      SpecializedBaseConformances.push_back({Table.size(), &conf});
+      Table.addNullPointer(IGM.Int8PtrTy);
     }
 
     void addMethod(SILDeclRef requirement) {
@@ -1761,6 +1759,22 @@ void WitnessTableBuilder::collectResilientWitnesses(
       continue;
     }
 
+    // Inherited conformance witnesses.
+    if (entry.getKind() == SILWitnessTable::BaseProtocol) {
+      const auto &witness = entry.getBaseProtocolWitness();
+      auto baseProto = witness.Requirement;
+      auto proto = SILWT->getProtocol();
+      CanType selfType = proto->getProtocolSelfType()->getCanonicalType();
+      AssociatedConformance requirement(proto, selfType, baseProto);
+      ProtocolConformanceRef inheritedConformance =
+        ConformanceInContext.getAssociatedConformance(selfType, baseProto);
+      llvm::Constant *witnessEntry =
+        getAssociatedConformanceWitness(requirement, ConcreteType,
+                                        inheritedConformance);
+      resilientWitnesses.push_back(witnessEntry);
+      continue;
+    }
+
     if (entry.getKind() != SILWitnessTable::Method)
       continue;
 
@@ -1978,6 +1992,18 @@ namespace {
             IGM.getAddrOfLLVMVariableOrGOTEquivalent(
               LinkEntity::forAssociatedConformanceDescriptor(requirement));
           B.addRelativeAddress(assocConformanceDescriptor);
+        } else if (entry.getKind() == SILWitnessTable::BaseProtocol) {
+          // Associated conformance descriptor for a base protocol.
+          const auto &witness = entry.getBaseProtocolWitness();
+          auto proto = SILWT->getProtocol();
+          AssociatedConformance requirement(proto,
+                                            proto->getSelfInterfaceType()
+                                              ->getCanonicalType(),
+                                            witness.Requirement);
+          auto baseConformanceDescriptor =
+            IGM.getAddrOfLLVMVariableOrGOTEquivalent(
+              LinkEntity::forAssociatedConformanceDescriptor(requirement));
+          B.addRelativeAddress(baseConformanceDescriptor);
         } else if (entry.getKind() == SILWitnessTable::Method) {
           // Method descriptor.
           auto declRef = entry.getMethodWitness().Requirement;

stdlib/public/runtime/Metadata.cpp

@@ -3952,6 +3952,7 @@ static bool doesNotRequireInstantiation(
 /// witnesses stored in the generic witness table structure itself.
 static void initializeResilientWitnessTable(
                               const ProtocolConformanceDescriptor *conformance,
+                              const Metadata *conformingType,
                               const GenericWitnessTable *genericTable,
                               void **table) {
   auto protocol = conformance->getProtocol();
@@ -3965,7 +3966,7 @@ static void initializeResilientWitnessTable(
     auto reqDescriptor = witness.Requirement.get();
 
     // The requirement descriptor may be NULL, in which case this is a
-    // requirement introduced in a later version of the protocol./
+    // requirement introduced in a later version of the protocol.
     if (!reqDescriptor) continue;
 
     // If the requirement descriptor doesn't land within the bounds of the
@@ -3988,35 +3989,24 @@ static void initializeResilientWitnessTable(
   for (size_t i = 0, e = protocol->NumRequirements; i < e; ++i) {
     unsigned witnessIndex = WitnessTableFirstRequirementOffset + i;
 
+    // If we don't have a witness, fill in the default implementation.
     // If we already have a witness, there's nothing to do.
-    if (table[witnessIndex])
-      continue;
-
-    // Otherwise, fill in a default implementation.
     auto &reqt = requirements[i];
-    void *impl = reqt.DefaultImplementation.get();
-    table[witnessIndex] = impl;
-  }
-}
-
-/// Realize witness tables for base protocols.
-static void realizeBaseProtocolWitnessTables(const ProtocolDescriptor *protocol,
-                                             const Metadata *conformingType,
-                                             WitnessTable *witnessTable) {
-  // Loop over the requirements, realizing witness tables for base class
-  // conformances.
-  auto requirements = protocol->getRequirements();
-  auto baseReq = protocol->getRequirementBaseDescriptor();
-  for (size_t i = 0, e = protocol->NumRequirements; i < e; ++i) {
-    // Once we hit a non-base protocol requirement, we're done.
-    auto &reqt = requirements[i];
-    if (reqt.Flags.getKind() != ProtocolRequirementFlags::Kind::BaseProtocol)
-      break;
+    if (!table[witnessIndex]) {
+      void *impl = reqt.DefaultImplementation.get();
+      table[witnessIndex] = impl;
+    }
 
-    // Realize the base protocol witness table.
-    (void)swift_getAssociatedConformanceWitness(witnessTable,
-                                                conformingType, conformingType,
-                                                baseReq, &reqt);
+    // Realize base protocol witnesses.
+    if (reqt.Flags.getKind() == ProtocolRequirementFlags::Kind::BaseProtocol &&
+        table[witnessIndex]) {
+      // Realize the base protocol witness table.
+      auto baseReq = protocol->getRequirementBaseDescriptor();
+      (void)swift_getAssociatedConformanceWitness((WitnessTable *)table,
+                                                  conformingType,
+                                                  conformingType,
+                                                  baseReq, &reqt);
+    }
   }
 }
 
@@ -4079,9 +4069,8 @@ WitnessTableCacheEntry::allocate(
   }
 
   // Fill in any default requirements.
-  initializeResilientWitnessTable(conformance, genericTable, table);
+  initializeResilientWitnessTable(conformance, Type, genericTable, table);
   auto castTable = reinterpret_cast<WitnessTable*>(table);
-  realizeBaseProtocolWitnessTables(protocol, Type, castTable);
 
   // Call the instantiation function if present.
   if (!genericTable->Instantiator.isNull()) {
@@ -4114,10 +4103,7 @@ swift::swift_getWitnessTable(const ProtocolConformanceDescriptor *conformance,
   // accessor directly.
   auto genericTable = conformance->getGenericWitnessTable();
   if (!genericTable || doesNotRequireInstantiation(conformance, genericTable)) {
-    auto pattern = conformance->getWitnessTablePattern();
-    realizeBaseProtocolWitnessTables(conformance->getProtocol(), type,
-                                     const_cast<WitnessTable *>(pattern));
-    return uniqueForeignWitnessTableRef(pattern);
+    return uniqueForeignWitnessTableRef(conformance->getWitnessTablePattern());
   }
 
   auto &cache = getCache(genericTable);

test/IRGen/associated_type_witness.swift

@@ -97,6 +97,15 @@ struct Computed<T, U> : Assocked {
   typealias Assoc = Pair<T, U>
 }
 
+//   Instantiation function for GenericComputed : DerivedFromSimpleAssoc.
+// CHECK-LABEL: define internal void @"$s23associated_type_witness15GenericComputedVyxGAA22DerivedFromSimpleAssocAAWI"(i8**, %swift.type* %"GenericComputed<T>", i8**)
+// CHECK:         [[T0:%.*]] = call i8** @swift_getWitnessTable({{.*}}@"$s23associated_type_witness15GenericComputedVyxGAA14HasSimpleAssocAAMc"
+// CHECK-NEXT:    [[T1:%.*]] = bitcast i8** [[T0]] to i8*
+// CHECK-NEXT:    [[T2:%.*]] = getelementptr inbounds i8*, i8** %0, i32 1
+// CHECK-NEXT:    store i8* [[T1]], i8** [[T2]], align 8
+// CHECK-NEXT:    ret void
+
+
 struct PBox<T: P> {}
 protocol HasSimpleAssoc {
   associatedtype Assoc
@@ -106,7 +115,7 @@ protocol DerivedFromSimpleAssoc : HasSimpleAssoc {}
 //   Generic witness table pattern for GenericComputed : DerivedFromSimpleAssoc.
 // GLOBAL-LABEL: @"$s23associated_type_witness15GenericComputedVyxGAA22DerivedFromSimpleAssocAAWp" = internal constant [2 x i8*]
 // GLOBAL-SAME: @"$s23associated_type_witness15GenericComputedVyxGAA22DerivedFromSimpleAssocAAMc"
-// GLOBAL-SAME: @"associated conformance 23associated_type_witness15GenericComputedVyxGAA22DerivedFromSimpleAssocA2A03HashI0"
+// GLOBAL-SAME: i8* null
 
 //   Relative reference to private data
 struct GenericComputed<T: P> : DerivedFromSimpleAssoc {
@@ -139,5 +148,5 @@ struct UsesVoid : HasSimpleAssoc {
 // GLOBAL-SAME:    i16 2,
 // GLOBAL-SAME:    i16 1,
 
-//   No instantiator function needed
-// GLOBAL-SAME:    i32 0
+//   Relative reference to instantiator function
+// GLOBAL-SAME:    i32 trunc (i64 sub (i64 ptrtoint (void (i8**, %swift.type*, i8**)* @"$s23associated_type_witness15GenericComputedVyxGAA22DerivedFromSimpleAssocAAWI" to i64),

test/IRGen/generic_wt_linkage.sil

@@ -44,6 +44,6 @@ sil_default_witness_table hidden DerivedFromSimpleAssoc {
   no_default
 }
 
-// CHECK: define internal swiftcc i8** @"$s4test15GenericComputedVyxGAA22DerivedFromSimpleAssocAAxAA03HasfG0PWT"
+// CHECK: define internal void @"$s4test15GenericComputedVyxGAA22DerivedFromSimpleAssocAAWI"
 
 

test/IRGen/protocol_resilience_descriptors.swift

@@ -79,6 +79,12 @@ where Element: ProtocolWithRequirements, Element.T == Y {
   public func second() { }
 }
 
+// CHECK-USAGE: @"$s31protocol_resilience_descriptors17ConformsToDerivedV010resilient_A009ResilientF8ProtocolAAMc" =
+// CHECK-SAME: @"associated conformance 31protocol_resilience_descriptors17ConformsToDerivedV010resilient_A009ResilientF8ProtocolAaD0h4BaseI0"
+public struct ConformsToDerived : ResilientDerivedProtocol {
+  public func requirement() -> Int { return 0 }
+}
+
 // ----------------------------------------------------------------------------
 // Resilient protocol usage
 // ----------------------------------------------------------------------------