SIL representation

aschwaighofer · aschwaighofer · commit c2b2f1331f03 · 2021-10-06T04:54:49.000-07:00
diff --git a/include/swift/AST/Availability.h b/include/swift/AST/Availability.h
@@ -316,6 +316,9 @@ class AvailabilityInference {
   static Optional<AvailabilityContext> annotatedAvailableRange(const Decl *D,
                                                                ASTContext &C);
 
+  static AvailabilityContext
+    annotatedAvailableRangeForAttr(const SpecializeAttr* attr, ASTContext &ctx);
+
 };
 
 } // end namespace swift
diff --git a/include/swift/Parse/Parser.h b/include/swift/Parse/Parser.h
@@ -1049,7 +1049,7 @@ class Parser {
   /// \p Attr is where to store the parsed attribute
   bool parseSpecializeAttribute(
       swift::tok ClosingBrace, SourceLoc AtLoc, SourceLoc Loc,
-      SpecializeAttr *&Attr,
+      SpecializeAttr *&Attr, AvailabilityContext *SILAvailability,
       llvm::function_ref<bool(Parser &)> parseSILTargetName =
           [](Parser &) { return false; },
       llvm::function_ref<bool(Parser &)> parseSILSIPModule =
@@ -1060,6 +1060,7 @@ class Parser {
       swift::tok ClosingBrace, bool &DiscardAttribute, Optional<bool> &Exported,
       Optional<SpecializeAttr::SpecializationKind> &Kind,
       TrailingWhereClause *&TrailingWhereClause, DeclNameRef &targetFunction,
+      AvailabilityContext *SILAvailability,
       SmallVectorImpl<Identifier> &spiGroups,
       SmallVectorImpl<AvailableAttr *> &availableAttrs,
       llvm::function_ref<bool(Parser &)> parseSILTargetName,
diff --git a/include/swift/SIL/SILFunction.h b/include/swift/SIL/SILFunction.h
@@ -72,7 +72,8 @@ class SILSpecializeAttr final {
                                    GenericSignature specializedSignature,
                                    bool exported, SpecializationKind kind,
                                    SILFunction *target, Identifier spiGroup,
-                                   const ModuleDecl *spiModule);
+                                   const ModuleDecl *spiModule,
+                                   AvailabilityContext availability);
 
   bool isExported() const {
     return exported;
@@ -110,20 +111,26 @@ class SILSpecializeAttr final {
     return spiModule;
   }
 
+  AvailabilityContext getAvailability() const {
+    return availability;
+  }
+
   void print(llvm::raw_ostream &OS) const;
 
 private:
   SpecializationKind kind;
   bool exported;
   GenericSignature specializedSignature;
   Identifier spiGroup;
+  AvailabilityContext availability;
   const ModuleDecl *spiModule = nullptr;
   SILFunction *F = nullptr;
   SILFunction *targetFunction = nullptr;
 
   SILSpecializeAttr(bool exported, SpecializationKind kind,
                     GenericSignature specializedSignature, SILFunction *target,
-                    Identifier spiGroup, const ModuleDecl *spiModule);
+                    Identifier spiGroup, const ModuleDecl *spiModule,
+                    AvailabilityContext availability);
 };
 
 /// SILFunction - A function body that has been lowered to SIL. This consists of
diff --git a/lib/AST/Availability.cpp b/lib/AST/Availability.cpp
@@ -176,6 +176,33 @@ AvailabilityInference::annotatedAvailableRange(const Decl *D, ASTContext &Ctx) {
     VersionRange::allGTE(bestAvailAttr->Introduced.getValue())};
 }
 
