SILGen: Stub unavailable functions.

When `-unavailable-decl-optimization=stub` is specified, insert a call to
`_diagnoseUnavailableCodeReached()` at the beginning of the function to cause
it to trap if executed at run time.

Part of rdar://107388493

Author: tshortli

include/swift/AST/KnownDecls.def

@@ -68,6 +68,7 @@ FUNC_DECL(DiagnoseUnexpectedError, "_unexpectedError")
 FUNC_DECL(DiagnoseUnexpectedNilOptional, "_diagnoseUnexpectedNilOptional")
 FUNC_DECL(DiagnoseUnexpectedEnumCase, "_diagnoseUnexpectedEnumCase")
 FUNC_DECL(DiagnoseUnexpectedEnumCaseValue, "_diagnoseUnexpectedEnumCaseValue")
+FUNC_DECL(DiagnoseUnavailableCodeReached, "_diagnoseUnavailableCodeReached")
 
 FUNC_DECL(GetErrorEmbeddedNSError, "_getErrorEmbeddedNSError")
 

include/swift/SIL/SILModule.h

@@ -1083,6 +1083,10 @@ LLVM_LIBRARY_VISIBILITY bool usesObjCAllocator(ClassDecl *theClass);
 /// A declaration may not require lowering if, for example, it is annotated as
 /// unavailable and optimization settings allow it to be omitted.
 LLVM_LIBRARY_VISIBILITY bool shouldSkipLowering(Decl *D);
+
+/// Returns true if SIL/IR lowering for the given declaration should produce
+/// a stub that traps at runtime because the code ought to be unreachable.
+LLVM_LIBRARY_VISIBILITY bool shouldLowerToUnavailableCodeStub(Decl *D);
 } // namespace Lowering
 
 /// Apply the given function to each ABI member of \c D skipping the members

lib/SIL/IR/SILModule.cpp

@@ -965,3 +965,13 @@ bool Lowering::shouldSkipLowering(Decl *D) {
   // -unavailable-decl-optimization=complete is specified.
   return D->getSemanticUnavailableAttr() != None;
 }
+
+bool Lowering::shouldLowerToUnavailableCodeStub(Decl *D) {
+  if (D->getASTContext().LangOpts.UnavailableDeclOptimizationMode !=
+      UnavailableDeclOptimization::Stub)
+    return false;
+
+  // Unavailable declarations should trap at runtime if
+  // -unavailable-decl-optimization=stub is specified.
+  return D->getSemanticUnavailableAttr() != None;
+}

lib/SILGen/SILGenApply.cpp

@@ -5863,6 +5863,23 @@ SILGenFunction::emitApplyOfLibraryIntrinsic(SILLocation loc,
                    finalArgs, calleeTypeInfo, ApplyOptions(), ctx, None);
 }
 
+void SILGenFunction::emitApplyOfUnavailableCodeReached() {
+  auto loc = RegularLocation::getAutoGeneratedLocation(F.getLocation());
+
+  // FIXME: When the deployment target is < Swift 5.9 the stdlib function will
+  // be unavailable. Call the @backDeployed fallback function instead.
+  auto *diagnoseUnavailableCodeReachedFunc =
+      getASTContext().getDiagnoseUnavailableCodeReached();
+
+  if (!diagnoseUnavailableCodeReachedFunc) {
+    B.createUnconditionalFail(loc, "unavailable code reached");
+    return;
+  }
+
+  emitApplyOfLibraryIntrinsic(loc, diagnoseUnavailableCodeReachedFunc,
+                              SubstitutionMap(), {}, SGFContext());
+}
+
 StringRef SILGenFunction::getMagicFunctionString() {
   assert(MagicFunctionName
          && "asking for #function but we don't have a function name?!");

lib/SILGen/SILGenFunction.cpp

@@ -882,6 +882,9 @@ void SILGenFunction::emitFunction(FuncDecl *fd) {
     prepareEpilog(fd->getResultInterfaceType(),
                   fd->hasThrows(), CleanupLocation(fd));
 
+    if (shouldLowerToUnavailableCodeStub(fd))
+      emitApplyOfUnavailableCodeReached();
+
     emitProfilerIncrement(fd->getTypecheckedBody());
 
     // Emit the actual function body as usual

lib/SILGen/SILGenFunction.h

@@ -1901,6 +1901,10 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
                                      ArrayRef<ManagedValue> args,
                                      SGFContext ctx);
 
+  /// Emits a call to the `_diagnoseUnavailableCodeReached()` function in the
+  /// standard library.
+  void emitApplyOfUnavailableCodeReached();
+
   RValue emitApplyAllocatingInitializer(SILLocation loc, ConcreteDeclRef init,
                                         PreparedArguments &&args, Type overriddenSelfType,
                                         SGFContext ctx);

stdlib/public/core/AssertCommon.swift

@@ -275,3 +275,18 @@ internal func _diagnoseUnexpectedEnumCase<SwitchedValue>(
     "unexpected enum case while switching on value of type '\(type)'",
     flags: _fatalErrorFlags())
 }
