SIL: Serialize and deserialize has_symbol instructions.

Author: tshortli

include/swift/AST/DiagnosticsSema.def

@@ -6029,9 +6029,6 @@ ERROR(availability_macro_in_inlinable, none,
       "availability macro cannot be used in " FRAGILE_FUNC_KIND "0",
       (unsigned))
 
-ERROR(has_symbol_condition_in_inlinable, none,
-      "'#_hasSymbol' cannot be used in " FRAGILE_FUNC_KIND "0", (unsigned))
-
 #undef FRAGILE_FUNC_KIND
 
 NOTE(resilience_decl_declared_here_public,

include/swift/SIL/SILInstruction.h

@@ -4101,7 +4101,8 @@ class HasSymbolInst final : public LiteralInst {
                     SILType::getBuiltinIntegerType(1, Decl->getASTContext())),
         Decl{Decl} {}
 
-  ValueDecl *getDecl() { return Decl; }
+  ValueDecl *getDecl() const { return Decl; }
+  void getReferencedFunctions(llvm::SmallVector<SILFunction *, 4> &fns) const;
 
   ArrayRef<Operand> getAllOperands() const { return {}; }
   MutableArrayRef<Operand> getAllOperands() { return {}; }

lib/SIL/IR/SILInstructions.cpp

@@ -26,6 +26,7 @@
 #include "swift/SIL/SILCloner.h"
 #include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILModule.h"
+#include "swift/SIL/SILSymbolVisitor.h"
 #include "swift/SIL/SILVisitor.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/SmallString.h"
@@ -2993,3 +2994,13 @@ SILPhiArgument *SwitchEnumInst::createOptionalSomeResult() {
   auto someBB = getCaseDestination(someDecl);
   return createResult(someBB, getOperand()->getType().unwrapOptionalType());
 }
+
+void HasSymbolInst::getReferencedFunctions(
+    llvm::SmallVector<SILFunction *, 4> &fns) const {
+  auto &M = getModule();
+  enumerateFunctionsForHasSymbol(M, getDecl(), [&M, &fns](SILDeclRef declRef) {
+    SILFunction *fn = M.lookUpFunction(declRef);
+    assert(fn);
+    fns.push_back(fn);
+  });
+}

lib/SILOptimizer/IPO/DeadFunctionElimination.cpp

@@ -364,6 +364,12 @@ class DeadFunctionAndGlobalElimination {
           ensureAlive(GA->getReferencedGlobal());
         } else if (auto *GV = dyn_cast<GlobalValueInst>(&I)) {
           ensureAlive(GV->getReferencedGlobal());
+        } else if (auto *HSI = dyn_cast<HasSymbolInst>(&I)) {
+          SmallVector<SILFunction *, 4> fns;
+          HSI->getReferencedFunctions(fns);
+          for (auto fn : fns) {
+            ensureAlive(fn);
+          }
         }
       }
     }

lib/Sema/MiscDiagnostics.cpp

@@ -4515,21 +4515,6 @@ static bool diagnoseHasSymbolCondition(PoundHasSymbolInfo *info,
     return true;
   }
 