+AvailabilityContext
+AvailabilityInference::annotatedAvailableRangeForAttr(const SpecializeAttr* attr,
+                                                      ASTContext &ctx) {
+
+  const AvailableAttr *bestAvailAttr = nullptr;
+
+  for (auto *availAttr : attr->getAvailabeAttrs()) {
+    if (availAttr == nullptr || !availAttr->Introduced.hasValue() ||
+        !availAttr->isActivePlatform(ctx) ||
+        availAttr->isLanguageVersionSpecific() ||
+        availAttr->isPackageDescriptionVersionSpecific()) {
+      continue;
+    }
+
+    if (isBetterThan(availAttr, bestAvailAttr))
+      bestAvailAttr = availAttr;
+  }
+
+  if (bestAvailAttr) {
+    return AvailabilityContext{
+      VersionRange::allGTE(bestAvailAttr->Introduced.getValue())
+    };
+  }
+
+  return AvailabilityContext::alwaysAvailable();
+}
+
 AvailabilityContext AvailabilityInference::availableRange(const Decl *D,
                                                           ASTContext &Ctx) {
   Optional<AvailabilityContext> AnnotatedRange =
diff --git a/lib/Parse/ParseDecl.cpp b/lib/Parse/ParseDecl.cpp
@@ -582,10 +582,11 @@ bool Parser::parseSpecializeAttributeArguments(
     swift::tok ClosingBrace, bool &DiscardAttribute, Optional<bool> &Exported,
     Optional<SpecializeAttr::SpecializationKind> &Kind,
     swift::TrailingWhereClause *&TrailingWhereClause,
-    DeclNameRef &targetFunction, SmallVectorImpl<Identifier> &spiGroups,
+    DeclNameRef &targetFunction, AvailabilityContext *SILAvailability, SmallVectorImpl<Identifier> &spiGroups,
     SmallVectorImpl<AvailableAttr *> &availableAttrs,
     llvm::function_ref<bool(Parser &)> parseSILTargetName,
     llvm::function_ref<bool(Parser &)> parseSILSIPModule) {
+  bool isSIL = SILAvailability != nullptr;
   SyntaxParsingContext ContentContext(SyntaxContext,
                                       SyntaxKind::SpecializeAttributeSpecList);
   // Parse optional "exported" and "kind" labeled parameters.
@@ -601,7 +602,8 @@ bool Parser::parseSpecializeAttributeArguments(
                               : SyntaxKind::LabeledSpecializeEntry));
       if (ParamLabel != "exported" && ParamLabel != "kind" &&
           ParamLabel != "target" && ParamLabel != "spi" &&
-          ParamLabel != "spiModule" && ParamLabel != "availability") {
+          ParamLabel != "spiModule" && ParamLabel != "availability" &&
+          (!isSIL || ParamLabel != "available")) {
         diagnose(Tok.getLoc(), diag::attr_specialize_unknown_parameter_name,
                  ParamLabel);
       }
@@ -627,6 +629,15 @@ bool Parser::parseSpecializeAttributeArguments(
         diagnose(Tok.getLoc(), diag::attr_specialize_parameter_already_defined,
                  ParamLabel);
       }
+      if (ParamLabel == "available") {
+        SourceRange range;
+        llvm::VersionTuple version;
+        if (parseVersionTuple(version, range,
+                                 diag::sil_availability_expected_version))
+          return false;
+
+        *SILAvailability = AvailabilityContext(VersionRange::allGTE(version));
+      }
       if (ParamLabel == "availability") {
         SourceRange attrRange;
         auto Loc = Tok.getLoc();
@@ -877,7 +888,7 @@ bool Parser::parseAvailability(
 
 bool Parser::parseSpecializeAttribute(
     swift::tok ClosingBrace, SourceLoc AtLoc, SourceLoc Loc,
-    SpecializeAttr *&Attr,
+    SpecializeAttr *&Attr, AvailabilityContext *SILAvailability,
     llvm::function_ref<bool(Parser &)> parseSILTargetName,
     llvm::function_ref<bool(Parser &)> parseSILSIPModule) {
   assert(ClosingBrace == tok::r_paren || ClosingBrace == tok::r_square);
@@ -896,7 +907,7 @@ bool Parser::parseSpecializeAttribute(
   SmallVector<AvailableAttr *, 4> availableAttrs;
   if (!parseSpecializeAttributeArguments(
           ClosingBrace, DiscardAttribute, exported, kind, trailingWhereClause,
-          targetFunction, spiGroups, availableAttrs, parseSILTargetName,
+          targetFunction, SILAvailability, spiGroups, availableAttrs, parseSILTargetName,
           parseSILSIPModule)) {
     return false;
   }
@@ -2588,7 +2599,7 @@ bool Parser::parseNewDeclAttribute(DeclAttributes &Attributes, SourceLoc AtLoc,
       return false;
     }
     SpecializeAttr *Attr;
-    if (!parseSpecializeAttribute(tok::r_paren, AtLoc, Loc, Attr))
+    if (!parseSpecializeAttribute(tok::r_paren, AtLoc, Loc, Attr, nullptr))
       return false;
 
     Attributes.add(Attr);
diff --git a/lib/SIL/IR/SILFunction.cpp b/lib/SIL/IR/SILFunction.cpp
@@ -40,9 +40,10 @@ STATISTIC(MaxBitfieldID, "Max value of SILFunction::currentBitfieldID");
 SILSpecializeAttr::SILSpecializeAttr(bool exported, SpecializationKind kind,
                                      GenericSignature specializedSig,
                                      SILFunction *target, Identifier spiGroup,
-                                     const ModuleDecl *spiModule)
+                                     const ModuleDecl *spiModule,
+                                     AvailabilityContext availability)
     : kind(kind), exported(exported), specializedSignature(specializedSig),
-      spiGroup(spiGroup), spiModule(spiModule), targetFunction(target) {
+      spiGroup(spiGroup), availability(availability), spiModule(spiModule), targetFunction(target) {
   if (targetFunction)
     targetFunction->incrementRefCount();
 }
@@ -51,10 +52,11 @@ SILSpecializeAttr *
 SILSpecializeAttr::create(SILModule &M, GenericSignature specializedSig,
                           bool exported, SpecializationKind kind,
                           SILFunction *target, Identifier spiGroup,
-                          const ModuleDecl *spiModule) {
+                          const ModuleDecl *spiModule,
+                          AvailabilityContext availability) {
   void *buf = M.allocate(sizeof(SILSpecializeAttr), alignof(SILSpecializeAttr));
   return ::new (buf) SILSpecializeAttr(exported, kind, specializedSig, target,
-                                       spiGroup, spiModule);
+                                       spiGroup, spiModule, availability);
 }
 
 void SILFunction::addSpecializeAttr(SILSpecializeAttr *Attr) {
diff --git a/lib/SIL/IR/SILFunctionBuilder.cpp b/lib/SIL/IR/SILFunctionBuilder.cpp
@@ -80,17 +80,20 @@ void SILFunctionBuilder::addFunctionAttributes(
     if (hasSPI) {
       spiGroupIdent = spiGroups[0];
     }
+    auto availability =
+      AvailabilityInference::annotatedAvailableRangeForAttr(SA,
+         M.getSwiftModule()->getASTContext());
     if (targetFunctionDecl) {
       SILDeclRef declRef(targetFunctionDecl, constant.kind, false);
       targetFunction = getOrCreateDeclaration(targetFunctionDecl, declRef);
       F->addSpecializeAttr(SILSpecializeAttr::create(
           M, SA->getSpecializedSignature(), SA->isExported(), kind,
           targetFunction, spiGroupIdent,
-          attributedFuncDecl->getModuleContext()));
+          attributedFuncDecl->getModuleContext(), availability));
     } else {
       F->addSpecializeAttr(SILSpecializeAttr::create(
           M, SA->getSpecializedSignature(), SA->isExported(), kind, nullptr,
-          spiGroupIdent, attributedFuncDecl->getModuleContext()));
+          spiGroupIdent, attributedFuncDecl->getModuleContext(), availability));
     }
   }
 
diff --git a/lib/SIL/IR/SILPrinter.cpp b/lib/SIL/IR/SILPrinter.cpp
@@ -3711,6 +3711,10 @@ void SILSpecializeAttr::print(llvm::raw_ostream &OS) const {
   if (targetFunction) {
     OS << "target: \"" << targetFunction->getName() << "\", ";
   }
+ if (!availability.isAlwaysAvailable()) {
+    auto version = availability.getOSVersion().getLowerEndpoint();
+    OS << "available: " << version.getAsString() << ", ";
+  }
   if (!requirements.empty()) {
     OS << "where ";
     SILFunction *F = getFunction();
diff --git a/lib/SIL/Parser/ParseSIL.cpp b/lib/SIL/Parser/ParseSIL.cpp
@@ -114,6 +114,7 @@ namespace {
     SILFunction *target = nullptr;
     Identifier spiGroupID;
     ModuleDecl *spiModule;
+    AvailabilityContext availability = AvailabilityContext::alwaysAvailable();
   };
 
   class SILParser {
@@ -1092,9 +1093,9 @@ static bool parseDeclSILOptional(bool *isTransparent,
       SpecializeAttr *Attr;
       StringRef targetFunctionName;
       ModuleDecl *module = nullptr;
-
+      AvailabilityContext availability = AvailabilityContext::alwaysAvailable();
       if (!SP.P.parseSpecializeAttribute(
-              tok::r_square, AtLoc, Loc, Attr,
+              tok::r_square, AtLoc, Loc, Attr, &availability,
               [&targetFunctionName](Parser &P) -> bool {
                 if (P.Tok.getKind() != tok::string_literal) {
                   P.diagnose(P.Tok, diag::expected_in_attribute_list);
@@ -1136,6 +1137,7 @@ static bool parseDeclSILOptional(bool *isTransparent,
                           : SILSpecializeAttr::SpecializationKind::Partial;
       SpecAttr.exported = Attr->isExported();
       SpecAttr.target = targetFunction;
+      SpecAttr.availability = availability;
       SpecAttrs->emplace_back(SpecAttr);
       if (!Attr->getSPIGroups().empty()) {
         SpecAttr.spiGroupID = Attr->getSPIGroups()[0];
@@ -6279,7 +6281,7 @@ bool SILParserState::parseDeclSIL(Parser &P) {
                 GenericSignature());
           FunctionState.F->addSpecializeAttr(SILSpecializeAttr::create(
               FunctionState.F->getModule(), genericSig, Attr.exported,
-              Attr.kind, Attr.target, Attr.spiGroupID, Attr.spiModule));
+              Attr.kind, Attr.target, Attr.spiGroupID, Attr.spiModule, Attr.availability));
         }
       }
 
diff --git a/lib/SILGen/SILGen.cpp b/lib/SILGen/SILGen.cpp
@@ -2209,9 +2209,12 @@ static void transferSpecializeAttributeTargets(SILGenModule &SGM, SILModule &M,
       if (hasSPIGroup) {
         spiGroupIdent = spiGroups[0];
       }
+      auto availability =
+        AvailabilityInference::annotatedAvailableRangeForAttr(SA,
+                                                              M.getSwiftModule()->getASTContext());
       targetSILFunction->addSpecializeAttr(SILSpecializeAttr::create(
           M, SA->getSpecializedSignature(), SA->isExported(), kind, nullptr,
-          spiGroupIdent, vd->getModuleContext()));
+          spiGroupIdent, vd->getModuleContext(), availability));
     }
   }
 }
diff --git a/lib/Serialization/DeserializeSIL.cpp b/lib/Serialization/DeserializeSIL.cpp
@@ -725,9 +725,11 @@ SILDeserializer::readSILFunctionChecked(DeclID FID, SILFunction *existingFn,
     IdentifierID targetFunctionID;
     IdentifierID spiGroupID;
     ModuleID spiModuleID;
+    unsigned LIST_VER_TUPLE_PIECES(available);
     SILSpecializeAttrLayout::readRecord(
         scratch, exported, specializationKindVal, specializedSigID,
-        targetFunctionID, spiGroupID, spiModuleID);
+        targetFunctionID, spiGroupID, spiModuleID,
+        LIST_VER_TUPLE_PIECES(available));
 
     SILFunction *target = nullptr;
     if (targetFunctionID) {
@@ -745,13 +747,19 @@ SILDeserializer::readSILFunctionChecked(DeclID FID, SILFunction *existingFn,
         specializationKindVal ? SILSpecializeAttr::SpecializationKind::Partial
                               : SILSpecializeAttr::SpecializationKind::Full;
 
+    llvm::VersionTuple available;
+    DECODE_VER_TUPLE(available);
+    auto availability = available.empty()
+      ? AvailabilityContext::alwaysAvailable()
+      : AvailabilityContext(VersionRange::allGTE(available));
+
     auto specializedSig = MF->getGenericSignature(specializedSigID);
     // Only add the specialize attributes once.
     if (shouldAddAtttributes) {
       // Read the substitution list and construct a SILSpecializeAttr.
       fn->addSpecializeAttr(SILSpecializeAttr::create(
           SILMod, specializedSig, exported != 0, specializationKind, target,
-          spiGroup, spiModule));
+          spiGroup, spiModule, availability));
     }
   }
 
diff --git a/lib/Serialization/SILFormat.h b/lib/Serialization/SILFormat.h
@@ -309,7 +309,8 @@ namespace sil_block {
                      GenericSignatureIDField, // specialized signature
                      DeclIDField, // Target SILFunction name or 0.
                      DeclIDField,  // SPIGroup or 0.
-                     DeclIDField // SPIGroup Module name id.
+                     DeclIDField, // SPIGroup Module name id.
+                     BC_AVAIL_TUPLE // Availability
                      >;
 
   // Has an optional argument list where each argument is a typed valueref.
diff --git a/lib/Serialization/Serialization.cpp b/lib/Serialization/Serialization.cpp
@@ -3114,12 +3114,15 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
   }
 
   void noteUseOfExportedPrespecialization(const AbstractFunctionDecl *afd) {
+    bool hasNoted = false;
     for (auto *A : afd->getAttrs().getAttributes<SpecializeAttr>()) {
       auto *SA = cast<SpecializeAttr>(A);
       if (!SA->isExported())
         continue;
       if (auto *targetFunctionDecl = SA->getTargetFunctionDecl(afd)) {
-        exportedPrespecializationDecls.push_back(S.addDeclRef(afd));
+        if (!hasNoted)
+          exportedPrespecializationDecls.push_back(S.addDeclRef(afd));
+        hasNoted = true;
       }
     }
   }
diff --git a/lib/Serialization/SerializeSIL.cpp b/lib/Serialization/SerializeSIL.cpp
@@ -509,11 +509,18 @@ void SILSerializer::writeSILFunction(const SILFunction &F, bool DeclOnly) {
       spiGroupID = S.addUniquedStringRef(ident.str());
       spiModuleDeclID = S.addModuleRef(SA->getSPIModule());
     }
+    auto availability = SA->getAvailability();
+    if (!availability.isAlwaysAvailable()) {
+      available = availability.getOSVersion().getLowerEndpoint();
+    }
+    ENCODE_VER_TUPLE(available, available)
+
     SILSpecializeAttrLayout::emitRecord(
         Out, ScratchRecord, specAttrAbbrCode, (unsigned)SA->isExported(),
         (unsigned)SA->getSpecializationKind(),
         S.addGenericSignatureRef(SA->getSpecializedSignature()),
-        targetFunctionNameID, spiGroupID, spiModuleDeclID);
+        targetFunctionNameID, spiGroupID, spiModuleDeclID,
+        LIST_VER_TUPLE_PIECES(available));
   }
 
   // Assign a unique ID to each basic block of the SILFunction.