+
+/// Called when a function marked `unavailable` with `@available` is invoked
+/// and the module containing the unavailable function was compiled with
+/// `-unavailable-decl-optimization=stub`.
+///
+/// This function should not be inlined because it is cold and inlining just
+/// bloats code.
+@backDeployed(before: SwiftStdlib 5.9)
+@inline(never)
+@_semantics("unavailable_code_reached")
+@usableFromInline // COMPILER_INTRINSIC
+internal func _diagnoseUnavailableCodeReached() -> Never {
+  _assertionFailure(
+    "Fatal error", "Unavailable code reached", flags: _fatalErrorFlags())
+}

test/Interpreter/unavailable_decl_optimization_stub.swift

@@ -0,0 +1,21 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-build-swift -module-name main -Xfrontend -unavailable-decl-optimization=stub %s -o %t/a.out
+// RUN: %target-codesign %t/a.out
+// RUN: %target-run %t/a.out > %t/output 2>&1 || true
+// RUN: %FileCheck %s < %t/output
+
+// REQUIRES: executable_test
+
+@available(*, unavailable)
+public func foo() {
+  print("Can't call this")
+}
+
+// To bypass the typechecker, forward declare an available function with the
+// same mangling as foo.
+@_silgen_name("$s4main3fooyyF")
+func callFoo()
+
+// CHECK: Fatal error: Unavailable code reached
+// CHECK-NOT: Can't call this
+callFoo()

test/SILGen/unavailable_decl_optimization_stub.swift

@@ -0,0 +1,25 @@
+// RUN: %target-swift-emit-silgen -module-name Test -parse-as-library %s -verify -unavailable-decl-optimization=stub | %FileCheck %s --check-prefixes=CHECK
+
+public struct S {}
+
+// CHECK-LABEL: sil {{.*}} @$s4Test15unavailableFuncAA1SVyF
+// CHECK:         [[FNREF:%.*]] = function_ref @$ss31_diagnoseUnavailableCodeReacheds5NeverOyF
+// CHECK-NEXT:    [[APPLY:%.*]] = apply [[FNREF]]()
+// CHECK:         function_ref @$s4Test1SVACycfC
+// CHECK:       } // end sil function '$s4Test15unavailableFuncAA1SVyF'
+@available(*, unavailable)
+public func unavailableFunc() -> S {
+  return S()
+}
+
+enum SomeError: Error { case generic }
+
+// CHECK-LABEL: sil {{.*}} @$s4Test23unavailableThrowingFuncyyKF
+// CHECK:         [[FNREF:%.*]] = function_ref @$ss31_diagnoseUnavailableCodeReacheds5NeverOyF
+// CHECK-NEXT:    [[APPLY:%.*]] = apply [[FNREF]]()
+// CHECK:         throw
+// CHECK:       } // end sil function '$s4Test23unavailableThrowingFuncyyKF'
+@available(*, unavailable)
+public func unavailableThrowingFunc() throws {
+  throw SomeError.generic
+}

test/SILGen/unavailable_decl_optimization_stub_opaque_type.swift

@@ -0,0 +1,15 @@
+// RUN: %target-swift-emit-silgen -target %target-swift-abi-5.1-triple -module-name Test -parse-as-library %s -verify -unavailable-decl-optimization=stub | %FileCheck %s --check-prefixes=CHECK
+
+public protocol P {}
+public struct S {}
+extension S: P {}
+
+// CHECK-LABEL: sil {{.*}} @$s4Test27unavailableOpaqueReturnFuncQryF
+// CHECK:         [[FNREF:%.*]] = function_ref @$ss31_diagnoseUnavailableCodeReacheds5NeverOyF
+// CHECK-NEXT:    [[APPLY:%.*]] = apply [[FNREF]]()
+// CHECK:         function_ref @$s4Test1SVACycfC
+// CHECK:       } // end sil function '$s4Test27unavailableOpaqueReturnFuncQryF'
+@available(*, unavailable)
+public func unavailableOpaqueReturnFunc() -> some P {
+  return S()
+}