Add @_weakLinked and a corresponding SIL attribute

This is mostly intended to be used for testing at this point; in the
long run, we want to be using availability information to decide
whether to weak-link something or not. You'll notice a bunch of FIXMEs
in the test case that we may not need now, but will probably need to
handle in the future.

Groundwork for doing backward-deployment execution tests.

Author: jrose-apple

include/swift/AST/Attr.def

@@ -308,6 +308,12 @@ DECL_ATTR(_clangImporterSynthesizedType, ClangImporterSynthesizedType,
           LongAttribute | NotSerialized | RejectByParser | UserInaccessible,
           /*Not serialized*/74)
 
+SIMPLE_DECL_ATTR(_weakLinked, WeakLinked,
+                 OnEnum | OnStruct | OnClass | OnProtocol |
+                 OnFunc | OnVar | OnSubscript | OnConstructor | OnEnumElement |
+                 UserInaccessible,
+                 75)
+
 #undef TYPE_ATTR
 #undef DECL_ATTR_ALIAS
 #undef SIMPLE_DECL_ATTR

include/swift/IRGen/Linking.h

@@ -733,9 +733,12 @@ class LinkEntity {
         getSILGlobalVariable()->getDecl())
       return getSILGlobalVariable()->getDecl()->isWeakImported(module);
 
-    if (getKind() == Kind::SILFunction)
+    if (getKind() == Kind::SILFunction) {
       if (auto clangOwner = getSILFunction()->getClangNodeOwner())
         return clangOwner->isWeakImported(module);
+      if (getSILFunction()->isWeakLinked())
+        return getSILFunction()->isAvailableExternally();
+    }
 
     if (!isDeclKind(getKind()))
       return false;

include/swift/SIL/SILFunction.h

@@ -171,6 +171,9 @@ class SILFunction
   /// would indicate.
   unsigned HasCReferences : 1;
 
+  /// Whether cross-module references to this function should use weak linking.
+  unsigned IsWeakLinked : 1;
+
   /// If != OptimizationMode::NotSet, the optimization mode specified with an
   /// function attribute.
   OptimizationMode OptMode;
@@ -450,6 +453,16 @@ class SILFunction
   bool hasCReferences() const { return HasCReferences; }
   void setHasCReferences(bool value) { HasCReferences = value; }
 
+  /// Returns whether this function's symbol must always be weakly referenced
+  /// across module boundaries.
+  bool isWeakLinked() const { return IsWeakLinked; }
+  /// Forces IRGen to treat references to this function as weak across module
+  /// boundaries (i.e. if it has external linkage).
+  void setWeakLinked(bool value = true) {
+    assert(!IsWeakLinked && "already set");
+    IsWeakLinked = value;
+  }
+
   /// Get the DeclContext of this function. (Debug info only).
   DeclContext *getDeclContext() const {
     return getLocation().getAsDeclContext();

include/swift/Serialization/ModuleFormat.h

@@ -54,7 +54,8 @@ 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 = 398; // Private discriminators for type xrefs
+/// Don't worry about adhering to the 80-column limit for this line.
+const uint16_t VERSION_MINOR = 399; // Last change: @_weakLinked
 
 using DeclIDField = BCFixed<31>;
 

lib/AST/Decl.cpp

@@ -482,7 +482,14 @@ bool Decl::isWeakImported(ModuleDecl *fromModule) const {
     return clangDecl->isWeakImported();
   }
 
-  // FIXME: Implement using AvailableAttr::getVersionAvailability().
+  auto *containingModule = getModuleContext();
+  if (containingModule == fromModule)
+    return false;
+
+  if (getAttrs().hasAttribute<WeakLinkedAttr>())
+    return true;
+
+  // FIXME: Also check availability when containingModule is resilient.
   return false;
 }
 

lib/ParseSIL/ParseSIL.cpp

