Make SILFunction::create() private and change all direct uses of SILFunction::create() to instead use SILMod.getOrCreateFunction().

gottesmm · gottesmm · commit 302632cefbff · 2015-12-06T16:23:44.000-08:00
This centralizes the entrypoints for creating SILFunctions. Creating a
SILFunction is intimately tied to a specific SILModule, so it makes sense to
either centralize the creation on SILModule or SILFunction. Since a SILFunction
is in a SILModule, it seems more natural to put it on SILModule.

I purposely created a new override on SILMod that exactly matches the signature
of SILFunction::create so that beyond the extra indirection through SILMod, this
change should be NFC. We can refactor individual cases in later iterations of
refactoring.
diff --git a/include/swift/SIL/SILFunction.h b/include/swift/SIL/SILFunction.h
@@ -165,7 +165,6 @@ class SILFunction
               const SILDebugScope *debugScope,
               DeclContext *DC);
 
-public:
   static SILFunction *create(SILModule &M, SILLinkage linkage, StringRef name,
                              CanSILFunctionType loweredType,
                              GenericParamList *contextGenericParams,
@@ -180,6 +179,8 @@ class SILFunction
                              SILFunction *InsertBefore = nullptr,
                              const SILDebugScope *DebugScope = nullptr,
                              DeclContext *DC = nullptr);
+
+public:
   ~SILFunction();
 
   SILModule &getModule() const { return Module; }
diff --git a/include/swift/SIL/SILModule.h b/include/swift/SIL/SILModule.h
@@ -443,6 +443,27 @@ class SILModule {
                                    SILDeclRef constant,
                                    ForDefinition_t forDefinition);
 
+  /// \brief Return the declaration of a function, or create it if it does not
+  /// exist.
+  ///
+  /// This signature is a direct copy of the signature of SILFunction::create()
+  /// in order to simplify refactoring all SILFunction creation use-sites to use
+  /// SILModule. Eventually the uses should probably be refactored.
+  SILFunction *getOrCreateFunction(SILLinkage linkage, StringRef name,
+                                   CanSILFunctionType loweredType,
+                                   GenericParamList *contextGenericParams,
+                                   Optional<SILLocation> loc,
+                                   IsBare_t isBareSILFunction,
+                                   IsTransparent_t isTrans,
+                                   IsFragile_t isFragile,
+                                   IsThunk_t isThunk = IsNotThunk,
+                                   SILFunction::ClassVisibility_t classVisibility = SILFunction::NotRelevant,
+                                   Inline_t inlineStrategy = InlineDefault,
+                                   EffectsKind EK = EffectsKind::Unspecified,
+                                   SILFunction *InsertBefore = nullptr,
+                                   const SILDebugScope *DebugScope = nullptr,
+                                   DeclContext *DC = nullptr);
+
   /// Look up the SILWitnessTable representing the lowering of a protocol
   /// conformance, and collect the substitutions to apply to the referenced
   /// witnesses, if any.
diff --git a/lib/Parse/ParseSIL.cpp b/lib/Parse/ParseSIL.cpp
@@ -372,8 +372,8 @@ SILFunction *SILParser::getGlobalNameForDefinition(Identifier Name,
                  Fn->getLoweredFunctionType(), Ty);
       P.diagnose(It->second.second, diag::sil_prior_reference);
       auto loc = SILFileLocation(Loc);
-      Fn = SILFunction::create(SILMod, SILLinkage::Private, "", Ty,
-                               nullptr, loc, IsNotBare, IsNotTransparent, IsNotFragile);
+      Fn = SILMod.getOrCreateFunction(SILLinkage::Private, "", Ty,
+                                      nullptr, loc, IsNotBare, IsNotTransparent, IsNotFragile);
       Fn->setDebugScope(new (SILMod) SILDebugScope(loc, *Fn));
     }
     
