SIL: Better verifier check for references from fragile functions

include/swift/SIL/SILFunction.h

@@ -662,7 +662,7 @@ class SILFunction
 
   /// verify - Run the IR verifier to make sure that the SILFunction follows
   /// invariants.
-  void verify() const;
+  void verify(bool SingleFunction=true) const;
 
   /// Pretty-print the SILFunction.
   void dump(bool Verbose) const;

lib/SIL/SILFunction.cpp

@@ -517,11 +517,6 @@ bool SILFunction::hasValidLinkageForFragileRef() const {
   if (isFragile())
     return true;
 
-  // If the function is a forward declaration, we may have not deserialized
-  // the body yet.
-  if (isExternalDeclaration())
-    return true;
-
   // Fragile functions can reference 'static inline' functions imported
   // from C.
   if (hasForeignBody())
@@ -536,7 +531,7 @@ bool SILFunction::hasValidLinkageForFragileRef() const {
     return true;
 
   // Otherwise, only public functions can be referenced.
-  return hasPublicVisibility(linkage);
+  return hasPublicVisibility(getLinkage());
 }
 
 /// Helper method which returns true if the linkage of the SILFunction

lib/SIL/SILVerifier.cpp

@@ -101,6 +101,7 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
   Lowering::TypeConverter &TC;
   const SILInstruction *CurInstruction = nullptr;
   DominanceInfo *Dominance = nullptr;
+  bool SingleFunction = true;
 
   SILVerifier(const SILVerifier&) = delete;
   void operator=(const SILVerifier&) = delete;
@@ -410,9 +411,9 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
     }
   }
 
-  SILVerifier(const SILFunction &F)
+  SILVerifier(const SILFunction &F, bool SingleFunction=true)
     : M(F.getModule().getSwiftModule()), F(F), TC(F.getModule().Types),
-      Dominance(nullptr) {
+      Dominance(nullptr), SingleFunction(SingleFunction) {
     if (F.isExternalDeclaration())
       return;
 
@@ -902,31 +903,15 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
       verifyLLVMIntrinsic(BI, BI->getIntrinsicInfo().ID);
   }
 
-  /// Returns true if \p FRI is only used as a callee and will always be
-  /// inlined at those call sites.
-  static bool isAlwaysInlined(FunctionRefInst *FRI) {
-    if (FRI->getReferencedFunction()->getInlineStrategy() != AlwaysInline &&
-        !FRI->getReferencedFunction()->isTransparent()) {
-      return false;
-    }
-
-    for (auto use : FRI->getUses()) {
-      auto site = FullApplySite::isa(use->getUser());
-      if (!site || site.getCallee() != FRI)
-        return false;
-    }
-    return true;
-  }
-
   void checkFunctionRefInst(FunctionRefInst *FRI) {
     auto fnType = requireObjectType(SILFunctionType, FRI,
                                     "result of function_ref");
     require(!fnType->getExtInfo().hasContext(),
             "function_ref should have a context-free function result");
     if (F.isFragile()) {
       SILFunction *RefF = FRI->getReferencedFunction();
-      require(isAlwaysInlined(FRI)
-                || RefF->hasValidLinkageForFragileRef(),
+      require((SingleFunction && RefF->isExternalDeclaration()) ||
+              RefF->hasValidLinkageForFragileRef(),
               "function_ref inside fragile function cannot "
               "reference a private or hidden symbol");
     }
@@ -3128,12 +3113,12 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
 
 /// verify - Run the SIL verifier to make sure that the SILFunction follows
 /// invariants.
-void SILFunction::verify() const {
+void SILFunction::verify(bool SingleFunction) const {
 #ifndef NDEBUG
   // Please put all checks in visitSILFunction in SILVerifier, not here. This
   // ensures that the pretty stack trace in the verifier is included with the
   // back trace when the verifier crashes.
-  SILVerifier(*this).verify();
+  SILVerifier(*this, SingleFunction).verify();
 #endif
 }
 
@@ -3274,7 +3259,7 @@ void SILModule::verify() const {
       llvm::errs() << "Symbol redefined: " << f.getName() << "!\n";
       assert(false && "triggering standard assertion failure routine");
     }
-    f.verify();
+    f.verify(/*SingleFunction=*/ false);
   }
 
   // Check all globals.