IRGen: support emitting specialized witness tables

Author: eeckstein

lib/IRGen/GenDecl.cpp

@@ -1335,7 +1335,6 @@ void IRGenerator::emitLazyDefinitions() {
     for (SILFunction *f : LazyFunctionDefinitions) {
       ASSERT(hasValidSignatureForEmbedded(f));
     }
-    assert(LazyWitnessTables.empty());
     assert(LazyCanonicalSpecializedMetadataAccessors.empty());
     assert(LazyMetadataAccessors.empty());
     // LazyClassMetadata is allowed

lib/IRGen/GenProto.cpp

@@ -1363,6 +1363,26 @@ class DirectConformanceInfo : public ConformanceInfo {
   }
 };
 
+/// Conformance info for a witness table that can be directly generated.
+class SpecializedConformanceInfo : public ConformanceInfo {
+  friend ProtocolInfo;
+
+  const SpecializedProtocolConformance *Conformance;
+public:
+  SpecializedConformanceInfo(const SpecializedProtocolConformance *C)
+      : Conformance(C) {}
+
+  llvm::Value *getTable(IRGenFunction &IGF,
+                        llvm::Value **conformingMetadataCache) const override {
+    return IGF.IGM.getAddrOfWitnessTable(Conformance);
+  }
+
+  llvm::Constant *tryGetConstantTable(IRGenModule &IGM,
+                                      CanType conformingType) const override {
+    return IGM.getAddrOfWitnessTable(Conformance);
+  }
+};
+
 /// Conformance info for a witness table that is (or may be) dependent.
 class AccessorConformanceInfo : public ConformanceInfo {
   friend ProtocolInfo;
@@ -2454,10 +2474,19 @@ IRGenModule::getConformanceInfo(const ProtocolDecl *protocol,
   if (auto found = checkCache(conformance))
     return *found;
 
+  const ConformanceInfo *info;
+
+  if (Context.LangOpts.hasFeature(Feature::Embedded)) {
+    if (auto *sc = dyn_cast<SpecializedProtocolConformance>(conformance)) {
+      info = new SpecializedConformanceInfo(sc);
+      Conformances.try_emplace(conformance, info);
+      return *info;
+    }
+  }
+
   //  Drill down to the root normal
   auto rootConformance = conformance->getRootConformance();
 
-  const ConformanceInfo *info;
   // If the conformance is dependent in any way, we need to unique it.
   // Under a relative protocol witness table implementation conformances are
   // always direct.
@@ -2657,22 +2686,24 @@ void IRGenModule::emitSILWitnessTable(SILWitnessTable *wt) {
     wtableBuilder.collectResilientWitnesses(resilientWitnesses);
   }
 
-  // Collect the information that will go into the protocol conformance
-  // descriptor.
-  unsigned tablePrivateSize = wt->getConditionalConformances().size();
-  ConformanceDescription description(rootConf, wt, global, tableSize,
-                                     tablePrivateSize, isDependent);
+  if (!Context.LangOpts.hasFeature(Feature::Embedded)) {
+    // Collect the information that will go into the protocol conformance
+    // descriptor.
+    unsigned tablePrivateSize = wt->getConditionalConformances().size();
+    ConformanceDescription description(rootConf, wt, global, tableSize,
+                                       tablePrivateSize, isDependent);
 
-  // Build the instantiation function, we if need one.
-  description.instantiationFn = instantiationFunction;
-  description.resilientWitnesses = std::move(resilientWitnesses);
+    // Build the instantiation function, we if need one.
+    description.instantiationFn = instantiationFunction;
+    description.resilientWitnesses = std::move(resilientWitnesses);
 
-  // Record this conformance descriptor.
-  addProtocolConformance(std::move(description));
+    // Record this conformance descriptor.
+    addProtocolConformance(std::move(description));
 
-  IRGen.noteUseOfTypeContextDescriptor(
-      conf->getDeclContext()->getSelfNominalTypeDecl(),
-      RequireMetadata);
+    IRGen.noteUseOfTypeContextDescriptor(
+        conf->getDeclContext()->getSelfNominalTypeDecl(),
+        RequireMetadata);
+  }
 }
 
 /// True if a function's signature in LLVM carries polymorphic parameters.

lib/IRGen/IRGenModule.cpp

@@ -1381,6 +1381,10 @@ bool IRGenerator::canEmitWitnessTableLazily(SILWitnessTable *wt) {
   if (Opts.UseJIT)
     return false;
 
+  // witness tables are always emitted lazily in embedded swift.
+  if (SIL.getASTContext().LangOpts.hasFeature(Feature::Embedded))
+    return true;
+
   // Regardless of the access level, if the witness table is shared it means
   // we can safely not emit it. Every other module which needs it will generate
   // its own shared copy of it.