Revert "IRGen: Remove special handling of fragile entities in LinkEntity"

This reverts commit 62ad8a6.

Author: benlangmuir

lib/IRGen/GenDecl.cpp

@@ -1205,11 +1205,33 @@ bool LinkEntity::isAvailableExternally(IRGenModule &IGM) const {
   llvm_unreachable("bad link entity kind");
 }
 
+bool LinkEntity::isFragile(IRGenModule &IGM) const {
+  switch (getKind()) {
+    case Kind::SILFunction:
+      return getSILFunction()->isFragile();
+      
+    case Kind::SILGlobalVariable:
+      return getSILGlobalVariable()->isFragile();
+      
+    case Kind::DirectProtocolWitnessTable: {
+      if (auto wt = IGM.SILMod->lookUpWitnessTable(getProtocolConformance())) {
+        return wt->isFragile();
+      } else {
+        return false;
+      }
+    }
+      
+    default:
+      break;
+  }
+  return false;
+}
+
 
 static std::pair<llvm::GlobalValue::LinkageTypes,
                  llvm::GlobalValue::VisibilityTypes>
 getIRLinkage(IRGenModule &IGM,
-             SILLinkage linkage, ForDefinition_t isDefinition,
+             SILLinkage linkage, bool isFragile, ForDefinition_t isDefinition,
              bool isWeakImported) {
 
 #define RESULT(LINKAGE, VISIBILITY)        \
@@ -1231,25 +1253,39 @@ llvm::GlobalValue::VISIBILITY##Visibility }
     break;
   }
 
+  if (isFragile) {
+    // Fragile functions/globals must be visible from outside, regardless of
+    // their accessibility. If a caller is also fragile and inlined into another
+    // module it must be able to access this (not-inlined) function/global.
+    switch (linkage) {
+    case SILLinkage::Hidden:
+    case SILLinkage::Private:
+      linkage = SILLinkage::Public;
+      break;
+
+    case SILLinkage::Public:
+    case SILLinkage::Shared:
+    case SILLinkage::HiddenExternal:
+    case SILLinkage::PrivateExternal:
+    case SILLinkage::PublicExternal:
+    case SILLinkage::SharedExternal:
+      break;
+    }
+  }
+  
   switch (linkage) {
   case SILLinkage::Public:
     return {llvm::GlobalValue::ExternalLinkage, PublicDefinitionVisibility};
-
   case SILLinkage::Shared:
-  case SILLinkage::SharedExternal:
-    return RESULT(LinkOnceODR, Hidden);
-
-  case SILLinkage::Hidden:
-    return RESULT(External, Hidden);
-
+  case SILLinkage::SharedExternal: return RESULT(LinkOnceODR, Hidden);
+  case SILLinkage::Hidden: return RESULT(External, Hidden);
   case SILLinkage::Private:
     if (IGM.dispatcher.hasMultipleIGMs()) {
       // In case of multiple llvm modules (in multi-threaded compilation) all
       // private decls must be visible from other files.
       return RESULT(External, Hidden);
     }
     return RESULT(Internal, Default);
-
   case SILLinkage::PublicExternal:
     if (isDefinition) {
       return RESULT(AvailableExternally, Default);
@@ -1258,12 +1294,15 @@ llvm::GlobalValue::VISIBILITY##Visibility }
     if (isWeakImported)
       return RESULT(ExternalWeak, Default);
     return RESULT(External, Default);
-
   case SILLinkage::HiddenExternal:
-  case SILLinkage::PrivateExternal:
-    if (isDefinition) 
-      return RESULT(AvailableExternally, Hidden);
-    return RESULT(External, Hidden);
+  case SILLinkage::PrivateExternal: {
+    auto visibility = isFragile ? llvm::GlobalValue::DefaultVisibility
+                                : llvm::GlobalValue::HiddenVisibility;
+    if (isDefinition) {
+      return {llvm::GlobalValue::AvailableExternallyLinkage, visibility};
+    }
+    return {llvm::GlobalValue::ExternalLinkage, visibility};
+  }
   }
   llvm_unreachable("bad SIL linkage");
 }
@@ -1278,6 +1317,7 @@ static void updateLinkageForDefinition(IRGenModule &IGM,
   auto linkage = getIRLinkage(
                    IGM,
                    entity.getLinkage(IGM, ForDefinition),
+                   entity.isFragile(IGM),
                    ForDefinition,
                    entity.isWeakImported(IGM.SILMod->getSwiftModule()));
   global->setLinkage(linkage.first);
@@ -1303,6 +1343,7 @@ LinkInfo LinkInfo::get(IRGenModule &IGM, const LinkEntity &entity,
 
   std::tie(result.Linkage, result.Visibility) =
     getIRLinkage(IGM, entity.getLinkage(IGM, isDefinition),
+                 entity.isFragile(IGM),
                  isDefinition,
                  entity.isWeakImported(IGM.SILMod->getSwiftModule()));
 

lib/IRGen/Linking.h

@@ -496,6 +496,11 @@ class LinkEntity {
   ///
   bool isAvailableExternally(IRGenModule &IGM) const;
 
+  /// Returns true if this function or global variable may be inlined into
+  /// another module.
+  ///
+  bool isFragile(IRGenModule &IGM) const;
+
   ValueDecl *getDecl() const {
     assert(isDeclKind(getKind()));
     return reinterpret_cast<ValueDecl*>(Pointer);

test/IRGen/sil_linkage.sil

@@ -3,13 +3,13 @@
 sil_stage canonical
 
 // CHECK: define{{( protected)?}} void @public_fragile_function_test() {{.*}} {
-// CHECK: define hidden void @hidden_fragile_function_test() {{.*}} {
+// CHECK: define{{( protected)?}} void @hidden_fragile_function_test() {{.*}} {
 // CHECK: define linkonce_odr hidden void @shared_fragile_function_test() {{.*}} {
-// CHECK: define internal void @private_fragile_function_test() {{.*}} {
+// CHECK: define{{( protected)?}} void @private_fragile_function_test() {{.*}} {
 // CHECK: define linkonce_odr hidden void @public_external_fragile_function_def_test() {{.*}} {
-// CHECK: define available_externally hidden void @hidden_external_fragile_function_def_test() {{.*}} {
+// CHECK: define{{( protected)?}} available_externally void @hidden_external_fragile_function_def_test() {{.*}} {
 // CHECK: define linkonce_odr hidden void @shared_external_fragile_function_def_test() {{.*}} {
-// CHECK: define available_externally hidden void @private_external_fragile_function_def_test() {{.*}} {
+// CHECK: define{{( protected)?}} available_externally void @private_external_fragile_function_def_test() {{.*}} {
 // CHECK: define{{( protected)?}} void @public_resilient_function_test() {{.*}} {
 // CHECK: define hidden void @hidden_resilient_function_test() {{.*}} {
 // CHECK: define linkonce_odr hidden void @shared_resilient_function_test() {{.*}} {