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

This reverts commit 8e43990.

See the discussion here for details:

<6723560>

Author: slavapestov

lib/IRGen/GenDecl.cpp

@@ -1189,11 +1189,34 @@ 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.getSILModule().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)        \
@@ -1215,25 +1238,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.IRGen.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);
@@ -1242,12 +1279,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");
 }
@@ -1262,6 +1302,7 @@ static void updateLinkageForDefinition(IRGenModule &IGM,
   auto linkage = getIRLinkage(
                    IGM,
                    entity.getLinkage(IGM, ForDefinition),
+                   entity.isFragile(IGM),
                    ForDefinition,
                    entity.isWeakImported(IGM.getSwiftModule()));
   global->setLinkage(linkage.first);
@@ -1287,6 +1328,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.getSwiftModule()));
 

lib/IRGen/Linking.h

@@ -506,6 +506,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() {{.*}} {