SIL: representation for specialized witness tables

eeckstein · eeckstein · commit 2950e4521e88 · 2024-09-25T19:32:08.000+02:00
The main change here is to associate a witness table with a `ProtocolConformance` instead of a `RootProtocolConformance`.
A `ProtocolConformance` is the base class and can be a `RootProtocolConformance` or a `SpecializedProtocolConformance`.
diff --git a/include/swift/AST/ASTMangler.h b/include/swift/AST/ASTMangler.h
@@ -239,7 +239,7 @@ class ASTMangler : public Mangler {
                                            const ConstructorDecl *Derived,
                                            bool isAllocating);
 
-  std::string mangleWitnessTable(const RootProtocolConformance *C);
+  std::string mangleWitnessTable(const ProtocolConformance *C);
 
   std::string mangleWitnessThunk(const ProtocolConformance *Conformance,
                                  const ValueDecl *Requirement);
diff --git a/include/swift/IRGen/Linking.h b/include/swift/IRGen/Linking.h
@@ -1075,7 +1075,7 @@ class LinkEntity {
     return entity;
   }
 
-  static LinkEntity forProtocolWitnessTable(const RootProtocolConformance *C) {
+  static LinkEntity forProtocolWitnessTable(const ProtocolConformance *C) {
     if (isEmbedded(C)) {
       assert(C->getProtocol()->requiresClass());
     }
@@ -1505,8 +1505,8 @@ class LinkEntity {
   }
 
   const RootProtocolConformance *getRootProtocolConformance() const {
-    assert(isRootProtocolConformanceKind(getKind()));
-    return cast<RootProtocolConformance>(getProtocolConformance());
+    assert(isProtocolConformanceKind(getKind()));
+    return getProtocolConformance()->getRootConformance();
   }
   
   const ProtocolConformance *getProtocolConformance() const {
diff --git a/include/swift/SIL/FormalLinkage.h b/include/swift/SIL/FormalLinkage.h
@@ -17,7 +17,7 @@ namespace swift {
 
 class CanGenericSignature;
 class CanType;
-class RootProtocolConformance;
+class ProtocolConformance;
 class ValueDecl;
 enum class SILLinkage : unsigned char;
 enum ForDefinition_t : bool;
@@ -53,7 +53,7 @@ FormalLinkage getGenericSignatureLinkage(CanGenericSignature signature);
 SILLinkage getSILLinkage(FormalLinkage linkage,
                          ForDefinition_t forDefinition);
 SILLinkage
-getLinkageForProtocolConformance(const RootProtocolConformance *C,
+getLinkageForProtocolConformance(const ProtocolConformance *C,
                                  ForDefinition_t definition);
 
 } // end swift namespace
diff --git a/include/swift/SIL/SILModule.h b/include/swift/SIL/SILModule.h
@@ -252,7 +252,7 @@ class SILModule {
       VTableEntryCache;
 
   /// Lookup table for SIL witness tables from conformances.
-  llvm::DenseMap<const RootProtocolConformance *, SILWitnessTable *>
+  llvm::DenseMap<const ProtocolConformance *, SILWitnessTable *>
   WitnessTableMap;
 
   /// The list of SILWitnessTables in the module.
diff --git a/include/swift/SIL/SILWitnessTable.h b/include/swift/SIL/SILWitnessTable.h
@@ -177,7 +177,7 @@ class SILWitnessTable : public llvm::ilist_node<SILWitnessTable>,
   SILLinkage Linkage;
 
   /// The conformance mapped to this witness table.
-  RootProtocolConformance *Conformance;
+  ProtocolConformance *Conformance;
 
   /// The various witnesses containing in this witness table. Is empty if the
   /// table has no witness entries or if it is a declaration.
@@ -201,33 +201,33 @@ class SILWitnessTable : public llvm::ilist_node<SILWitnessTable>,
 
   /// Private constructor for making SILWitnessTable definitions.
   SILWitnessTable(SILModule &M, SILLinkage Linkage, SerializedKind_t Serialized,
-                  StringRef name, RootProtocolConformance *conformance,
+                  StringRef name, ProtocolConformance *conformance,
                   ArrayRef<Entry> entries,
                   ArrayRef<ConditionalConformance> conditionalConformances);
 
   /// Private constructor for making SILWitnessTable declarations.
   SILWitnessTable(SILModule &M, SILLinkage Linkage, StringRef Name,
-                  RootProtocolConformance *conformance);
+                  ProtocolConformance *conformance);
 
   void addWitnessTable();
 
 public:
   /// Create a new SILWitnessTable definition with the given entries.
   static SILWitnessTable *
   create(SILModule &M, SILLinkage Linkage, SerializedKind_t SerializedKind,
-         RootProtocolConformance *conformance, ArrayRef<Entry> entries,
+         ProtocolConformance *conformance, ArrayRef<Entry> entries,
          ArrayRef<ConditionalConformance> conditionalConformances);
 
   /// Create a new SILWitnessTable declaration.
   static SILWitnessTable *create(SILModule &M, SILLinkage Linkage,
-                                 RootProtocolConformance *conformance);
+                                 ProtocolConformance *conformance);
 
   ~SILWitnessTable();
   
   SILModule &getModule() const { return Mod; }
 
   /// Return the AST ProtocolConformance this witness table represents.
-  RootProtocolConformance *getConformance() const {
+  ProtocolConformance *getConformance() const {
     return Conformance;
   }
 
diff --git a/lib/AST/ASTMangler.cpp b/lib/AST/ASTMangler.cpp
@@ -249,12 +249,15 @@ std::string ASTMangler::mangleConstructorVTableThunk(
   return finalize();
 }
 
-std::string ASTMangler::mangleWitnessTable(const RootProtocolConformance *C) {
+std::string ASTMangler::mangleWitnessTable(const ProtocolConformance *C) {
   llvm::SaveAndRestore X(AllowInverses,
                          inversesAllowedIn(C->getDeclContext()));
 
   beginMangling();
-  if (isa<NormalProtocolConformance>(C)) {
+  if (auto *sc = dyn_cast<SpecializedProtocolConformance>(C)) {
+    appendProtocolConformance(sc);
+    appendOperator("WP");
+  } else if (isa<NormalProtocolConformance>(C)) {
     appendProtocolConformance(C);
     appendOperator("WP");
   } else if (isa<SelfProtocolConformance>(C)) {
diff --git a/lib/IRGen/GenDecl.cpp b/lib/IRGen/GenDecl.cpp
@@ -6108,7 +6108,7 @@ IRGenModule::getAddrOfWitnessTableLazyCacheVariable(
 ///
 /// This can only be used with non-dependent conformances.
 llvm::Constant*
-IRGenModule::getAddrOfWitnessTable(const RootProtocolConformance *conf,
+IRGenModule::getAddrOfWitnessTable(const ProtocolConformance *conf,
                                    ConstantInit definition) {
   IRGen.addLazyWitnessTable(conf);
 
diff --git a/lib/IRGen/GenProto.cpp b/lib/IRGen/GenProto.cpp
@@ -1413,8 +1413,8 @@ class AccessorConformanceInfo : public ConformanceInfo {
 
     WitnessTableBuilderBase(IRGenModule &IGM, SILWitnessTable *SILWT)
         : IGM(IGM), SILWT(SILWT),
-          Conformance(*SILWT->getConformance()),
-          ConformanceInContext(*mapConformanceIntoContext(SILWT->getConformance())),
+          Conformance(*SILWT->getConformance()->getRootConformance()),
+          ConformanceInContext(*mapConformanceIntoContext(SILWT->getConformance()->getRootConformance())),
           ConcreteType(Conformance.getDeclContext()
                          ->mapTypeIntoContext(Conformance.getType())
                          ->getCanonicalType()) {}
@@ -2352,7 +2352,7 @@ void IRGenerator::ensureRelativeSymbolCollocation(SILWitnessTable &wt) {
 
   // Only resilient conformances use relative pointers for witness methods.
   if (wt.isDeclaration() || isAvailableExternally(wt.getLinkage()) ||
-      !CurrentIGM->isResilientConformance(wt.getConformance()))
+      !CurrentIGM->isResilientConformance(wt.getConformance()->getRootConformance()))
     return;
 
   for (auto &entry : wt.getEntries()) {
@@ -2592,14 +2592,15 @@ void IRGenModule::emitSILWitnessTable(SILWitnessTable *wt) {
   IRGen.ensureRelativeSymbolCollocation(*wt);
 
   auto conf = wt->getConformance();
+  RootProtocolConformance *rootConf = conf->getRootConformance();
   PrettyStackTraceConformance _st("emitting witness table for", conf);
 
   unsigned tableSize = 0;
   llvm::GlobalVariable *global = nullptr;
   llvm::Function *instantiationFunction = nullptr;
-  bool isDependent = isDependentConformance(conf);
+  bool isDependent = isDependentConformance(rootConf);
   SmallVector<llvm::Constant *, 4> resilientWitnesses;
-  bool isResilient = isResilientConformance(conf);
+  bool isResilient = isResilientConformance(rootConf);
   bool useRelativeProtocolWitnessTable =
     IRGen.Opts.UseRelativeProtocolWitnessTables;
   if (useRelativeProtocolWitnessTable &&
@@ -2659,7 +2660,7 @@ void IRGenModule::emitSILWitnessTable(SILWitnessTable *wt) {
   // Collect the information that will go into the protocol conformance
   // descriptor.
   unsigned tablePrivateSize = wt->getConditionalConformances().size();
-  ConformanceDescription description(conf, wt, global, tableSize,
+  ConformanceDescription description(rootConf, wt, global, tableSize,
                                      tablePrivateSize, isDependent);
 
   // Build the instantiation function, we if need one.
diff --git a/lib/IRGen/IRGenModule.h b/lib/IRGen/IRGenModule.h
@@ -1837,7 +1837,7 @@ private:                                                                       \
                                                const NormalProtocolConformance *C,
                                                CanType conformingType,
                                                ForDefinition_t forDefinition);
-  llvm::Constant *getAddrOfWitnessTable(const RootProtocolConformance *C,
+  llvm::Constant *getAddrOfWitnessTable(const ProtocolConformance *C,
                                       ConstantInit definition = ConstantInit());
   llvm::Constant *getAddrOfWitnessTablePattern(
                                       const NormalProtocolConformance *C,
diff --git a/lib/IRGen/Linking.cpp b/lib/IRGen/Linking.cpp
@@ -347,7 +347,7 @@ std::string LinkEntity::mangleAsString() const {
     return mangler.mangleFieldOffset(getDecl());
 
   case Kind::ProtocolWitnessTable:
-    return mangler.mangleWitnessTable(getRootProtocolConformance());
+    return mangler.mangleWitnessTable(getProtocolConformance());
 
   case Kind::GenericProtocolWitnessTableInstantiationFunction:
     return mangler.mangleGenericProtocolWitnessTableInstantiationFunction(
diff --git a/lib/SIL/IR/Linker.cpp b/lib/SIL/IR/Linker.cpp
@@ -260,16 +260,16 @@ void SILLinkerVisitor::visitProtocolConformance(ProtocolConformanceRef ref) {
   if (!VisitedConformances.insert(C).second)
     return;
 
-  auto *WT = Mod.lookUpWitnessTable(C);
-  
+  RootProtocolConformance *rootC = C->getRootConformance();
+  auto *WT = Mod.lookUpWitnessTable(rootC);
+
   if ((!WT || WT->isDeclaration()) &&
       (mustDeserialize || Mode == SILModule::LinkingMode::LinkAll)) {
     if (!WT) {
       // Marker protocols should never have witness tables.
       if (C->getProtocol()->isMarkerProtocol())
         return;
 
-      RootProtocolConformance *rootC = C->getRootConformance();
       SILLinkage linkage = getLinkageForProtocolConformance(rootC, NotForDefinition);
       WT = SILWitnessTable::create(Mod, linkage,
                                    const_cast<RootProtocolConformance *>(rootC));
diff --git a/lib/SIL/IR/SIL.cpp b/lib/SIL/IR/SIL.cpp
@@ -80,10 +80,10 @@ SILLinkage swift::getSILLinkage(FormalLinkage linkage,
 }
 
 SILLinkage
-swift::getLinkageForProtocolConformance(const RootProtocolConformance *C,
+swift::getLinkageForProtocolConformance(const ProtocolConformance *C,
                                         ForDefinition_t definition) {
   // If the conformance was synthesized, give it shared linkage.
-  if (C->isSynthesized())
+  if (C->getRootConformance()->isSynthesized())
     return SILLinkage::Shared;
 
   auto typeDecl = C->getDeclContext()->getSelfNominalTypeDecl();
diff --git a/lib/SIL/IR/SILModule.cpp b/lib/SIL/IR/SILModule.cpp
@@ -236,9 +236,8 @@ SILWitnessTable *
 SILModule::lookUpWitnessTable(const ProtocolConformance *C) {
   assert(C && "null conformance passed to lookUpWitnessTable");
 
-  auto rootC = C->getRootConformance();
   // Attempt to lookup the witness table from the table.
-  auto found = WitnessTableMap.find(rootC);
+  auto found = WitnessTableMap.find(C);
   if (found == WitnessTableMap.end())
     return nullptr;
 
@@ -540,7 +539,7 @@ SILModule::lookUpFunctionInWitnessTable(ProtocolConformanceRef C,
     SILLinkerVisitor linker(*this, linkingMode);
     linker.processConformance(C);
   }
-  SILWitnessTable *wt = lookUpWitnessTable(C.getConcrete());
+  SILWitnessTable *wt = lookUpWitnessTable(C.getConcrete()->getRootConformance());
 
   if (!wt) {
     LLVM_DEBUG(llvm::dbgs() << "        Failed speculative lookup of "
diff --git a/lib/SIL/IR/SILWitnessTable.cpp b/lib/SIL/IR/SILWitnessTable.cpp
@@ -31,7 +31,7 @@
 
 using namespace swift;
 
-static std::string mangleConstant(RootProtocolConformance *C) {
+static std::string mangleConstant(ProtocolConformance *C) {
   Mangle::ASTMangler Mangler;
   return Mangler.mangleWitnessTable(C);
 }
@@ -59,7 +59,7 @@ void SILWitnessTable::addWitnessTable() {
 
 SILWitnessTable *SILWitnessTable::create(
     SILModule &M, SILLinkage Linkage, SerializedKind_t SerializedKind,
-    RootProtocolConformance *Conformance,
+    ProtocolConformance *Conformance,
     ArrayRef<SILWitnessTable::Entry> entries,
     ArrayRef<ConditionalConformance> conditionalConformances) {
   assert(Conformance && "Cannot create a witness table for a null "
@@ -84,7 +84,7 @@ SILWitnessTable *SILWitnessTable::create(
 
 SILWitnessTable *
 SILWitnessTable::create(SILModule &M, SILLinkage Linkage,
-                        RootProtocolConformance *Conformance) {
+                        ProtocolConformance *Conformance) {
   assert(Conformance && "Cannot create a witness table for a null "
          "conformance.");
 
@@ -105,7 +105,7 @@ SILWitnessTable::create(SILModule &M, SILLinkage Linkage,
 
 SILWitnessTable::SILWitnessTable(
     SILModule &M, SILLinkage Linkage, SerializedKind_t SerializedKind, StringRef N,
-    RootProtocolConformance *Conformance, ArrayRef<Entry> entries,
+    ProtocolConformance *Conformance, ArrayRef<Entry> entries,
     ArrayRef<ConditionalConformance> conditionalConformances)
     : Mod(M), Name(N), Linkage(Linkage), Conformance(Conformance), Entries(),
       ConditionalConformances(), IsDeclaration(true),
@@ -114,7 +114,7 @@ SILWitnessTable::SILWitnessTable(
 }
 
 SILWitnessTable::SILWitnessTable(SILModule &M, SILLinkage Linkage, StringRef N,
-                                 RootProtocolConformance *Conformance)
+                                 ProtocolConformance *Conformance)
     : Mod(M), Name(N), Linkage(Linkage), Conformance(Conformance), Entries(),
       ConditionalConformances(), IsDeclaration(true),
       SerializedKind(IsNotSerialized) {}
diff --git a/lib/SIL/Utils/CalleeCache.cpp b/lib/SIL/Utils/CalleeCache.cpp
@@ -206,7 +206,7 @@ void CalleeCache::computeWitnessMethodCalleesForWitnessTable(
     // If we can't resolve the witness, conservatively assume it can call
     // anything.
     if (!Requirement.getDecl()->isProtocolRequirement() ||
-        !WT.getConformance()->hasWitness(Requirement.getDecl())) {
+        !WT.getConformance()->getRootConformance()->hasWitness(Requirement.getDecl())) {
       TheCallees.setInt(true);
       continue;
     }
@@ -229,7 +229,7 @@ void CalleeCache::computeWitnessMethodCalleesForWitnessTable(
         LLVM_FALLTHROUGH;
       case AccessLevel::FilePrivate:
       case AccessLevel::Private: {
-        auto Witness = Conf->getWitness(Requirement.getDecl());
+        auto Witness = Conf->getRootConformance()->getWitness(Requirement.getDecl());
         auto DeclRef = SILDeclRef(Witness.getDecl());
         canCallUnknown = !calleesAreStaticallyKnowable(M, DeclRef);
       }
diff --git a/lib/SIL/Verifier/SILVerifier.cpp b/lib/SIL/Verifier/SILVerifier.cpp
@@ -7677,7 +7677,7 @@ void SILModule::verify(CalleeCache *calleeCache,
 
   // Check all witness tables.
   LLVM_DEBUG(llvm::dbgs() <<"*** Checking witness tables for duplicates ***\n");
-  llvm::DenseSet<RootProtocolConformance*> wtableConformances;
+  llvm::DenseSet<ProtocolConformance*> wtableConformances;
   for (const SILWitnessTable &wt : getWitnessTables()) {
     LLVM_DEBUG(llvm::dbgs() << "Witness Table:\n"; wt.dump());
     auto conformance = wt.getConformance();
diff --git a/lib/SILOptimizer/IPO/DeadFunctionElimination.cpp b/lib/SILOptimizer/IPO/DeadFunctionElimination.cpp
@@ -37,14 +37,14 @@ class DeadFunctionAndGlobalElimination {
   /// method.
   struct FuncImpl {
     FuncImpl(SILFunction *F, ClassDecl *Cl) : F(F), Impl(Cl) {}
-    FuncImpl(SILFunction *F, RootProtocolConformance *C) : F(F), Impl(C) {}
+    FuncImpl(SILFunction *F, ProtocolConformance *C) : F(F), Impl(C) {}
 
     /// The implementing function.
     SILFunction *F;
 
     /// This is a class decl if we are tracking a class_method (i.e. a vtable
     /// method) and a protocol conformance if we are tracking a witness_method.
-    PointerUnion<ClassDecl *, RootProtocolConformance*> Impl;
+    PointerUnion<ClassDecl *, ProtocolConformance*> Impl;
   };
 
   /// Stores which functions implement a vtable or witness table method.
@@ -74,7 +74,7 @@ class DeadFunctionAndGlobalElimination {
     /// Adds an implementation of the method in a specific conformance.
     ///
     /// \p Conf is null for default implementations and move-only deinits
-    void addWitnessFunction(SILFunction *F, RootProtocolConformance *Conf) {
+    void addWitnessFunction(SILFunction *F, ProtocolConformance *Conf) {
       assert(isWitnessMethod);
       implementingFunctions.push_back(FuncImpl(F, Conf));
     }
@@ -328,7 +328,7 @@ class DeadFunctionAndGlobalElimination {
       return;
     mi->methodIsCalled = true;
     for (FuncImpl &FImpl : mi->implementingFunctions) {
-      if (auto Conf = FImpl.Impl.dyn_cast<RootProtocolConformance *>()) {
+      if (auto Conf = FImpl.Impl.dyn_cast<ProtocolConformance *>()) {
         SILWitnessTable *WT = Module->lookUpWitnessTable(Conf);
         if (!WT || isAlive(WT))
           makeAlive(FImpl.F);

Original file line number	Diff line number	Diff line change
`@@ -1075,7 +1075,7 @@ class LinkEntity {`
`1075`	`1075`	`return entity;`
`1076`	`1076`	`}`
`1077`	`1077`
`1078`		`- static LinkEntity forProtocolWitnessTable(const RootProtocolConformance *C) {`
	`1078`	`+ static LinkEntity forProtocolWitnessTable(const ProtocolConformance *C) {`
`1079`	`1079`	`if (isEmbedded(C)) {`
`1080`	`1080`	`assert(C->getProtocol()->requiresClass());`
`1081`	`1081`	`}`
`@@ -1505,8 +1505,8 @@ class LinkEntity {`
`1505`	`1505`	`}`
`1506`	`1506`
`1507`	`1507`	`const RootProtocolConformance *getRootProtocolConformance() const {`
`1508`		`- assert(isRootProtocolConformanceKind(getKind()));`
`1509`		`- return cast<RootProtocolConformance>(getProtocolConformance());`
	`1508`	`+ assert(isProtocolConformanceKind(getKind()));`
	`1509`	`+ return getProtocolConformance()->getRootConformance();`
`1510`	`1510`	`}`
`1511`	`1511`
`1512`	`1512`	`const ProtocolConformance *getProtocolConformance() const {`