-  auto fragileKind = DC->getFragileFunctionKind();
-  if (fragileKind.kind != FragileFunctionKind::None) {
-    // #_hasSymbol cannot be used in inlinable code because of limitations of
-    // the current implementation strategy. It relies on recording the
-    // referenced ValueDecl, mangling a helper function name using that
-    // ValueDecl, and then passing the responsibility of generating the
-    // definition for that helper function to IRGen. In order to lift this
-    // restriction, we will need teach SIL to encode the ValueDecl, or take
-    // another approach entirely.
-    ctx.Diags.diagnose(info->getStartLoc(),
-                       diag::has_symbol_condition_in_inlinable,
-                       fragileKind.getSelector());
-    return true;
-  }
-
   auto decl = info->getReferencedDecl().getDecl();
   if (!decl) {
     // Diagnose because we weren't able to interpret the expression as one
@@ -4538,7 +4523,8 @@ static bool diagnoseHasSymbolCondition(PoundHasSymbolInfo *info,
     return true;
   }
 
-  if (!decl->isWeakImported(DC->getParentModule())) {
+  if (DC->getFragileFunctionKind().kind == FragileFunctionKind::None &&
+      !decl->isWeakImported(DC->getParentModule())) {
     // `if #_hasSymbol(someStronglyLinkedSymbol)` is functionally a no-op
     // and may indicate the developer has mis-identified the declaration
     // they want to check (or forgot to import the module weakly).

lib/Serialization/DeserializeSIL.cpp

@@ -1280,6 +1280,10 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn,
                                                       Attr, Attr2);
     RawOpCode = (unsigned)SILInstructionKind::IncrementProfilerCounterInst;
     break;
+  case SIL_INST_HAS_SYMBOL:
+    SILInstHasSymbolLayout::readRecord(scratch, ValID, ListOfValues);
+    RawOpCode = (unsigned)SILInstructionKind::HasSymbolInst;
+    break;
   }
 
   // FIXME: validate
@@ -2992,7 +2996,13 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn,
     break;
   }
   case SILInstructionKind::HasSymbolInst: {
-    llvm_unreachable("unimplemented"); // FIXME: implement deserialization
+    ValueDecl *decl = cast<ValueDecl>(MF->getDecl(ValID));
+    ResultInst = Builder.createHasSymbol(Loc, decl);
+    // Deserialize the functions that are implicitly referenced by the
+    // instruction.
+    for (auto fnID : ListOfValues) {
+      (void)getFuncForReference(MF->getIdentifierText(fnID));
+    }
     break;
   }
   }

lib/Serialization/ModuleFormat.h

@@ -58,7 +58,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// 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.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 721; // has_symbol SIL instruction
+const uint16_t SWIFTMODULE_VERSION_MINOR = 722; // has_symbol SIL serialization
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///

lib/Serialization/SILFormat.h

@@ -158,6 +158,7 @@ namespace sil_block {
     SIL_INST_LINEAR_FUNCTION_EXTRACT,
     SIL_INST_INCREMENT_PROFILER_COUNTER,
     SIL_MOVEONLY_DEINIT,
+    SIL_INST_HAS_SYMBOL,
   };
 
   using SILInstNoOperandLayout = BCRecordLayout<
@@ -529,6 +530,12 @@ namespace sil_block {
     BCVBR<8>,                // counter index
     BCVBR<8>                 // num counters
   >;
+
+  using SILInstHasSymbolLayout = BCRecordLayout<
+    SIL_INST_HAS_SYMBOL,
+    ValueIDField,               // decl
+    BCArray<IdentifierIDField>  // referenced functions
+  >;
 }
 
 } // end namespace serialization

lib/Serialization/SerializeSIL.cpp

@@ -2490,7 +2490,20 @@ void SILSerializer::writeSILInstruction(const SILInstruction &SI) {
     break;
   }
   case SILInstructionKind::HasSymbolInst: {
-    llvm_unreachable("unimplemented"); // FIXME: implement serialization
+    auto *hsi = cast<HasSymbolInst>(&SI);
+    auto *decl = hsi->getDecl();
+    // Although the instruction doesn't have them as members, we need to
+    // ensure that any SILFunctions that are technically referenced by the
+    // instruction get serialized.
+    SmallVector<SILFunction *, 4> fns;
+    hsi->getReferencedFunctions(fns);
+    SmallVector<IdentifierID, 4> functionRefs;
+    for (auto fn : fns) {
+      functionRefs.push_back(addSILFunctionRef(fn));
+    }
+    SILInstHasSymbolLayout::emitRecord(
+        Out, ScratchRecord, SILAbbrCodes[SILInstHasSymbolLayout::Code],
+        S.addDeclRef(decl), functionRefs);
     break;
   }
   }