@@ -392,15 +392,15 @@ SILFunction *SILParser::getGlobalNameForDefinition(Identifier Name,
   // defined already.
   if (SILMod.lookUpFunction(Name.str()) != nullptr) {
     P.diagnose(Loc, diag::sil_value_redefinition, Name.str());
-    auto fn = SILFunction::create(SILMod, SILLinkage::Private, "", Ty,
+    auto *fn = SILMod.getOrCreateFunction(SILLinkage::Private, "", Ty,
                                   nullptr, loc, IsNotBare, IsNotTransparent,
                                   IsNotFragile);
     fn->setDebugScope(new (SILMod) SILDebugScope(loc, *fn));
     return fn;
   }
 
   // Otherwise, this definition is the first use of this name.
-  auto fn = SILFunction::create(SILMod, SILLinkage::Private, Name.str(),
+  auto *fn = SILMod.getOrCreateFunction(SILLinkage::Private, Name.str(),
                                 Ty, nullptr, loc, IsNotBare, IsNotTransparent,
                                 IsNotFragile);
   fn->setDebugScope(new (SILMod) SILDebugScope(loc, *fn));
@@ -422,7 +422,7 @@ SILFunction *SILParser::getGlobalNameForReference(Identifier Name,
     if (FnRef->getLoweredFunctionType() != Ty) {
       P.diagnose(Loc, diag::sil_value_use_type_mismatch,
                  Name.str(), FnRef->getLoweredFunctionType(), Ty);
-      FnRef = SILFunction::create(SILMod, SILLinkage::Private, "", Ty, nullptr,
+      FnRef = SILMod.getOrCreateFunction(SILLinkage::Private, "", Ty, nullptr,
                                   loc, IsNotBare, IsNotTransparent,
                                   IsNotFragile);
       FnRef->setDebugScope(new (SILMod) SILDebugScope(loc, *FnRef));
@@ -432,7 +432,7 @@ SILFunction *SILParser::getGlobalNameForReference(Identifier Name,
   
   // If we didn't find a function, create a new one - it must be a forward
   // reference.
-  auto Fn = SILFunction::create(SILMod, SILLinkage::Private,
+  auto *Fn = SILMod.getOrCreateFunction(SILLinkage::Private,
                                 Name.str(), Ty, nullptr, loc, IsNotBare,
                                 IsNotTransparent, IsNotFragile);
   Fn->setDebugScope(new (SILMod) SILDebugScope(loc, *Fn));
diff --git a/lib/SIL/SILModule.cpp b/lib/SIL/SILModule.cpp
@@ -398,6 +398,24 @@ SILFunction *SILModule::getOrCreateSharedFunction(SILLocation loc,
                              isThunk, SILFunction::NotRelevant);
 }
 
+SILFunction *SILModule::getOrCreateFunction(SILLinkage linkage, StringRef name,
+                                            CanSILFunctionType loweredType,
+                                            GenericParamList *contextGenericParams,
+                                            Optional<SILLocation> loc,
+                                            IsBare_t isBareSILFunction,
+                                            IsTransparent_t isTrans,
+                                            IsFragile_t isFragile,
+                                            IsThunk_t isThunk,
+                                            SILFunction::ClassVisibility_t classVisibility,
+                                            Inline_t inlineStrategy,
+                                            EffectsKind EK,
+                                            SILFunction *InsertBefore,
+                                            const SILDebugScope *DebugScope,
+                                            DeclContext *DC) {
+  return SILFunction::create(*this, linkage, name, loweredType,
+                             contextGenericParams, loc, isBareSILFunction, isTrans, isFragile, isThunk, classVisibility, inlineStrategy, EK, InsertBefore, DebugScope, DC);
+}
+
 ArrayRef<SILType> ValueBase::getTypes() const {
   // No results.
   if (TypeOrTypeList.isNull())
diff --git a/lib/SILGen/SILGen.cpp b/lib/SILGen/SILGen.cpp
@@ -210,7 +210,7 @@ SILFunction *SILGenModule::emitTopLevelFunction(SILLocation Loc) {
                                    None,
                                    C);
 
-  return SILFunction::create(M, SILLinkage::Public,
+  return M.getOrCreateFunction(SILLinkage::Public,
                              SWIFT_ENTRY_POINT_FUNCTION, topLevelType, nullptr,
                              Loc, IsBare, IsNotTransparent, IsNotFragile,
                              IsNotThunk, SILFunction::NotRelevant);
@@ -723,7 +723,7 @@ SILFunction *SILGenModule::emitLazyGlobalInitializer(StringRef funcName,
   auto initSILType = getLoweredType(initType).castTo<SILFunctionType>();
 
   auto *f =
-    SILFunction::create(M, SILLinkage::Private, funcName,
+    M.getOrCreateFunction(SILLinkage::Private, funcName,
                         initSILType, nullptr, SILLocation(binding),
                         IsNotBare, IsNotTransparent,
                         makeModuleFragile ? IsFragile : IsNotFragile);
diff --git a/lib/SILGen/SILGenDecl.cpp b/lib/SILGen/SILGenDecl.cpp
@@ -1765,7 +1765,7 @@ SILGenModule::emitProtocolWitness(ProtocolConformance *conformance,
   if (witness.isAlwaysInline())
     InlineStrategy = AlwaysInline;
 
-  auto *f = SILFunction::create(M, linkage, nameBuffer,
+  auto *f = M.getOrCreateFunction(linkage, nameBuffer,
                                 witnessSILType.castTo<SILFunctionType>(),
                                 witnessContextParams,
                                 SILLocation(witness.getDecl()),
diff --git a/lib/SILGen/SILGenType.cpp b/lib/SILGen/SILGenType.cpp
@@ -88,7 +88,7 @@ SILGenModule::emitVTableMethod(SILDeclRef derived, SILDeclRef base) {
 
   auto *derivedDecl = cast<AbstractFunctionDecl>(derived.getDecl());
   SILLocation loc(derivedDecl);
-  auto thunk = SILFunction::create(M, SILLinkage::Private, name,
+  auto thunk = M.getOrCreateFunction(SILLinkage::Private, name,
                                    overrideInfo.SILFnType,
                                    derivedDecl->getGenericParams(),
                                    loc, IsBare, IsNotTransparent, IsNotFragile);
diff --git a/lib/SILPasses/IPO/CapturePromotion.cpp b/lib/SILPasses/IPO/CapturePromotion.cpp
@@ -452,8 +452,8 @@ ClosureCloner::initCloned(SILFunction *Orig, StringRef ClonedName,
          && "SILFunction missing DebugScope");
   assert(!Orig->isGlobalInit() && "Global initializer cannot be cloned");
 
-  auto Fn =
-      SILFunction::create(M, Orig->getLinkage(), ClonedName, SubstTy,
+  auto *Fn =
+    M.getOrCreateFunction(Orig->getLinkage(), ClonedName, SubstTy,
                           Orig->getContextGenericParams(), Orig->getLocation(),
                           Orig->isBare(), IsNotTransparent, Orig->isFragile(),
                           Orig->isThunk(),
diff --git a/lib/SILPasses/IPO/CapturePropagation.cpp b/lib/SILPasses/IPO/CapturePropagation.cpp
@@ -233,8 +233,7 @@ SILFunction *CapturePropagation::specializeConstClosure(PartialApplyInst *PAI,
   CanSILFunctionType NewFTy =
     Lowering::adjustFunctionType(PAI->getType().castTo<SILFunctionType>(),
                                  SILFunctionType::Representation::Thin);
-  SILFunction *NewF = SILFunction::create(
-      *getModule(), SILLinkage::Shared, Name, NewFTy,
+  SILFunction *NewF = getModule()->getOrCreateFunction(SILLinkage::Shared, Name, NewFTy,
       /*contextGenericParams*/ nullptr, OrigF->getLocation(), OrigF->isBare(),
       OrigF->isTransparent(), OrigF->isFragile(), OrigF->isThunk(),
       OrigF->getClassVisibility(),
diff --git a/lib/SILPasses/IPO/ClosureSpecializer.cpp b/lib/SILPasses/IPO/ClosureSpecializer.cpp
@@ -546,8 +546,7 @@ ClosureSpecCloner::initCloned(const CallSiteDescriptor &CallSiteDesc,
 
   // We make this function bare so we don't have to worry about decls in the
   // SILArgument.
-  auto Fn = SILFunction::create(
-      M, ClosureUser->getLinkage(), ClonedName, ClonedTy,
+  auto *Fn = M.getOrCreateFunction(ClosureUser->getLinkage(), ClonedName, ClonedTy,
       ClosureUser->getContextGenericParams(), ClosureUser->getLocation(),
       IsBare, ClosureUser->isTransparent(), ClosureUser->isFragile(),
       ClosureUser->isThunk(), ClosureUser->getClassVisibility(),
diff --git a/lib/SILPasses/IPO/FunctionSignatureOpts.cpp b/lib/SILPasses/IPO/FunctionSignatureOpts.cpp
@@ -604,8 +604,7 @@ SILFunction *FunctionAnalyzer::createEmptyFunctionWithOptimizedSig(
   CanSILFunctionType NewFTy = createOptimizedSILFunctionType();
 
   // Create the new function.
-  SILFunction *NewF = SILFunction::create(
-      M, F->getLinkage(), NewFName, NewFTy, nullptr, F->getLocation(),
+  auto *NewF = M.getOrCreateFunction(F->getLinkage(), NewFName, NewFTy, nullptr, F->getLocation(),
       F->isBare(), F->isTransparent(), F->isFragile(), F->isThunk(),
       F->getClassVisibility(), F->getInlineStrategy(), F->getEffectsKind(), 0,
       F->getDebugScope(), F->getDeclContext());
diff --git a/lib/SILPasses/Scalar/AllocBoxToStack.cpp b/lib/SILPasses/Scalar/AllocBoxToStack.cpp
@@ -549,8 +549,8 @@ DeadParamCloner::initCloned(SILFunction *Orig,
   assert((Orig->isTransparent() || Orig->isBare() || Orig->getDebugScope())
          && "SILFunction missing DebugScope");
   assert(!Orig->isGlobalInit() && "Global initializer cannot be cloned");
-  auto Fn =
-      SILFunction::create(M, SILLinkage::Shared, ClonedName, ClonedTy,
+  auto *Fn =
+    M.getOrCreateFunction(SILLinkage::Shared, ClonedName, ClonedTy,
                           Orig->getContextGenericParams(), Orig->getLocation(),
                           Orig->isBare(), IsNotTransparent, Orig->isFragile(),
                           Orig->isThunk(),
diff --git a/lib/SILPasses/Utils/GenericCloner.cpp b/lib/SILPasses/Utils/GenericCloner.cpp
@@ -43,8 +43,7 @@ SILFunction *GenericCloner::initCloned(SILFunction *Orig,
   assert(!Orig->isGlobalInit() && "Global initializer cannot be cloned");
 
   // Create a new empty function.
-  SILFunction *NewF = SILFunction::create(
-      M, getSpecializedLinkage(Orig, Orig->getLinkage()), NewName, FTy, nullptr,
+  SILFunction *NewF = M.getOrCreateFunction(getSpecializedLinkage(Orig, Orig->getLinkage()), NewName, FTy, nullptr,
       Orig->getLocation(), Orig->isBare(), Orig->isTransparent(),
       Orig->isFragile(), Orig->isThunk(), Orig->getClassVisibility(),
       Orig->getInlineStrategy(), Orig->getEffectsKind(), Orig,
diff --git a/lib/Serialization/DeserializeSIL.cpp b/lib/Serialization/DeserializeSIL.cpp
@@ -293,7 +293,7 @@ static SILFunction *createBogusSILFunction(SILModule &M,
                                            StringRef name,
                                            SILType type) {
   SourceLoc loc;
-  return SILFunction::create(M, SILLinkage::Private, name,
+  return M.getOrCreateFunction(SILLinkage::Private, name,
                              type.castTo<SILFunctionType>(),
                              nullptr, SILFileLocation(loc), IsNotBare,
                              IsNotTransparent, IsNotFragile, IsNotThunk,
@@ -435,7 +435,7 @@ SILFunction *SILDeserializer::readSILFunction(DeclID FID,
 
   // Otherwise, create a new function.
   } else {
-    fn = SILFunction::create(SILMod, linkage.getValue(), name,
+    fn = SILMod.getOrCreateFunction(linkage.getValue(), name,
                              ty.castTo<SILFunctionType>(),
                              nullptr, loc,
                              IsNotBare, IsTransparent_t(isTransparent == 1),
