Merge pull request swiftlang#28610 from nate-chandler/generic-metadata-prespecialization

Generic metadata prespecialization, part 1

Author: nate-chandler

include/swift/ABI/Metadata.h

@@ -697,6 +697,8 @@ struct TargetMetadata {
 
   bool satisfiesClassConstraint() const;
 
+  bool isCanonicalStaticallySpecializedGenericMetadata() const;
+
 #if SWIFT_OBJC_INTEROP
   /// Get the ObjC class object for this type if it has one, or return null if
   /// the type is not a class (or not a class with a class object).
@@ -1348,6 +1350,34 @@ struct TargetStructMetadata : public TargetValueMetadata<Runtime> {
     return reinterpret_cast<const uint32_t *>(asWords + offset);
   }
 
+  bool isCanonicalStaticallySpecializedGenericMetadata() const {
+    auto *description = getDescription();
+    if (!description->isGeneric())
+      return false;
+
+    auto *trailingFlags = getTrailingFlags();
+    if (trailingFlags == nullptr)
+      return false;
+
+    return trailingFlags->isCanonicalStaticSpecialization();
+  }
+
+  const MetadataTrailingFlags *getTrailingFlags() const {
+    auto description = getDescription();
+    auto flags = description->getFullGenericContextHeader()
+                     .DefaultInstantiationPattern->PatternFlags;
+    if (!flags.hasTrailingFlags())
+      return nullptr;
+    auto fieldOffset = description->FieldOffsetVectorOffset;
+    auto offset =
+        fieldOffset +
+        // Pad to the nearest pointer.
+        ((description->NumFields * sizeof(uint32_t) + sizeof(void *) - 1) /
+         sizeof(void *));
+    auto asWords = reinterpret_cast<const void *const *>(this);
+    return reinterpret_cast<const MetadataTrailingFlags *>(asWords + offset);
+  }
+
   static constexpr int32_t getGenericArgumentOffset() {
     return sizeof(TargetStructMetadata<Runtime>) / sizeof(StoredPointer);
   }
@@ -3575,7 +3605,7 @@ struct TargetSingletonMetadataInitialization {
   }
 
   /// This method can only be called from the runtime itself. It is defined
-  /// in MetadataCache.h.
+  /// in Metadata.cpp.
   TargetMetadata<Runtime> *allocate(
       const TargetTypeContextDescriptor<Runtime> *description) const;
 };

include/swift/ABI/MetadataValues.h

