Merge pull request #6609 from DougGregor/sil-generic-env-serialization

Author: swift-ci

include/swift/Serialization/DeclTypeRecordNodes.def

@@ -164,7 +164,7 @@ OTHER(GENERIC_PARAM_LIST, 240)
 TRAILING_INFO(GENERIC_PARAM)
 TRAILING_INFO(GENERIC_REQUIREMENT)
 OTHER(GENERIC_ENVIRONMENT, 243)
-TRAILING_INFO(SIL_GENERIC_ENVIRONMENT)
+OTHER(SIL_GENERIC_ENVIRONMENT, 244)
 
 OTHER(LOCAL_DISCRIMINATOR, 248)
 OTHER(PRIVATE_DISCRIMINATOR, 249)

include/swift/Serialization/ModuleFile.h

@@ -529,6 +529,17 @@ class ModuleFile : public LazyMemberLoader {
                         serialization::DeclID willSet,
                         serialization::DeclID didSet);
 
+  /// Return the generic signature or environment at the current position in
+  /// the given cursor.
+  ///
+  /// \param cursor The cursor to read from.
+  /// \param wantEnvironment Whether we always want to receive a generic
+  /// environment vs. being able to handle the generic signature.
+  llvm::PointerUnion<GenericSignature *, GenericEnvironment *>
+  readGenericSignatureOrEnvironment(
+                        llvm::BitstreamCursor &cursor,
+                        bool wantEnvironment);
+
 public:
   /// Loads a module from the given memory buffer.
   ///
