IRGen: Initial support for relative protocol witness table emission

Author: aschwaighofer

include/swift/AST/IRGenOptions.h

@@ -422,6 +422,9 @@ class IRGenOptions {
   /// Collocate metadata functions in their own section.
   unsigned CollocatedMetadataFunctions : 1;
 
+  /// Use relative (and constant) protocol witness tables.
+  unsigned UseRelativeProtocolWitnessTables : 1;
+
   /// The number of threads for multi-threaded code generation.
   unsigned NumThreads = 0;
 
@@ -493,7 +496,8 @@ class IRGenOptions {
         InternalizeAtLink(false), InternalizeSymbols(false),
         EmitGenericRODatas(false), NoPreallocatedInstantiationCaches(false),
         DisableReadonlyStaticObjects(false),
-        CollocatedMetadataFunctions(false), CmdArgs(),
+        CollocatedMetadataFunctions(false),
+        UseRelativeProtocolWitnessTables(false), CmdArgs(),
         SanitizeCoverage(llvm::SanitizerCoverageOptions()),
         TypeInfoFilter(TypeInfoDumpFilter::All) {
 #ifndef NDEBUG

include/swift/Option/FrontendOptions.td

@@ -1119,6 +1119,13 @@ def disable_collocate_metadata_functions :
   Flag<["-"], "disable-collocate-metadata-functions">,
   HelpText<"Disable collocate metadata functions">;
 
+def enable_relative_protocol_witness_tables :
+  Flag<["-"], "enable-relative-protocol-witness-tables">,
+  HelpText<"Enable relative protocol witness tables">;
+def disable_relative_protocol_witness_tables :
+  Flag<["-"], "disable-relative-protocol-witness-tables">,
+  HelpText<"Disable relative protocol witness tables">;
+
 def enable_new_llvm_pass_manager :
   Flag<["-"], "enable-new-llvm-pass-manager">,
   HelpText<"Enable the new llvm pass manager">;

include/swift/Runtime/Metadata.h

@@ -354,6 +354,11 @@ swift_getWitnessTable(const ProtocolConformanceDescriptor *conformance,
                       const Metadata *type,
                       const void * const *instantiationArgs);
 
+const WitnessTable *
+swift_getWitnessTableRelative(const ProtocolConformanceDescriptor *conformance,
+                      const Metadata *type,
+                      const void * const *instantiationArgs);
+
 /// Retrieve an associated type witness from the given witness table.
 ///
 /// \param wtable The witness table.
@@ -369,6 +374,13 @@ MetadataResponse swift_getAssociatedTypeWitness(
                                           const Metadata *conformingType,
                                           const ProtocolRequirement *reqBase,
                                           const ProtocolRequirement *assocType);
+SWIFT_RUNTIME_EXPORT SWIFT_CC(swift)
+MetadataResponse swift_getAssociatedTypeWitnessRelative(
+                                          MetadataRequest request,
+                                          WitnessTable *wtable,
+                                          const Metadata *conformingType,
+                                          const ProtocolRequirement *reqBase,
+                                          const ProtocolRequirement *assocType);
 
 /// Retrieve an associated conformance witness table from the given witness
 /// table.
@@ -388,6 +400,14 @@ const WitnessTable *swift_getAssociatedConformanceWitness(
                                   const ProtocolRequirement *reqBase,
                                   const ProtocolRequirement *assocConformance);
 
+SWIFT_RUNTIME_EXPORT SWIFT_CC(swift)
+const WitnessTable *swift_getAssociatedConformanceWitnessRelative(
+                                  WitnessTable *wtable,
+                                  const Metadata *conformingType,
+                                  const Metadata *assocType,
+                                  const ProtocolRequirement *reqBase,
+                                  const ProtocolRequirement *assocConformance);
+
 /// Determine whether two protocol conformance descriptors describe the same
 /// conformance of a type to a protocol.
 ///

include/swift/Runtime/RuntimeFunctions.def

@@ -907,6 +907,13 @@ FUNCTION(GetWitnessTable, swift_getWitnessTable, C_CC, AlwaysAvailable,
               WitnessTablePtrPtrTy),
          ATTRS(NoUnwind, ReadOnly),
          EFFECT(MetaData)) // ?
+FUNCTION(GetWitnessTableRelative, swift_getWitnessTableRelative, C_CC, AlwaysAvailable,
+         RETURNS(WitnessTablePtrTy),
+         ARGS(ProtocolConformanceDescriptorPtrTy,
+              TypeMetadataPtrTy,
+              WitnessTablePtrPtrTy),
+         ATTRS(NoUnwind, ReadOnly),
+         EFFECT(MetaData)) // ?
 
 // MetadataResponse swift_getAssociatedTypeWitness(
 //                                            MetadataRequest request,
@@ -924,6 +931,16 @@ FUNCTION(GetAssociatedTypeWitness, swift_getAssociatedTypeWitness,
               ProtocolRequirementStructTy->getPointerTo()),
          ATTRS(NoUnwind, ReadNone, WillReturn),
          EFFECT(MetaData)) // ?
+FUNCTION(GetAssociatedTypeWitnessRelative, swift_getAssociatedTypeWitnessRelative,
+         SwiftCC, AlwaysAvailable,
+         RETURNS(TypeMetadataResponseTy),
+         ARGS(SizeTy,
+              WitnessTablePtrTy,
+              TypeMetadataPtrTy,
+              ProtocolRequirementStructTy->getPointerTo(),
+              ProtocolRequirementStructTy->getPointerTo()),
+         ATTRS(NoUnwind, ReadNone, WillReturn),
+         EFFECT(MetaData)) // ?
 
 // SWIFT_RUNTIME_EXPORT SWIFT_CC(swift)
 // const WitnessTable *swift_getAssociatedConformanceWitness(
@@ -942,6 +959,16 @@ FUNCTION(GetAssociatedConformanceWitness,
               ProtocolRequirementStructTy->getPointerTo()),
          ATTRS(NoUnwind, ReadNone, WillReturn),
          EFFECT(MetaData)) // ?