diff --git a/test/SIL/Parser/available.sil b/test/SIL/Parser/available.sil
@@ -25,3 +25,11 @@ sil [available 123.321.444] @version_subminor : $@convention(thin) () -> ()
 
 // CHECK-LABEL: sil [weak_imported] @weak_func : $@convention(thin) () -> ()
 sil [weak_imported] @weak_func : $@convention(thin) () -> ()
+
+public struct SomeData {}
+
+// CHECK-LABEL: sil [_specialize exported: true, kind: full, available: 10.50, where T == SomeData] @specialize_availability : $@convention(thin) <T> (@in_guaranteed T) -> ()
+sil [_specialize exported: true, kind: full, available: 10.50, where T == SomeData] @specialize_availability : $@convention(thin) <T> (@in_guaranteed T) -> () {
+entry(%0 : $*T):
+  return undef: $()
+}
diff --git a/test/SIL/Serialization/available.sil b/test/SIL/Serialization/available.sil
@@ -7,6 +7,14 @@
 
 import Builtin
 
+public struct SomeData {}
+
+// CHECK-LABEL: sil [serialized] [_specialize exported: true, kind: full, available: 10.50, where T == SomeData] @specialize_availability : $@convention(thin) <T> (@in_guaranteed T) -> ()
+sil [serialized] [_specialize exported: true, kind: full, available: 10.50, where T == SomeData] @specialize_availability : $@convention(thin) <T> (@in_guaranteed T) -> () {
+bb0(%0 : $*T):
+  return undef : $()
+}
+
 // CHECK-LABEL: sil [serialized] [weak_imported] @weak_func : $@convention(thin) () -> ()
 sil [serialized] [weak_imported] @weak_func : $@convention(thin) () -> () {
 bb0:
diff --git a/test/SILGen/Inputs/specialize_attr_module2.swift b/test/SILGen/Inputs/specialize_attr_module2.swift
@@ -2,6 +2,7 @@ import A
 
 extension PublicThing {
   @_specialize(exported: true, kind: full, target: doStuffWith(_:), where T == Int)
+  @_specialize(exported: true, kind: full, target: doStuffWith(_:), availability: macOS 10.50, *; where T == Int16)
   public func specializedoStuff2(_ t: T) {}
 }
 
diff --git a/test/SILGen/availability_attribute.swift b/test/SILGen/availability_attribute.swift
diff --git a/test/SILGen/specialize_attr.swift b/test/SILGen/specialize_attr.swift

Original file line number	Diff line number	Diff line change
`@@ -2209,9 +2209,12 @@ static void transferSpecializeAttributeTargets(SILGenModule &SGM, SILModule &M,`
`2209`	`2209`	`if (hasSPIGroup) {`
`2210`	`2210`	`spiGroupIdent = spiGroups[0];`
`2211`	`2211`	`}`
	`2212`	`+ auto availability =`
	`2213`	`+ AvailabilityInference::annotatedAvailableRangeForAttr(SA,`
	`2214`	`+ M.getSwiftModule()->getASTContext());`
`2212`	`2215`	`targetSILFunction->addSpecializeAttr(SILSpecializeAttr::create(`
`2213`	`2216`	`M, SA->getSpecializedSignature(), SA->isExported(), kind, nullptr,`
`2214`		`- spiGroupIdent, vd->getModuleContext()));`
	`2217`	`+ spiGroupIdent, vd->getModuleContext(), availability));`
`2215`	`2218`	`}`
`2216`	`2219`	`}`
`2217`	`2220`	`}`