SIL: Stricter assertions for references from within fragile functions

Let's abuse the [thunk] attribute to mean "serialize the body of this
function but only if it is referenced from a [fragile] function."

Author: slavapestov

include/swift/SIL/SILFunction.h

@@ -325,6 +325,10 @@ class SILFunction
   /// Set the function's linkage attribute.
   void setLinkage(SILLinkage linkage) { Linkage = unsigned(linkage); }
 
+  /// Returns true if this function can be referenced from a fragile function
+  /// body.
+  bool hasValidLinkageForFragileRef() const;
+
   /// Get's the effective linkage which is used to derive the llvm linkage.
   /// Usually this is the same as getLinkage(), except in one case: if this
   /// function is a method in a class which has higher visibility than the

include/swift/SILOptimizer/Utils/Local.h

@@ -174,10 +174,6 @@ bool tryCheckedCastBrJumpThreading(SILFunction *Fn, DominanceInfo *DT,
 
 void recalcDomTreeForCCBOpt(DominanceInfo *DT, SILFunction &F);
 
-/// Checks if a symbol with a given linkage can be referenced from fragile
-/// functions.
-bool isValidLinkageForFragileRef(SILLinkage linkage);
-
 /// A structure containing callbacks that are called when an instruction is
 /// removed or added.
 struct InstModCallbacks {

lib/SIL/SILFunction.cpp

@@ -510,9 +510,31 @@ bool SILFunction::hasName(const char *Name) const {
   return getName() == Name;
 }
 
-  /// Helper method which returns true if the linkage of the SILFunction
-  /// indicates that the objects definition might be required outside the
-  /// current SILModule.
+/// Returns true if this function can be referenced from a fragile function
+/// body.
+bool SILFunction::hasValidLinkageForFragileRef() const {
+  // Fragile functions can reference other fragile functions.
+  if (isFragile())
+    return true;
+
+  // Fragile functions can reference 'static inline' functions imported
+  // from C.
+  if (hasForeignBody())
+    return true;
+
+  // Fragile functions can reference non-fragile shared functions only
+  // if they are thunks.
+  SILLinkage linkage = getLinkage();
+  if (hasSharedVisibility(linkage))
+    return isThunk();
+
+  // Otherwise, only public functions can be referenced.
+  return hasPublicVisibility(linkage);
+}
+
+/// Helper method which returns true if the linkage of the SILFunction
+/// indicates that the objects definition might be required outside the
+/// current SILModule.
 bool
 SILFunction::isPossiblyUsedExternally() const {
   return swift::isPossiblyUsedExternally(getLinkage(),

lib/SIL/SILVerifier.cpp

@@ -902,35 +902,6 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
       verifyLLVMIntrinsic(BI, BI->getIntrinsicInfo().ID);
   }
 
-  bool isValidLinkageForFragileRef(SILLinkage linkage) {
-    switch (linkage) {
-    case SILLinkage::Private:
-    case SILLinkage::PrivateExternal:
-    case SILLinkage::Hidden:
-    case SILLinkage::HiddenExternal:
-      return false;
-
-    case SILLinkage::Shared:
-    case SILLinkage::SharedExternal:
-      // This allows fragile functions to reference thunks, generated
-      // methods on Clang types, and optimizer specializations.
-      return true;
-
-    case SILLinkage::Public:
-    case SILLinkage::PublicExternal:
-      return true;
-    }
-  }
-
-  bool isValidLinkageForFragileRef(const SILFunction *RefF) {
-    if (RefF->isFragile() ||
-        RefF->isExternalDeclaration()) {
-      return true;
-    }
-
-    return isValidLinkageForFragileRef(RefF->getLinkage());
-  }
-
   /// 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) {
@@ -955,7 +926,7 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
     if (F.isFragile()) {
       SILFunction *RefF = FRI->getReferencedFunction();
       require(isAlwaysInlined(FRI)
-                || isValidLinkageForFragileRef(RefF),
+                || RefF->hasValidLinkageForFragileRef(),
               "function_ref inside fragile function cannot "
               "reference a private or hidden symbol");
     }
@@ -966,7 +937,7 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
     if (F.isFragile()) {
       SILGlobalVariable *RefG = AGI->getReferencedGlobal();
       require(RefG->isFragile()
-                || isValidLinkageForFragileRef(RefG->getLinkage()),
+                || hasPublicVisibility(RefG->getLinkage()),
               "alloc_global inside fragile function cannot "
               "reference a private or hidden symbol");
     }
@@ -982,7 +953,7 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
     if (F.isFragile()) {
       SILGlobalVariable *RefG = GAI->getReferencedGlobal();
       require(RefG->isFragile()
-                || isValidLinkageForFragileRef(RefG->getLinkage()),
+                || hasPublicVisibility(RefG->getLinkage()),
               "global_addr inside fragile function cannot "
               "reference a private or hidden symbol");
     }

lib/SILOptimizer/Utils/Devirtualize.cpp

@@ -473,8 +473,7 @@ bool swift::canDevirtualizeClassMethod(FullApplySite AI,
   if (AI.getFunction()->isFragile()) {
     // function_ref inside fragile function cannot reference a private or
     // hidden symbol.
-    if (!(F->isFragile() || isValidLinkageForFragileRef(F->getLinkage()) ||
-          F->isExternalDeclaration()))
+    if (!F->hasValidLinkageForFragileRef())
       return false;
   }
 

lib/SILOptimizer/Utils/Local.cpp

@@ -1481,28 +1481,6 @@ optimizeBridgedObjCToSwiftCast(SILInstruction *Inst,
   return (NewI) ? NewI : AI;
 }
 
-bool swift::isValidLinkageForFragileRef(SILLinkage linkage) {
-  switch (linkage) {
-  case SILLinkage::Private:
-  case SILLinkage::PrivateExternal:
-  case SILLinkage::Hidden:
-  case SILLinkage::HiddenExternal:
-    return false;
-
-  case SILLinkage::Shared:
-  case SILLinkage::SharedExternal:
-      // This handles some kind of generated functions, like constructors
-      // of clang imported types.
-      // TODO: check why those functions are not fragile anyway and make
-      // a less conservative check here.
-      return true;
-
-  case SILLinkage::Public:
-  case SILLinkage::PublicExternal:
-    return true;
-  }
-}
-
 /// Create a call of _bridgeToObjectiveC which converts an _ObjectiveCBridgeable
 /// instance into a bridged ObjC type.
 SILInstruction *
@@ -1568,9 +1546,7 @@ optimizeBridgedSwiftToObjCCast(SILInstruction *Inst,
          "Implementation of _bridgeToObjectiveC could not be found");
 
   if (Inst->getFunction()->isFragile() &&
-      !(BridgedFunc->isFragile() ||
-        isValidLinkageForFragileRef(BridgedFunc->getLinkage()) ||
-        BridgedFunc->isExternalDeclaration()))
+      !BridgedFunc->hasValidLinkageForFragileRef())
     return nullptr;
 
   auto ParamTypes = BridgedFunc->getLoweredFunctionType()->getParameters();

lib/Serialization/SerializeSIL.cpp

@@ -271,6 +271,8 @@ void SILSerializer::addReferencedSILFunction(const SILFunction *F,
   // have enough information at the time we emit the function to
   // know if it should be marked fragile or not.
   if (F->getLinkage() == SILLinkage::Shared && !DeclOnly) {
+    assert(F->isThunk() && "Reference to non-thunk, non-fragile shared "
+           "function from a fragile function");
     FuncsToEmit[F] = false;
     Worklist.push_back(F);
     return;