+FUNCTION(GetAssociatedConformanceWitnessRelative,
+         swift_getAssociatedConformanceWitnessRelative, SwiftCC, AlwaysAvailable,
+         RETURNS(WitnessTablePtrTy),
+         ARGS(WitnessTablePtrTy,
+              TypeMetadataPtrTy,
+              TypeMetadataPtrTy,
+              ProtocolRequirementStructTy->getPointerTo(),
+              ProtocolRequirementStructTy->getPointerTo()),
+         ATTRS(NoUnwind, ReadNone, WillReturn),
+         EFFECT(MetaData)) // ?
 
 // SWIFT_RUNTIME_EXPORT
 //     SWIFT_CC(swift) bool swift_compareProtocolConformanceDescriptors(

lib/Frontend/CompilerInvocation.cpp

@@ -2482,6 +2482,10 @@ static bool ParseIRGenArgs(IRGenOptions &Opts, ArgList &Args,
       Args.hasFlag(OPT_enable_collocate_metadata_functions,
                    OPT_disable_collocate_metadata_functions,
                    Opts.CollocatedMetadataFunctions);
+  Opts.UseRelativeProtocolWitnessTables =
+    Args.hasFlag(OPT_enable_relative_protocol_witness_tables,
+                 OPT_disable_relative_protocol_witness_tables,
+                 Opts.UseRelativeProtocolWitnessTables);
   return false;
 }
 

lib/IRGen/GenOpaque.cpp

@@ -308,9 +308,20 @@ llvm::PointerType *IRGenModule::getEnumValueWitnessTablePtrTy() {
 
 Address irgen::slotForLoadOfOpaqueWitness(IRGenFunction &IGF,
                                           llvm::Value *table,
-                                          WitnessIndex index) {
+                                          WitnessIndex index,
+                                          bool areEntriesRelative) {
   assert(table->getType() == IGF.IGM.WitnessTablePtrTy);
 
+  // Are we loading from a relative protocol witness table.
+  if (areEntriesRelative) {
+    llvm::Value *slot =
+      IGF.Builder.CreateBitOrPointerCast(table, IGF.IGM.RelativeAddressPtrTy);
+    if (index.getValue() != 0)
+      slot = IGF.Builder.CreateConstInBoundsGEP1_32(IGF.IGM.RelativeAddressTy,
+                                                    slot, index.getValue());
+    return Address(slot, IGF.IGM.RelativeAddressTy, Alignment(4));
+  }
+
   // GEP to the appropriate index, avoiding spurious IR in the trivial case.
   llvm::Value *slot = table;
   if (index.getValue() != 0)
@@ -326,8 +337,12 @@ llvm::Value *irgen::emitInvariantLoadOfOpaqueWitness(IRGenFunction &IGF,
                                                      llvm::Value *table,
                                                      WitnessIndex index,
                                                      llvm::Value **slotPtr) {
-  auto slot = slotForLoadOfOpaqueWitness(IGF, table, index);
+  auto isRelativeTable = IGF.IGM.IRGen.Opts.UseRelativeProtocolWitnessTables;
+  auto slot = slotForLoadOfOpaqueWitness(IGF, table, index, isRelativeTable);
   if (slotPtr) *slotPtr = slot.getAddress();
+  if (isRelativeTable) {
+    return IGF.emitLoadOfRelativePointer(slot, false, IGF.IGM.Int8Ty);
+  }
   return IGF.emitInvariantLoad(slot);
 }
 

lib/IRGen/GenOpaque.h

@@ -40,8 +40,11 @@ namespace irgen {
 
   /// Given a witness table (protocol or value), return the address of the slot
   /// for one of the witnesses.
+  /// If \p areEntriesRelative is true we are emitting code for a relative
+  /// protocol witness table.
   Address slotForLoadOfOpaqueWitness(IRGenFunction &IGF, llvm::Value *table,
-                                     WitnessIndex index);
+                                     WitnessIndex index,
+                                     bool areEntriesRelative = false);
 
   /// Given a witness table (protocol or value), load one of the
   /// witnesses.