@@ -741,20 +752,6 @@ class ModuleFile : public LazyMemberLoader {
   /// is loaded instead.
   Module *getModule(ArrayRef<Identifier> name);
 
-  /// Return the generic signature or environment at the current position in
-  /// the given cursor.
-  ///
-  /// \param cursor The cursor to read from.
-  /// \param wantEnvironment Whether we always want to receive a generic
-  /// environment vs. being able to handle the generic signature.
-  /// \param optRequirements If not \c None, use these generic requirements
-  /// rather than deserializing requirements.
-  llvm::PointerUnion<GenericSignature *, GenericEnvironment *>
-  readGenericSignatureOrEnvironment(
-                        llvm::BitstreamCursor &cursor,
-                        bool wantEnvironment,
-                        Optional<ArrayRef<Requirement>> optRequirements);
-
   /// Returns the generic signature or environment for the given ID,
   /// deserializing it if needed.
   ///

include/swift/Serialization/ModuleFormat.h

@@ -54,7 +54,7 @@ const uint16_t VERSION_MAJOR = 0;
 /// in source control, you should also update the comment to briefly
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
-const uint16_t VERSION_MINOR = 302; // Last change: SIL box type substitutions
+const uint16_t VERSION_MINOR = 303; // Last change: SIL generic environments
 
 using DeclID = PointerEmbeddedInt<unsigned, 31>;
 using DeclIDField = BCFixed<31>;

lib/Serialization/Deserialization.cpp

@@ -967,8 +967,7 @@ void ModuleFile::configureGenericEnvironment(
 llvm::PointerUnion<GenericSignature *, GenericEnvironment *>
 ModuleFile::readGenericSignatureOrEnvironment(
                         llvm::BitstreamCursor &cursor,
-                        bool wantEnvironment,
-                        Optional<ArrayRef<Requirement>> optRequirements) {
+                        bool wantEnvironment) {
   using namespace decls_block;
 
   SmallVector<uint64_t, 8> scratch;
@@ -1068,14 +1067,8 @@ ModuleFile::readGenericSignatureOrEnvironment(
   }
 
   // Read the generic requirements.
-  ArrayRef<Requirement> requirements;
-  SmallVector<Requirement, 4> requirementsVec;
-  if (optRequirements) {
-    requirements = *optRequirements;
-  } else {
-    readGenericRequirements(requirementsVec, cursor);
-    requirements = requirementsVec;
-  }
+  SmallVector<Requirement, 4> requirements;
+  readGenericRequirements(requirements, cursor);
 
   // Construct the generic signature from the loaded parameters and
   // requirements.
@@ -1113,15 +1106,20 @@ ModuleFile::getGenericSignatureOrEnvironment(
   // Read the generic environment.
   BCOffsetRAII restoreOffset(DeclTypeCursor);
   DeclTypeCursor.JumpToBit(envOrOffset);
+  DeserializingEntityRAII deserializingEntity(*this);
 
   auto result = readGenericSignatureOrEnvironment(DeclTypeCursor,
-                                                  wantEnvironment,
-                                                  None);
+                                                  wantEnvironment);
   if (result.isNull()) {
     envOrOffset = nullptr;
     return envOrOffset.get();
   }
 
+  // If we've already deserialized this generic environment, return it.
+  if (envOrOffset.isComplete()) {
+    return envOrOffset.get();
+  }
+
   if (auto signature = result.dyn_cast<GenericSignature *>()) {
     assert(!wantEnvironment && "Reader should have produced the environment");
     return signature;

lib/Serialization/DeserializeSIL.cpp

@@ -379,14 +379,15 @@ SILFunction *SILDeserializer::readSILFunction(DeclID FID,
 
   DeclID clangNodeOwnerID;
   TypeID funcTyID;
+  GenericEnvironmentID genericEnvID;
   unsigned rawLinkage, isTransparent, isFragile, isThunk, isGlobal,
       inlineStrategy, effect, numSpecAttrs, hasQualifiedOwnership;
   ArrayRef<uint64_t> SemanticsIDs;
   // TODO: read fragile
   SILFunctionLayout::readRecord(scratch, rawLinkage, isTransparent, isFragile,
                                 isThunk, isGlobal, inlineStrategy, effect,
                                 numSpecAttrs, hasQualifiedOwnership, funcTyID,
-                                clangNodeOwnerID, SemanticsIDs);
+                                genericEnvID, clangNodeOwnerID, SemanticsIDs);
 
   if (funcTyID == 0) {
     DEBUG(llvm::dbgs() << "SILFunction typeID is 0.\n");
@@ -491,15 +492,8 @@ SILFunction *SILDeserializer::readSILFunction(DeclID FID,
   }
 
   GenericEnvironment *genericEnv = nullptr;
-  if (!declarationOnly) {
-    auto signature = fn->getLoweredFunctionType()->getGenericSignature();
-    genericEnv = MF->readGenericSignatureOrEnvironment(
-                    SILCursor,
-                    /*wantEnvironment=*/true,
-                    signature ? signature->getRequirements()
-                              : ArrayRef<Requirement>())
-                  .get<GenericEnvironment *>();
-  }
+  if (!declarationOnly)
+    genericEnv = MF->getGenericEnvironment(genericEnvID);
 
   // If the next entry is the end of the block, then this function has
   // no contents.
@@ -2001,13 +1995,14 @@ bool SILDeserializer::hasSILFunction(StringRef Name,
   // linkage to avoid re-reading it from the bitcode each time?
   DeclID clangOwnerID;
   TypeID funcTyID;
+  GenericEnvironmentID genericEnvID;
   unsigned rawLinkage, isTransparent, isFragile, isThunk, isGlobal,
     inlineStrategy, effect, numSpecAttrs, hasQualifiedOwnership;
   ArrayRef<uint64_t> SemanticsIDs;
   SILFunctionLayout::readRecord(scratch, rawLinkage, isTransparent, isFragile,
                                 isThunk, isGlobal, inlineStrategy, effect,
                                 numSpecAttrs, hasQualifiedOwnership, funcTyID,
-                                clangOwnerID, SemanticsIDs);
+                                genericEnvID, clangOwnerID, SemanticsIDs);
   auto linkage = fromStableSILLinkage(rawLinkage);
   if (!linkage) {
     DEBUG(llvm::dbgs() << "invalid linkage code " << rawLinkage

lib/Serialization/SILFormat.h

@@ -247,6 +247,7 @@ namespace sil_block {
                      BCFixed<2>,  // number of specialize attributes
                      BCFixed<1>,  // has qualified ownership
                      TypeIDField, // SILFunctionType
+                     GenericEnvironmentIDField,
                      DeclIDField, // ClangNode owner
                      BCArray<IdentifierIDField> // Semantics Attribute
                      // followed by specialize attributes

lib/Serialization/Serialization.cpp

@@ -556,8 +556,6 @@ void Serializer::writeBlockInfoBlock() {
                               decls_block::GENERIC_PARAM);
   BLOCK_RECORD_WITH_NAMESPACE(sil_block,
                               decls_block::GENERIC_REQUIREMENT);
-  BLOCK_RECORD_WITH_NAMESPACE(sil_block,
-                              decls_block::SIL_GENERIC_ENVIRONMENT);
 
   BLOCK(SIL_INDEX_BLOCK);
   BLOCK_RECORD(sil_index_block, SIL_FUNC_NAMES);
@@ -1011,25 +1009,32 @@ bool Serializer::writeGenericParams(const GenericParamList *genericParams) {
   return true;
 }
 
-void Serializer::writeGenericEnvironment(
-       const GenericEnvironment *env,
-       const std::array<unsigned, 256> &abbrCodes,
-       bool SILMode) {
+void Serializer::writeGenericEnvironment(const GenericEnvironment *env) {
   using namespace decls_block;
 
   // Record the offset of this generic environment.
-  if (!SILMode) {
-    auto id = GenericEnvironmentIDs[env];
-    assert(id != 0 && "generic environment not referenced properly");
-    (void)id;
+  auto id = GenericEnvironmentIDs[env];
+  assert(id != 0 && "generic environment not referenced properly");
+  (void)id;
 
-    assert((id - 1) == GenericEnvironmentOffsets.size());
-    GenericEnvironmentOffsets.push_back(Out.GetCurrentBitNo());
-  }
+  assert((id - 1) == GenericEnvironmentOffsets.size());
+  GenericEnvironmentOffsets.push_back(Out.GetCurrentBitNo());
 
   if (env == nullptr)
     return;
 
+  // Determine whether we must use SIL mode, because one of the generic
+  // parameters has a declaration with module context.
+  bool SILMode = false;
+  for (auto *paramTy : env->getGenericParams()) {
+    if (auto *decl = paramTy->getDecl()) {
+      if (decl->getDeclContext()->isModuleScopeContext()) {
+        SILMode = true;
+        break;
+      }
+    }
+  }
+
   // Record the generic parameters.
   SmallVector<uint64_t, 4> rawParamIDs;
   for (auto *paramTy : env->getGenericParams()) {
@@ -1050,20 +1055,17 @@ void Serializer::writeGenericEnvironment(
   }
 
   if (SILMode) {
-    assert(&abbrCodes != &DeclTypeAbbrCodes);
-    auto envAbbrCode = abbrCodes[SILGenericEnvironmentLayout::Code];
+    auto envAbbrCode = DeclTypeAbbrCodes[SILGenericEnvironmentLayout::Code];
     SILGenericEnvironmentLayout::emitRecord(Out, ScratchRecord, envAbbrCode,
                                             rawParamIDs);
-    return;
+  } else {
+    auto envAbbrCode = DeclTypeAbbrCodes[GenericEnvironmentLayout::Code];
+    GenericEnvironmentLayout::emitRecord(Out, ScratchRecord, envAbbrCode,
+                                         rawParamIDs);
   }
 
-  assert(&abbrCodes == &DeclTypeAbbrCodes);
-  auto envAbbrCode = abbrCodes[GenericEnvironmentLayout::Code];
-  GenericEnvironmentLayout::emitRecord(Out, ScratchRecord, envAbbrCode,
-                                       rawParamIDs);
-
   writeGenericRequirements(env->getGenericSignature()->getRequirements(),
-                           abbrCodes);
+                           DeclTypeAbbrCodes);
 }
 
 void Serializer::writeSILLayout(SILLayout *layout) {
@@ -3437,6 +3439,7 @@ void Serializer::writeAllDeclsAndTypes() {
   registerDeclTypeAbbr<GenericParamLayout>();
   registerDeclTypeAbbr<GenericRequirementLayout>();
   registerDeclTypeAbbr<GenericEnvironmentLayout>();
+  registerDeclTypeAbbr<SILGenericEnvironmentLayout>();
 
   registerDeclTypeAbbr<ForeignErrorConventionLayout>();
   registerDeclTypeAbbr<DeclContextLayout>();
@@ -3498,7 +3501,7 @@ void Serializer::writeAllDeclsAndTypes() {
     while (!GenericEnvironmentsToWrite.empty()) {
       auto next = GenericEnvironmentsToWrite.front();
       GenericEnvironmentsToWrite.pop();
-      writeGenericEnvironment(next, DeclTypeAbbrCodes, /*SILMode=*/false);
+      writeGenericEnvironment(next);
     }
 
     while (!NormalConformancesToWrite.empty()) {

lib/Serialization/Serialization.h

@@ -338,6 +338,9 @@ class Serializer {
   /// Writes the given type.
   void writeType(Type ty);
 
+  /// Writes a generic environment.
+  void writeGenericEnvironment(const GenericEnvironment *env);
+
   /// Registers the abbreviation for the given decl or type layout.
   template <typename Layout>
   void registerDeclTypeAbbr() {
@@ -471,11 +474,6 @@ class Serializer {
   void writeConformance(ProtocolConformance *conformance,
                         const std::array<unsigned, 256> &abbrCodes,
                         GenericEnvironment *genericEnv = nullptr);
-
-  /// Writes a generic environment.
-  void writeGenericEnvironment(const GenericEnvironment *env,
-                               const std::array<unsigned, 256> &abbrCodes,
-                               bool SILMode);
 };
 } // end namespace serialization
 } // end namespace swift

lib/Serialization/SerializeSIL.cpp

@@ -348,6 +348,11 @@ void SILSerializer::writeSILFunction(const SILFunction &F, bool DeclOnly) {
     Linkage = addExternalToLinkage(Linkage);
   }
 
+  // If we have a body, we might have a generic environment.
+  GenericEnvironmentID genericEnvID = 0;
+  if (!F.isExternalDeclaration())
+    genericEnvID = S.addGenericEnvironmentRef(F.getGenericEnvironment());
+
   DeclID clangNodeOwnerID;
   if (F.hasClangNode())
     clangNodeOwnerID = S.addDeclRef(F.getClangNodeOwner());
@@ -359,7 +364,7 @@ void SILSerializer::writeSILFunction(const SILFunction &F, bool DeclOnly) {
       (unsigned)F.isThunk(), (unsigned)F.isGlobalInit(),
       (unsigned)F.getInlineStrategy(), (unsigned)F.getEffectsKind(),
       (unsigned)numSpecAttrs, (unsigned)F.hasQualifiedOwnership(), FnID,
-      clangNodeOwnerID, SemanticsIDs);
+      genericEnvID, clangNodeOwnerID, SemanticsIDs);
 
   if (NoBody)
     return;
@@ -373,12 +378,6 @@ void SILSerializer::writeSILFunction(const SILFunction &F, bool DeclOnly) {
     S.writeSubstitutions(subs, SILAbbrCodes);
   }
 
-  // Write the body's context archetypes, unless we don't actually have a body.
-  if (!F.isExternalDeclaration()) {
-    if (auto genericEnv = F.getGenericEnvironment())
-      S.writeGenericEnvironment(genericEnv, SILAbbrCodes, true);
-  }
-
   // Assign a unique ID to each basic block of the SILFunction.
   unsigned BasicID = 0;
   BasicBlockMap.clear();
@@ -1918,8 +1917,6 @@ void SILSerializer::writeSILBlock(const SILModule *SILMod) {
   registerSILAbbr<decls_block::NormalProtocolConformanceIdLayout>();
   registerSILAbbr<decls_block::ProtocolConformanceXrefLayout>();
   registerSILAbbr<decls_block::GenericRequirementLayout>();
-  registerSILAbbr<decls_block::GenericEnvironmentLayout>();
-  registerSILAbbr<decls_block::SILGenericEnvironmentLayout>();
 
   for (const SILGlobalVariable &g : SILMod->getSILGlobals())
     writeSILGlobalVar(g);