Ask SILFunction link entities' clang nodes for weakness when applicable (#2822)

* Provide ways to get back to the original Clang declaration from
a SILFunction or SILGLobalVariable.

This will be used as one step towards moving IRGen off of the
global external-definitions list.

* Ask SILFunction link entities' clang nodes for weakness when applicable

When importing C functions with availability attributes, we don't
properly use that information to decide whether a symbol should be
weak_extern, causing load failures in dylibs that reference these
symbols when deployed to an older OS.

This is a very targeted fix and we need a better architecture for
deciding this.

rdar://problem/26359452

Author: bitjammer

include/swift/SIL/SILDeclRef.h

@@ -375,6 +375,7 @@ struct SILDeclRef {
   /// True if the referenced entity is emitted by Clang on behalf of the Clang
   /// importer.
   bool isClangGenerated() const;
+  static bool isClangGenerated(ClangNode node);
 
   bool isImplicit() const {
     if (hasDecl())

include/swift/SIL/SILFunction.h

@@ -105,6 +105,9 @@ class SILFunction
   /// The declcontext of this function.
   DeclContext *DeclCtx;
 
+  /// The owning declaration of this function's clang node, if applicable.
+  ValueDecl *ClangNodeOwner = nullptr;
+
   /// The source location and scope of the function.
   const SILDebugScope *DebugScope;
 
@@ -146,9 +149,6 @@ class SILFunction
   /// it public.
   unsigned KeepAsPublic : 1;
 
-  /// This flag indicates if a function has a body generated by Clang.
-  unsigned ForeignBody : 1;
-
   /// This is the number of uses of this SILFunction inside the SIL.
   /// It does not include references from debug scopes.
   unsigned RefCount = 0;
@@ -515,9 +515,37 @@ class SILFunction
   bool isKeepAsPublic() const { return KeepAsPublic; }
   void setKeepAsPublic(bool keep) { KeepAsPublic = keep; }
 
-  /// Get this function's foreign body attribute.
-  HasForeignBody_t hasForeignBody() const { return HasForeignBody_t(ForeignBody); }
-  void setForeignBody(HasForeignBody_t foreign) { ForeignBody = foreign; }
+  /// Return whether this function has a foreign implementation which can
+  /// be emitted on demand.
+  bool hasForeignBody() const;
+
+  /// Return whether this function corresponds to a Clang node.
+  bool hasClangNode() const {
+    return ClangNodeOwner != nullptr;
+  }
+
+  /// Set the owning declaration of the Clang node associated with this
+  /// function.  We have to store an owner (a Swift declaration) instead of
+  /// directly referencing the original declaration due to current
+  /// limitations in the serializer.
+  void setClangNodeOwner(ValueDecl *owner) {
+    assert(owner->hasClangNode());
+    ClangNodeOwner = owner;
+  }
+
+  /// Return the owning declaration of the Clang node associated with this
+  /// function.  This should only be used for serialization.
+  ValueDecl *getClangNodeOwner() const {
+    return ClangNodeOwner;
+  }
+
+  /// Return the Clang node associated with this function if it has one.
+  ClangNode getClangNode() const {
+    return (ClangNodeOwner ? ClangNodeOwner->getClangNode() : ClangNode());
+  }
+  const clang::Decl *getClangDecl() const {
+    return (ClangNodeOwner ? ClangNodeOwner->getClangDecl() : nullptr);
+  }
 
   /// Retrieve the generic parameter list containing the contextual archetypes
   /// of the function.

include/swift/SIL/SILGlobalVariable.h

@@ -144,6 +144,19 @@ class SILGlobalVariable
   /// Return the value that is written into the global variable.
   SILInstruction *getValueOfStaticInitializer();
 
+  /// Return whether this variable corresponds to a Clang node.
+  bool hasClangNode() const {
+    return VDecl->hasClangNode();
+  }
+
+  /// Return the Clang node associated with this variable if it has one.
+  ClangNode getClangNode() const {
+    return VDecl->getClangNode();
+  }
+  const clang::Decl *getClangDecl() const {
+    return VDecl->getClangDecl();
+  }
+
   //===--------------------------------------------------------------------===//
   // Miscellaneous
   //===--------------------------------------------------------------------===//

include/swift/SIL/SILLinkage.h

@@ -90,12 +90,6 @@ enum IsFragile_t {
   IsFragile
 };
 
-/// True if we have an inline body generated by Clang.
-enum HasForeignBody_t {
-  DoesNotHaveForeignBody,
-  HasForeignBody
-};
-
 /// Strip external from public_external, hidden_external. Otherwise just return
 /// the linkage.
 inline SILLinkage stripExternalFromLinkage(SILLinkage linkage) {

include/swift/Serialization/ModuleFormat.h

@@ -53,7 +53,7 @@ const uint16_t VERSION_MAJOR = 0;
 /// in source control, you should also update the comment to briefly
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
-const uint16_t VERSION_MINOR = 248; // Last change: [nonatomic] attribute
+const uint16_t VERSION_MINOR = 249; // Last change: SIL clang decls
 
 using DeclID = PointerEmbeddedInt<unsigned, 31>;
 using DeclIDField = BCFixed<31>;

lib/IRGen/Linking.h

@@ -574,6 +574,10 @@ class LinkEntity {
         getSILGlobalVariable()->getDecl())
       return getSILGlobalVariable()->getDecl()->isWeakImported(module);
 
+    if (getKind() == Kind::SILFunction)
+      if (auto clangOwner = getSILFunction()->getClangNodeOwner())
+        return clangOwner->isWeakImported(module);
+
     if (!isDeclKind(getKind()))
       return false;
 

lib/SIL/SILDeclRef.cpp

@@ -275,8 +275,12 @@ bool SILDeclRef::isClangGenerated() const {
   if (!hasDecl())
     return false;
 
-  auto clangNode = getDecl()->getClangNode().getAsDecl();
-  if (auto nd = dyn_cast_or_null<clang::NamedDecl>(clangNode)) {
+  return isClangGenerated(getDecl()->getClangNode());
+}
+
+// FIXME: this is a weird predicate.
+bool SILDeclRef::isClangGenerated(ClangNode node) {
+  if (auto nd = dyn_cast_or_null<clang::NamedDecl>(node.getAsDecl())) {
     // ie, 'static inline' functions for which we must ask Clang to emit a body
     // for explicitly
     if (!nd->isExternallyVisible())

lib/SIL/SILFunction.cpp

@@ -101,7 +101,6 @@ SILFunction::SILFunction(SILModule &Module, SILLinkage Linkage,
     InlineStrategy(inlineStrategy),
     Linkage(unsigned(Linkage)),
     KeepAsPublic(false),
-    ForeignBody(false),
     EffectsKindAttr(E) {
   if (InsertBefore)
     Module.functions.insert(SILModule::iterator(InsertBefore), this);
@@ -160,6 +159,11 @@ void SILFunction::setDeclContext(Expr *E) {
   DeclCtx = dyn_cast_or_null<AbstractClosureExpr>(E);
 }
 
+bool SILFunction::hasForeignBody() const {
+  if (!hasClangNode()) return false;
+  return SILDeclRef::isClangGenerated(getClangNode());
+}
+
 void SILFunction::numberValues(llvm::DenseMap<const ValueBase*,
                                unsigned> &ValueToNumberMap) const {
   unsigned idx = 0;

lib/SIL/SILModule.cpp

@@ -355,10 +355,12 @@ SILFunction *SILModule::getOrCreateFunction(SILLocation loc,
 
   F->setGlobalInit(constant.isGlobal());
   if (constant.hasDecl()) {
-    if (constant.isForeign && constant.isClangGenerated())
-      F->setForeignBody(HasForeignBody);
+    auto decl = constant.getDecl();
 
-    auto Attrs = constant.getDecl()->getAttrs();
+    if (constant.isForeign && decl->hasClangNode())
+      F->setClangNodeOwner(decl);
+
+    auto Attrs = decl->getAttrs();
     for (auto *A : Attrs.getAttributes<SemanticsAttr, false /*AllowInvalid*/>())
       F->addSemanticsAttr(cast<SemanticsAttr>(A)->Value);
 

lib/Serialization/DeserializeSIL.cpp

@@ -376,14 +376,16 @@ SILFunction *SILDeserializer::readSILFunction(DeclID FID,
   assert(kind == SIL_FUNCTION && "expect a sil function");
   (void)kind;
 
+  DeclID clangNodeOwnerID;
   TypeID funcTyID;
   unsigned rawLinkage, isTransparent, isFragile, isThunk, isGlobal,
     inlineStrategy, effect, numSpecAttrs;
   ArrayRef<uint64_t> SemanticsIDs;
   // TODO: read fragile
   SILFunctionLayout::readRecord(scratch, rawLinkage, isTransparent, isFragile,
                                 isThunk, isGlobal, inlineStrategy, effect,
-                                numSpecAttrs, funcTyID, SemanticsIDs);
+                                numSpecAttrs, funcTyID, clangNodeOwnerID,
+                                SemanticsIDs);
 
   if (funcTyID == 0) {
     DEBUG(llvm::dbgs() << "SILFunction typeID is 0.\n");
@@ -405,6 +407,16 @@ SILFunction *SILDeserializer::readSILFunction(DeclID FID,
     return nullptr;
   }
 
+  ValueDecl *clangNodeOwner = nullptr;
+  if (clangNodeOwnerID != 0) {
+    clangNodeOwner = dyn_cast_or_null<ValueDecl>(MF->getDecl(clangNodeOwnerID));
+    if (!clangNodeOwner) {
+      DEBUG(llvm::dbgs() << "invalid clang node owner for SILFunction\n");
+      MF->error();
+      return nullptr;
+    }
+  }
+
   // If we weren't handed a function, check for an existing
   // declaration in the output module.
   if (!existingFn) existingFn = SILMod.lookUpFunction(name);
@@ -436,6 +448,8 @@ SILFunction *SILDeserializer::readSILFunction(DeclID FID,
         SILFunction::NotRelevant, (Inline_t)inlineStrategy);
     fn->setGlobalInit(isGlobal == 1);
     fn->setEffectsKind((EffectsKind)effect);
+    if (clangNodeOwner)
+      fn->setClangNodeOwner(clangNodeOwner);
     for (auto ID : SemanticsIDs) {
       fn->addSemanticsAttr(MF->getIdentifier(ID).str());
     }
@@ -1837,13 +1851,15 @@ bool SILDeserializer::hasSILFunction(StringRef Name,
   // Read function properties only, e.g. its linkage and other attributes.
   // TODO: If this results in any noticeable performance problems, Cache the
   // linkage to avoid re-reading it from the bitcode each time?
+  DeclID clangOwnerID;
   TypeID funcTyID;
   unsigned rawLinkage, isTransparent, isFragile, isThunk, isGlobal,
     inlineStrategy, effect, numSpecAttrs;
   ArrayRef<uint64_t> SemanticsIDs;
   SILFunctionLayout::readRecord(scratch, rawLinkage, isTransparent, isFragile,
                                 isThunk, isGlobal, inlineStrategy, effect,
-                                numSpecAttrs, funcTyID, SemanticsIDs);
+                                numSpecAttrs, funcTyID, clangOwnerID,
+                                SemanticsIDs);
   auto linkage = fromStableSILLinkage(rawLinkage);
   if (!linkage) {
     DEBUG(llvm::dbgs() << "invalid linkage code " << rawLinkage
@@ -1909,8 +1925,8 @@ SILGlobalVariable *SILDeserializer::readGlobalVar(StringRef Name) {
   TypeID TyID;
   DeclID dID;
   unsigned rawLinkage, isFragile, IsDeclaration, IsLet;
-  GlobalVarLayout::readRecord(scratch, rawLinkage, isFragile, TyID, dID,
-                              IsDeclaration, IsLet);
+  SILGlobalVarLayout::readRecord(scratch, rawLinkage, isFragile,
+                                 IsDeclaration, IsLet, TyID, dID);
   if (TyID == 0) {
     DEBUG(llvm::dbgs() << "SILGlobalVariable typeID is 0.\n");
     return nullptr;