Revert "SIL: Remove special meaning for @_semantics("stdlib_binary_only")" (swiftlang#12270)

It still affects StdlibUnittest, which is still using -sil-serialize-all.

Author: jrose-apple

docs/HighLevelSILOptimizations.rst

@@ -117,13 +117,15 @@ Cloning code from the standard library
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 The Swift compiler can copy code from the standard library into the
-application for functions marked @_inlineable. This allows the optimizer to
-inline calls from the stdlib and improve the performance of code that uses
-common operators such as '+=' or basic containers such as Array. However,
-importing code from the standard library can increase the binary size.
-
-To prevent copying of functions from the standard library into the user
-program, make sure the function in question is not marked @_inlineable.
+application. This allows the optimizer to inline calls from stdlib and improve
+the performance of code that uses common operators such as '++' or basic
+containers such as Array. However, importing code from the standard library can
+increase the binary size. Marking functions with @_semantics("stdlib_binary_only")
+will prevent the copying of the marked function from the standard library into the
+user program.
+
+Notice that this annotation is similar to the resilient annotation that will
+disallow the cloning of code into the user application.
 
 Array
 ~~~~~

lib/SIL/Linker.cpp

@@ -26,6 +26,26 @@ using namespace Lowering;
 
 STATISTIC(NumFuncLinked, "Number of SIL functions linked");
 
+//===----------------------------------------------------------------------===//
+//                                  Utility
+//===----------------------------------------------------------------------===//
+
+/// \return True if the function \p F should be imported into the current
+/// module.
+static bool shouldImportFunction(SILFunction *F) {
+  // Skip functions that are marked with the 'no import' tag. These
+  // are functions that we don't want to copy from the module.
+  if (F->hasSemanticsAttr("stdlib_binary_only")) {
+    // If we are importing a function declaration mark it as external since we
+    // are not importing the body.
+    if (F->isExternalDeclaration())
+      F->setLinkage(SILLinkage::PublicExternal);
+    return false;
+  }
+
+  return true;
+}
+
 //===----------------------------------------------------------------------===//
 //                               Linker Helpers
 //===----------------------------------------------------------------------===//
@@ -35,6 +55,9 @@ bool SILLinkerVisitor::processFunction(SILFunction *F) {
   if (Mode == LinkingMode::LinkNone)
     return false;
 
+  if (!shouldImportFunction(F))
+    return false;
+
   // If F is a declaration, first deserialize it.
   if (F->isExternalDeclaration()) {
     auto *NewFn = Loader->lookupSILFunction(F);
@@ -311,6 +334,9 @@ bool SILLinkerVisitor::process() {
   while (!Worklist.empty()) {
     auto *Fn = Worklist.pop_back_val();
 
+    if (!shouldImportFunction(Fn))
+      continue;
+
     DEBUG(llvm::dbgs() << "Process imports in function: "
                        << Fn->getName() << "\n");
 
@@ -320,6 +346,9 @@ bool SILLinkerVisitor::process() {
         if (visit(&I)) {
           for (auto *F : FunctionDeserializationWorklist) {
 
+            if (!shouldImportFunction(F))
+              continue;
+
             DEBUG(llvm::dbgs() << "Imported function: "
                                << F->getName() << "\n");
             F->setBare(IsBare);

lib/SILOptimizer/IPO/GlobalOpt.cpp

@@ -1353,9 +1353,11 @@ void SILGlobalOpt::replaceFindStringCall(ApplyInst *FindStringCall) {
   if (!FD)
     return;
 
-  SILDeclRef declRef(FD, SILDeclRef::Kind::Func);
-  SILFunction *replacementFunc = Module->getOrCreateFunction(
-      FindStringCall->getLoc(), declRef, NotForDefinition);
+  std::string Mangled = SILDeclRef(FD, SILDeclRef::Kind::Func).mangle();
+  SILFunction *replacementFunc = Module->findFunction(Mangled,
+                                                    SILLinkage::PublicExternal);
+  if (!replacementFunc)
+    return;
 
   SILFunctionType *FTy = replacementFunc->getLoweredFunctionType();
   if (FTy->getNumParameters() != 3)
@@ -1365,7 +1367,6 @@ void SILGlobalOpt::replaceFindStringCall(ApplyInst *FindStringCall) {
   NominalTypeDecl *cacheDecl = cacheType.getNominalOrBoundGenericNominal();
   if (!cacheDecl)
     return;
-
   SILType wordTy = cacheType.getFieldType(
                             cacheDecl->getStoredProperties().front(), *Module);
 

lib/SILOptimizer/Utils/Local.cpp

@@ -423,7 +423,11 @@ SILLinkage swift::getSpecializedLinkage(SILFunction *F, SILLinkage L) {
     return SILLinkage::Private;
   }
 
-  return SILLinkage::Shared;
+  // Treat stdlib_binary_only specially. We don't serialize the body of
+  // stdlib_binary_only functions so we can't mark them as Shared (making
+  // their visibility in the dylib hidden).
+  return F->hasSemanticsAttr("stdlib_binary_only") ? SILLinkage::Public
+                                                   : SILLinkage::Shared;
 }
 
 /// Remove all instructions in the body of \p BB in safe manner by using

stdlib/private/StdlibUnittest/StdlibUnittest.swift.gyb

@@ -627,7 +627,7 @@ func _stdlib_installTrapInterceptor()
 #endif
 
 // Avoid serializing references to objc_setUncaughtExceptionHandler in SIL.
-@inline(never)
+@inline(never) @_semantics("stdlib_binary_only")
 func _childProcess() {
   _stdlib_installTrapInterceptor()
 

stdlib/public/core/AssertCommon.swift

@@ -82,8 +82,10 @@ func _fatalErrorFlags() -> UInt32 {
 ///
 /// This function should not be inlined because it is cold and inlining just
 /// bloats code.
-@_versioned // FIXME(sil-serialize-all)
+@_inlineable // FIXME(sil-serialize-all)
+@_versioned
 @inline(never)
+@_semantics("stdlib_binary_only")
 internal func _assertionFailure(
   _ prefix: StaticString, _ message: StaticString,
   file: StaticString, line: UInt,
@@ -112,8 +114,10 @@ internal func _assertionFailure(
 ///
 /// This function should not be inlined because it is cold and inlining just
 /// bloats code.
-@_versioned // FIXME(sil-serialize-all)
+@_inlineable // FIXME(sil-serialize-all)
+@_versioned
 @inline(never)
+@_semantics("stdlib_binary_only")
 internal func _assertionFailure(
   _ prefix: StaticString, _ message: String,
   file: StaticString, line: UInt,
@@ -142,8 +146,10 @@ internal func _assertionFailure(
 ///
 /// This function should not be inlined because it is cold and it inlining just
 /// bloats code.
-@_versioned // FIXME(sil-serialize-all)
+@_inlineable // FIXME(sil-serialize-all)
+@_versioned
 @inline(never)
+@_semantics("stdlib_binary_only")
 @_semantics("arc.programtermination_point")
 internal func _fatalErrorMessage(
   _ prefix: StaticString, _ message: StaticString,

stdlib/public/core/DebuggerSupport.swift

@@ -305,8 +305,10 @@ public enum _DebuggerSupport {
   }
 
   // LLDB uses this function in expressions, and if it is inlined the resulting
-  // LLVM IR is enormous.  As a result, to improve LLDB performance we are not
-  // making it @_inlineable.
+  // LLVM IR is enormous.  As a result, to improve LLDB performance we have made
+  // this stdlib_binary_only, which prevents inlining.
+  @_inlineable // FIXME(sil-serialize-all)
+  @_semantics("stdlib_binary_only")
   public static func stringForPrintObject(_ value: Any) -> String {
     var maxItemCounter = Int.max
     var refs = Set<ObjectIdentifier>()

stdlib/public/core/HashedCollections.swift.gyb

@@ -2862,7 +2862,9 @@ public func _dictionaryUpCast<DerivedKey, DerivedValue, BaseKey, BaseValue>(
 ///
 /// - Precondition: `SwiftKey` and `SwiftValue` are bridged to Objective-C,
 ///   and at least one of them requires non-trivial bridging.
+@_inlineable // FIXME(sil-serialize-all)
 @inline(never)
+@_semantics("stdlib_binary_only")
 public func _dictionaryBridgeToObjectiveC<
   SwiftKey, SwiftValue, ObjCKey, ObjCValue
 >(

stdlib/public/core/OutputStream.swift

@@ -343,9 +343,11 @@ internal func _adHocPrint_unlocked<T, TargetStream : TextOutputStream>(
   }
 }
 
+@_inlineable // FIXME(sil-serialize-all)
 @_versioned
 @inline(never)
 @_semantics("optimize.sil.specialize.generic.never")
+@_semantics("stdlib_binary_only")
 internal func _print_unlocked<T, TargetStream : TextOutputStream>(
   _ value: T, _ target: inout TargetStream
 ) {

stdlib/public/core/Print.swift

@@ -49,7 +49,9 @@
 ///     space (`" "`).
 ///   - terminator: The string to print after all items have been printed. The
 ///     default is a newline (`"\n"`).
+@_inlineable // FIXME(sil-serialize-all)
 @inline(never)
+@_semantics("stdlib_binary_only")
 public func print(
   _ items: Any...,
   separator: String = " ",
@@ -108,7 +110,9 @@ public func print(
 ///     space (`" "`).
 ///   - terminator: The string to print after all items have been printed. The
 ///     default is a newline (`"\n"`).
+@_inlineable // FIXME(sil-serialize-all)
 @inline(never)
+@_semantics("stdlib_binary_only")
 public func debugPrint(
   _ items: Any...,
   separator: String = " ",
@@ -224,8 +228,10 @@ public func debugPrint<Target : TextOutputStream>(
     items, separator: separator, terminator: terminator, to: &output)
 }
 
+@_inlineable // FIXME(sil-serialize-all)
 @_versioned
 @inline(never)
+@_semantics("stdlib_binary_only")
 internal func _print<Target : TextOutputStream>(
   _ items: [Any],
   separator: String = " ",
@@ -243,8 +249,10 @@ internal func _print<Target : TextOutputStream>(
   output.write(terminator)
 }
 
+@_inlineable // FIXME(sil-serialize-all)
 @_versioned
 @inline(never)
+@_semantics("stdlib_binary_only")
 internal func _debugPrint<Target : TextOutputStream>(
   _ items: [Any],
   separator: String = " ",