@@ -2931,6 +2944,7 @@ void SILSerializer::writeSILBlock(const SILModule *SILMod) {
   registerSILAbbr<SILInstDifferentiableFunctionExtractLayout>();
   registerSILAbbr<SILInstLinearFunctionExtractLayout>();
   registerSILAbbr<SILInstIncrementProfilerCounterLayout>();
+  registerSILAbbr<SILInstHasSymbolLayout>();
 
   registerSILAbbr<VTableLayout>();
   registerSILAbbr<VTableEntryLayout>();

test/Interpreter/has_symbol.swift

@@ -33,9 +33,6 @@
 // to remote executors.
 // UNSUPPORTED: remote_run || device_run
 
-// rdar://102159307 - #_hasSymbol needs to be implemented with a SILInstruction
-// REQUIRES: swift_test_mode_optimize_none
-
 @_weakLinked import helper
 
 // HAS-ANSWER: 42

test/SILOptimizer/has_symbol.swift

@@ -0,0 +1,41 @@
+// RUN: %empty-directory(%t)
+// RUN: split-file %s %t
+// RUN: %target-swift-frontend -O -emit-module -emit-module-path %t/Library.swiftmodule -parse-as-library %t/Library.swift -enable-library-evolution
+// RUN: %target-swift-frontend -O -emit-sil %t/Client.swift -I %t -module-name test | %FileCheck %s
+
+// REQUIRES: VENDOR=apple
+
+//--- Library.swift
+
+@usableFromInline func usableFromInlineFunc() {}
+
+public struct S {
+  @usableFromInline var member: Int = 0
+  public init() {}
+}
+
+@_alwaysEmitIntoClient
+public func serializedHasSymbolFunc(_ s: S) -> Bool {
+  guard #_hasSymbol(usableFromInlineFunc) else { return false }
+  guard #_hasSymbol(s.member) else { return false }
+  return true
+}
+
+//--- Client.swift
+
+@_weakLinked import Library
+
+public func foo() -> Bool {
+  // CHECK:   {{%[0-9]+}} = has_symbol #usableFromInlineFunc
+  // CHECK:   {{%[0-9]+}} = has_symbol #S.member
+  return serializedHasSymbolFunc(S())
+}
+
+// Verify that the functions referenced by the deserialized `has_symbol`
+// instructions have also been deserialized and remain after dead function
+// elimination.
+
+// CHECK: sil @$s7Library20usableFromInlineFuncyyF : $@convention(thin) () -> ()
+// CHECK: sil @$s7Library1SV6memberSivg : $@convention(method) (@in_guaranteed S) -> Int
+// CHECK: sil @$s7Library1SV6memberSivs : $@convention(method) (Int, @inout S) -> ()
+// CHECK: sil @$s7Library1SV6memberSivM : $@yield_once @convention(method) (@inout S) -> @yields @inout Int

test/Sema/has_symbol.swift

@@ -121,15 +121,15 @@ func doIt(_ closure: () -> ()) {
 
 @inlinable
 func testInlinable() {
-  if #_hasSymbol(noArgFunc) {} // expected-error {{'#_hasSymbol' cannot be used in an '@inlinable' function}}
+  if #_hasSymbol(noArgFunc) {}
   doIt {
-    if #_hasSymbol(noArgFunc) {} // expected-error {{'#_hasSymbol' cannot be used in an '@inlinable' function}}
+    if #_hasSymbol(noArgFunc) {}
   }
 }
 
 @_alwaysEmitIntoClient
 func testAEIC() {
-  if #_hasSymbol(noArgFunc) {} // expected-error {{'#_hasSymbol' cannot be used in an '@_alwaysEmitIntoClient' function}}
+  if #_hasSymbol(noArgFunc) {}
 }
 
 func testClosure() {