@@ -1511,6 +1511,10 @@ class GenericMetadataPatternFlags : public FlagSet<uint32_t> {
     /// Does this pattern have an extra-data pattern?
     HasExtraDataPattern = 0,
 
+    /// Do instances of this pattern have a bitset of flags that occur at the
+    /// end of the metadata, after the extra data if there is any?
+    HasTrailingFlags = 1,
+
     // Class-specific flags.
 
     /// Does this pattern have an immediate-members pattern?
@@ -1535,6 +1539,10 @@ class GenericMetadataPatternFlags : public FlagSet<uint32_t> {
                                 hasExtraDataPattern,
                                 setHasExtraDataPattern)
 
+  FLAGSET_DEFINE_FLAG_ACCESSORS(HasTrailingFlags,
+                                hasTrailingFlags,
+                                setHasTrailingFlags)
+
   FLAGSET_DEFINE_FIELD_ACCESSORS(Value_MetadataKind,
                                  Value_MetadataKind_width,
                                  MetadataKind,
@@ -1667,6 +1675,30 @@ class MetadataRequest : public FlagSet<size_t> {
   }
 };
 
+struct MetadataTrailingFlags : public FlagSet<uint64_t> {
+  enum {
+    /// Whether this metadata is a specialization of a generic metadata pattern
+    /// which was created during compilation.
+    IsStaticSpecialization = 0,
+
+    /// Whether this metadata is a specialization of a generic metadata pattern
+    /// which was created during compilation and made to be canonical by
+    /// modifying the metadata accessor.
+    IsCanonicalStaticSpecialization = 1,
+  };
+
+  explicit MetadataTrailingFlags(uint64_t bits) : FlagSet(bits) {}
+  constexpr MetadataTrailingFlags() {}
+
+  FLAGSET_DEFINE_FLAG_ACCESSORS(IsStaticSpecialization,
+                                isStaticSpecialization,
+                                setIsStaticSpecialization)
+
+  FLAGSET_DEFINE_FLAG_ACCESSORS(IsCanonicalStaticSpecialization,
+                                isCanonicalStaticSpecialization,
+                                setIsCanonicalStaticSpecialization)
+};
+
 /// Flags for Builtin.IntegerLiteral values.
 class IntegerLiteralFlags {
 public:

include/swift/AST/ASTContext.h

@@ -614,6 +614,14 @@ class ASTContext final {
   /// swift_getTypeByMangledNameInContextInMetadataState.
   AvailabilityContext getTypesInAbstractMetadataStateAvailability();
 
+  /// Get the runtime availability of support for prespecialized generic 
+  /// metadata.
+  AvailabilityContext getPrespecializedGenericMetadataAvailability();
+
+  /// Get the runtime availability of features introduced in the Swift 5.2
+  /// compiler for the target platform.
+  AvailabilityContext getSwift52Availability();
+
 
   //===--------------------------------------------------------------------===//
   // Diagnostics Helper functions

include/swift/AST/Decl.h

@@ -2864,7 +2864,7 @@ class GenericTypeDecl : public GenericContext, public TypeDecl {
 /// code. One is formed implicitly when a declaration is written with an opaque
 /// result type, as in:
 ///
-/// func foo() -> opaque SignedInteger { return 1 }
+/// func foo() -> some SignedInteger { return 1 }
 ///
 /// The declared type is a special kind of ArchetypeType representing the
 /// abstracted underlying type.

include/swift/AST/IRGenOptions.h

@@ -190,6 +190,10 @@ class IRGenOptions {
   /// Passing this flag completely disables this behavior.
   unsigned DisableLegacyTypeInfo : 1;
 
+  /// Create metadata specializations for generic types at statically known type
+  /// arguments.
+  unsigned PrespecializeGenericMetadata : 1;
+
   /// The path to load legacy type layouts from.
   StringRef ReadLegacyTypeInfoPath;
 
@@ -255,8 +259,9 @@ class IRGenOptions {
         EnableAnonymousContextMangledNames(false), ForcePublicLinkage(false),
         LazyInitializeClassMetadata(false),
         LazyInitializeProtocolConformances(false), DisableLegacyTypeInfo(false),
-        UseIncrementalLLVMCodeGen(true), UseSwiftCall(false),
-        GenerateProfile(false), EnableDynamicReplacementChaining(false),
+        PrespecializeGenericMetadata(false), UseIncrementalLLVMCodeGen(true),
+        UseSwiftCall(false), GenerateProfile(false),
+        EnableDynamicReplacementChaining(false),
         DisableRoundTripDebugTypes(false), DisableDebuggerShadowCopies(false),
         CmdArgs(), SanitizeCoverage(llvm::SanitizerCoverageOptions()),
         TypeInfoFilter(TypeInfoDumpFilter::All) {}

include/swift/IRGen/Linking.h

@@ -65,7 +65,7 @@ class UniversalLinkageInfo {
   bool shouldAllPrivateDeclsBeVisibleFromOtherFiles() const {
     return HasMultipleIGMs;
   }
-  /// In case of multipe llvm modules, private lazy protocol
+  /// In case of multiple llvm modules, private lazy protocol
   /// witness table accessors could be emitted by two different IGMs during
   /// IRGen into different object files and the linker would complain about
   /// duplicate symbols.

include/swift/Option/FrontendOptions.td

@@ -644,6 +644,10 @@ def disable_verify_exclusivity : Flag<["-"], "disable-verify-exclusivity">,
 def disable_legacy_type_info : Flag<["-"], "disable-legacy-type-info">,
   HelpText<"Completely disable legacy type layout">;
 
+def prespecialize_generic_metadata : Flag<["-"], "prespecialize-generic-metadata">,
+  HelpText<"Statically specialize metadata for generic types at types that "
+           "are known to be used in source.">;
+
 def read_legacy_type_info_path_EQ : Joined<["-"], "read-legacy-type-info-path=">,
   HelpText<"Read legacy type layout from the given path instead of default path">;
 

lib/AST/Availability.cpp

@@ -239,14 +239,25 @@ AvailabilityContext ASTContext::getSwift51Availability() {
 }
 
 AvailabilityContext ASTContext::getTypesInAbstractMetadataStateAvailability() {
+  return getSwift52Availability();
+}
+
+AvailabilityContext ASTContext::getPrespecializedGenericMetadataAvailability() {
+  return getSwift52Availability();
+}
+
+AvailabilityContext ASTContext::getSwift52Availability() {
   auto target = LangOpts.Target;
 
   if (target.isMacOSX() ) {
     return AvailabilityContext(
         VersionRange::allGTE(llvm::VersionTuple(10, 99, 0)));
-  } else if (target.isiOS() || target.isWatchOS()) {
+  } else if (target.isiOS()) {
+    return AvailabilityContext(
+        VersionRange::allGTE(llvm::VersionTuple(99, 0, 0)));
+  } else if (target.isWatchOS()) {
     return AvailabilityContext(
-        VersionRange::allGTE(llvm::VersionTuple(9999, 0, 0)));
+        VersionRange::allGTE(llvm::VersionTuple(9, 99, 0)));
   } else {
     return AvailabilityContext::alwaysAvailable();
   }

lib/Frontend/CompilerInvocation.cpp

@@ -1245,6 +1245,10 @@ static bool ParseIRGenArgs(IRGenOptions &Opts, ArgList &Args,
     Opts.DisableLegacyTypeInfo = true;
   }
 
+  if (Args.hasArg(OPT_prespecialize_generic_metadata)) {
+    Opts.PrespecializeGenericMetadata = true;
+  }
+
   if (const Arg *A = Args.getLastArg(OPT_read_legacy_type_info_path_EQ)) {
     Opts.ReadLegacyTypeInfoPath = A->getValue();
   }

lib/IRGen/ClassMetadataVisitor.h

@@ -204,8 +204,13 @@ class ClassMetadataScanner : public ClassMetadataVisitor<Impl> {
       addPointer();
     }
   }
-  void addGenericArgument(ClassDecl *forClass) { addPointer(); }
-  void addGenericWitnessTable(ClassDecl *forClass) { addPointer(); }
+  void addGenericArgument(GenericRequirement requirement, ClassDecl *forClass) {
+    addPointer();
+  }
+  void addGenericWitnessTable(GenericRequirement requirement,
+                              ClassDecl *forClass) {
+    addPointer();
+  }
   void addPlaceholder(MissingMemberDecl *MMD) {
     for (auto i : range(MMD->getNumberOfVTableEntries())) {
       (void)i;