@@ -882,7 +882,7 @@ static bool parseDeclSILOptional(bool *isTransparent,
                                  IsThunk_t *isThunk, bool *isGlobalInit,
                                  Inline_t *inlineStrategy,
                                  OptimizationMode *optimizationMode,
-                                 bool *isLet,
+                                 bool *isLet, bool *isWeakLinked,
                                  SmallVectorImpl<std::string> *Semantics,
                                  SmallVectorImpl<ParsedSpecAttr> *SpecAttrs,
                                  ValueDecl **ClangDecl,
@@ -909,6 +909,8 @@ static bool parseDeclSILOptional(bool *isTransparent,
       *isThunk = IsReabstractionThunk;
     else if (isGlobalInit && SP.P.Tok.getText() == "global_init")
       *isGlobalInit = true;
+    else if (isWeakLinked && SP.P.Tok.getText() == "_weakLinked")
+      *isWeakLinked = true;
     else if (inlineStrategy && SP.P.Tok.getText() == "noinline")
       *inlineStrategy = NoInline;
     else if (optimizationMode && SP.P.Tok.getText() == "Onone")
@@ -5089,7 +5091,7 @@ bool SILParserTUState::parseDeclSIL(Parser &P) {
   bool isTransparent = false;
   IsSerialized_t isSerialized = IsNotSerialized;
   IsThunk_t isThunk = IsNotThunk;
-  bool isGlobalInit = false;
+  bool isGlobalInit = false, isWeakLinked = false;
   Inline_t inlineStrategy = InlineDefault;
   OptimizationMode optimizationMode = OptimizationMode::NotSet;
   SmallVector<std::string, 1> Semantics;
@@ -5099,7 +5101,7 @@ bool SILParserTUState::parseDeclSIL(Parser &P) {
   if (parseSILLinkage(FnLinkage, P) ||
       parseDeclSILOptional(&isTransparent, &isSerialized, &isThunk, &isGlobalInit,
                            &inlineStrategy, &optimizationMode, nullptr,
-                           &Semantics, &SpecAttrs,
+                           &isWeakLinked, &Semantics, &SpecAttrs,
                            &ClangDecl, &MRK, FunctionState) ||
       P.parseToken(tok::at_sign, diag::expected_sil_function_name) ||
       P.parseIdentifier(FnName, FnNameLoc, diag::expected_sil_function_name) ||
@@ -5125,6 +5127,7 @@ bool SILParserTUState::parseDeclSIL(Parser &P) {
     FunctionState.F->setSerialized(IsSerialized_t(isSerialized));
     FunctionState.F->setThunk(IsThunk_t(isThunk));
     FunctionState.F->setGlobalInit(isGlobalInit);
+    FunctionState.F->setWeakLinked(isWeakLinked);
     FunctionState.F->setInlineStrategy(inlineStrategy);
     FunctionState.F->setOptimizationMode(optimizationMode);
     FunctionState.F->setEffectsKind(MRK);
@@ -5257,7 +5260,7 @@ bool SILParserTUState::parseSILGlobal(Parser &P) {
   if (parseSILLinkage(GlobalLinkage, P) ||
       parseDeclSILOptional(nullptr, &isSerialized, nullptr, nullptr,
                            nullptr, nullptr, &isLet, nullptr, nullptr, nullptr,
-                           nullptr, State) ||
+                           nullptr, nullptr, State) ||
       P.parseToken(tok::at_sign, diag::expected_sil_value_name) ||
       P.parseIdentifier(GlobalName, NameLoc, diag::expected_sil_value_name) ||
       P.parseToken(tok::colon, diag::expected_sil_type))
@@ -5300,7 +5303,7 @@ bool SILParserTUState::parseSILVTable(Parser &P) {
   IsSerialized_t Serialized = IsNotSerialized;
   if (parseDeclSILOptional(nullptr, &Serialized, nullptr, nullptr,
                            nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
-                           nullptr, VTableState))
+                           nullptr, nullptr, VTableState))
     return true;
 
   // Parse the class name.
@@ -5650,7 +5653,7 @@ bool SILParserTUState::parseSILWitnessTable(Parser &P) {
   IsSerialized_t isSerialized = IsNotSerialized;
   if (parseDeclSILOptional(nullptr, &isSerialized, nullptr, nullptr,
                            nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
-                           nullptr, WitnessState))
+                           nullptr, nullptr, WitnessState))
     return true;
 
   Scope S(&P, ScopeKind::TopLevel);

lib/SIL/SILFunction.cpp

@@ -98,7 +98,7 @@ SILFunction::SILFunction(SILModule &Module, SILLinkage Linkage, StringRef Name,
       Serialized(isSerialized), Thunk(isThunk),
       ClassSubclassScope(unsigned(classSubclassScope)), GlobalInitFlag(false),
       InlineStrategy(inlineStrategy), Linkage(unsigned(Linkage)),
-      HasCReferences(false),
+      HasCReferences(false), IsWeakLinked(false),
       OptMode(OptimizationMode::NotSet), EffectsKindAttr(E),
       EntryCount(entryCount) {
   if (InsertBefore)

lib/SIL/SILModule.cpp

@@ -310,6 +310,9 @@ static void addFunctionAttributes(SILFunction *F, DeclAttributes &Attrs,
   if (Attrs.hasAttribute<SILGenNameAttr>() ||
       Attrs.hasAttribute<CDeclAttr>())
     F->setHasCReferences(true);
+
+  if (Attrs.hasAttribute<WeakLinkedAttr>())
+    F->setWeakLinked();
 }
 
 SILFunction *SILModule::getOrCreateFunction(SILLocation loc,

lib/SIL/SILPrinter.cpp

@@ -2280,7 +2280,9 @@ void SILFunction::print(SILPrintContext &PrintCtx) const {
 
   if (isGlobalInit())
     OS << "[global_init] ";
-  
+  if (isWeakLinked())
+    OS << "[_weakLinked] ";
+
   switch (getInlineStrategy()) {
     case NoInline: OS << "[noinline] "; break;
     case AlwaysInline: OS << "[always_inline] "; break;

lib/Sema/TypeCheckAttr.cpp

@@ -112,6 +112,7 @@ class AttributeEarlyChecker : public AttributeVisitor<AttributeEarlyChecker> {
   IGNORED_ATTR(UIApplicationMain)
   IGNORED_ATTR(UnsafeNoObjCTaggedPointer)
   IGNORED_ATTR(Versioned)
+  IGNORED_ATTR(WeakLinked)
 #undef IGNORED_ATTR
 
   // @noreturn has been replaced with a 'Never' return type.
@@ -833,6 +834,7 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
     IGNORED_ATTR(Testable)
     IGNORED_ATTR(Transparent)
     IGNORED_ATTR(WarnUnqualifiedAccess)
+    IGNORED_ATTR(WeakLinked)
 #undef IGNORED_ATTR
 
   void visitAvailableAttr(AvailableAttr *attr);

lib/Sema/TypeCheckDecl.cpp

@@ -6527,6 +6527,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     UNINTERESTING_ATTR(DowngradeExhaustivityCheck)
     UNINTERESTING_ATTR(ImplicitlyUnwrappedOptional)
     UNINTERESTING_ATTR(ClangImporterSynthesizedType)
+    UNINTERESTING_ATTR(WeakLinked)
 #undef UNINTERESTING_ATTR
 
     void visitAvailableAttr(AvailableAttr *attr) {

lib/Serialization/DeserializeSIL.cpp

@@ -413,12 +413,12 @@ SILFunction *SILDeserializer::readSILFunction(DeclID FID,
   GenericEnvironmentID genericEnvID;
   unsigned rawLinkage, isTransparent, isSerialized, isThunk, isGlobal,
       inlineStrategy, optimizationMode, effect, numSpecAttrs,
-      hasQualifiedOwnership;
+      hasQualifiedOwnership, isWeakLinked;
   ArrayRef<uint64_t> SemanticsIDs;
   SILFunctionLayout::readRecord(scratch, rawLinkage, isTransparent, isSerialized,
                                 isThunk, isGlobal, inlineStrategy,
-                                optimizationMode, effect,
-                                numSpecAttrs, hasQualifiedOwnership, funcTyID,
+                                optimizationMode, effect, numSpecAttrs,
+                                hasQualifiedOwnership, isWeakLinked, funcTyID,
                                 genericEnvID, clangNodeOwnerID, SemanticsIDs);
 
   if (funcTyID == 0) {
@@ -498,6 +498,7 @@ SILFunction *SILDeserializer::readSILFunction(DeclID FID,
     fn->setGlobalInit(isGlobal == 1);
     fn->setEffectsKind((EffectsKind)effect);
     fn->setOptimizationMode((OptimizationMode)optimizationMode);
+    fn->setWeakLinked(isWeakLinked);
     if (clangNodeOwner)
       fn->setClangNodeOwner(clangNodeOwner);
     for (auto ID : SemanticsIDs) {
@@ -2405,12 +2406,12 @@ bool SILDeserializer::hasSILFunction(StringRef Name,
   GenericEnvironmentID genericEnvID;
   unsigned rawLinkage, isTransparent, isSerialized, isThunk, isGlobal,
     inlineStrategy, optimizationMode, effect, numSpecAttrs,
-    hasQualifiedOwnership;
+    hasQualifiedOwnership, isWeakLinked;
   ArrayRef<uint64_t> SemanticsIDs;
   SILFunctionLayout::readRecord(scratch, rawLinkage, isTransparent, isSerialized,
                                 isThunk, isGlobal, inlineStrategy,
-                                optimizationMode, effect,
-                                numSpecAttrs, hasQualifiedOwnership, funcTyID,
+                                optimizationMode, effect, numSpecAttrs,
+                                hasQualifiedOwnership, isWeakLinked, funcTyID,
                                 genericEnvID, clangOwnerID, SemanticsIDs);
   auto linkage = fromStableSILLinkage(rawLinkage);
   if (!linkage) {

lib/Serialization/SILFormat.h

@@ -280,6 +280,7 @@ namespace sil_block {
                      BCFixed<2>,  // side effect info.
                      BCVBR<8>,    // number of specialize attributes
                      BCFixed<1>,  // has qualified ownership
+                     BCFixed<1>,  // must be weakly referenced
                      TypeIDField, // SILFunctionType
                      GenericEnvironmentIDField,
                      DeclIDField, // ClangNode owner

lib/Serialization/SerializeSIL.cpp

@@ -379,8 +379,8 @@ void SILSerializer::writeSILFunction(const SILFunction &F, bool DeclOnly) {
       (unsigned)F.isThunk(), (unsigned)F.isGlobalInit(),
       (unsigned)F.getInlineStrategy(), (unsigned)F.getOptimizationMode(),
       (unsigned)F.getEffectsKind(),
-      (unsigned)numSpecAttrs, (unsigned)F.hasQualifiedOwnership(), FnID,
-      genericEnvID, clangNodeOwnerID, SemanticsIDs);
+      (unsigned)numSpecAttrs, (unsigned)F.hasQualifiedOwnership(),
+      F.isWeakLinked(), FnID, genericEnvID, clangNodeOwnerID, SemanticsIDs);
 
   if (NoBody)
     return;

test/IRGen/Inputs/weak_import_native_helper.swift

@@ -0,0 +1,105 @@
+@_weakLinked
+public func fn() {}
+
+@_weakLinked
+public var globalStored = 0
+
+@_weakLinked
+public var globalComputed: Int {
+  get { return 1 }
+  set {}
+}
+
+public struct S {
+  @_weakLinked
+  public func fn() {}
+
+  @_weakLinked
+  public var storedProp = 0
+
+  @_weakLinked
+  public var computedProp: Int {
+    get { return 1 }
+    set {}
+  }
+
+  @_weakLinked
+  public init() {}
+
+  @_weakLinked
+  public subscript(_: Int) -> Int {
+    get { return 1 }
+    set {}
+  }
+}
+
+public enum E {
+  case strong
+
+  @_weakLinked
+  case weak
+
+  case strongAssoc(Int)
+
+  @_weakLinked
+  case weakAssoc(Int)
+}
+
+open class C {
+  @_weakLinked
+  open func fn() {}
+
+  @_weakLinked
+  open var storedProp = 0
+
+  @_weakLinked
+  open var computedProp: Int {
+    get { return 1 }
+    set {}
+  }
+
+  @_weakLinked
+  public init() {}
+
+  @_weakLinked
+  open subscript(_: Int) -> Int {
+    get { return 1 }
+    set {}
+  }
+}
+
+public protocol P {
+  @_weakLinked
+  func fn()
+
+  @_weakLinked
+  var prop: Int { get set }
+
+  @_weakLinked
+  init()
+
+  @_weakLinked
+  subscript(_: Int) -> Int { get set }
+}
+
+@_weakLinked
+public struct WeakS {}
+
+@_weakLinked
+public enum WeakE {}
+
+@_weakLinked
+open class WeakC {}
+
+@_weakLinked
+public protocol WeakP {}
+
+
+@_weakLinked
+public struct GenericS<T> {}
+
+@_weakLinked
+public enum GenericE<T> {}
+
+@_weakLinked
+open class GenericC<T> {}

test/IRGen/weak_import.swift renamed to test/IRGen/weak_import_clang.swift

@@ -0,0 +1,23 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -primary-file %s -emit-ir | %FileCheck %s
+
+sil_stage canonical
+
+// CHECK-DAG: define{{( protected)?}} swiftcc void @weakButDefined() {{#[0-9]+}} {
+sil public [_weakLinked] @weakButDefined : $@convention(thin) () -> () {
+  %unit = tuple()
+  return %unit : $()
+}
+
+// CHECK-DAG: declare extern_weak swiftcc void @weakExternal()
+sil public_external [_weakLinked] @weakExternal : $@convention(thin) () -> ()
+
+sil [_weakLinked] @testWeak : $@convention(thin) () -> () {
+  %weakButDefined = function_ref @weakButDefined : $@convention(thin) () -> ()
+  %wbdResult      = apply %weakButDefined() : $@convention(thin) () -> ()
+  %weakExternal   = function_ref @weakExternal : $@convention(thin) () -> ()
+  %weResult       = apply %weakExternal() : $@convention(thin) () -> ()
+  %unit = tuple()
+  return %unit : $()
+}
+