Merge pull request #64644 from tshortli/strip-unavailable-code

Introduce `-unavailable-decl-optimization`

Author: tshortli

include/swift/Basic/LangOptions.h

@@ -105,6 +105,22 @@ namespace swift {
     TaskToThread,
   };
 
+  /// Describes the code size optimization behavior for code associated with
+  /// declarations that are marked unavailable.
+  enum class UnavailableDeclOptimization : uint8_t {
+    /// No optimization. Unavailable declarations will contribute to the
+    /// resulting binary by default in this mode.
+    None,
+
+    /// Avoid generating any code for unavailable declarations.
+    ///
+    /// NOTE: This optimization can be ABI breaking for a library evolution
+    /// enabled module because existing client binaries built with a
+    /// pre-Swift 5.9 compiler may depend on linkable symbols associated with
+    /// unavailable declarations.
+    Complete,
+  };
+
   /// A collection of options that affect the language dialect and
   /// provide compiler debugging facilities.
   class LangOptions final {
@@ -171,6 +187,10 @@ namespace swift {
     /// Disable API availability checking.
     bool DisableAvailabilityChecking = false;
 
+    /// Optimization mode for unavailable declarations.
+    UnavailableDeclOptimization UnavailableDeclOptimizationMode =
+        UnavailableDeclOptimization::None;
+
     /// Causes the compiler to use weak linkage for symbols belonging to
     /// declarations introduced at the deployment target.
     bool WeakLinkAtTarget = false;

include/swift/Option/Options.td

@@ -490,6 +490,13 @@ def check_api_availability_only : Flag<["-"], "check-api-availability-only">,
   Flags<[HelpHidden, FrontendOption, NoInteractiveOption]>,
   HelpText<"Deprecated, has no effect">;
 
+def unavailable_decl_optimization_EQ : Joined<["-"], "unavailable-decl-optimization=">,
+  MetaVarName<"<complete,none>">,
+  Flags<[FrontendOption, NoInteractiveOption]>,
+  HelpText<"Specify the optimization mode for unavailable declarations. The "
+           "value may be 'none' (no optimization) or 'complete' (code is not "
+           "generated at all unavailable declarations)">;
+
 def library_level : Separate<["-"], "library-level">,
   MetaVarName<"<level>">,
   Flags<[HelpHidden, FrontendOption, ModuleInterfaceOption]>,

include/swift/SIL/SILModule.h

@@ -1078,8 +1078,22 @@ namespace Lowering {
 /// Determine whether the given class will be allocated/deallocated using the
 /// Objective-C runtime, i.e., +alloc and -dealloc.
 LLVM_LIBRARY_VISIBILITY bool usesObjCAllocator(ClassDecl *theClass);
+
+/// Returns true if SIL/IR lowering for the given declaration should be skipped.
+/// 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);
 } // namespace Lowering
 
+/// Apply the given function to each ABI member of \c D skipping the members
+/// that should be skipped according to \c shouldSkipLowering()
+template <typename F>
+void forEachMemberToLower(IterableDeclContext *D, F &&f) {
+  for (auto *member : D->getABIMembers()) {
+    if (!Lowering::shouldSkipLowering(member))
+      f(member);
+  }
+}
 } // namespace swift
 
 #endif

include/swift/SIL/SILVTableVisitor.h

@@ -141,8 +141,9 @@ template <class T> class SILVTableVisitor {
     if (!theClass->hasKnownSwiftImplementation())
       return;
 
-    for (auto member : theClass->getABIMembers())
+    forEachMemberToLower(theClass, [&](Decl *member) {
       maybeAddMember(member);
+    });
   }
 };
 

lib/AST/Availability.cpp

@@ -181,6 +181,9 @@ AvailabilityInference::parentDeclForInferredAvailability(const Decl *D) {
       return NTD;
   }
 
+  if (auto *PBD = dyn_cast<PatternBindingDecl>(D))
+    return PBD->getAnchoringVarDecl(0);
+
   // Clang decls may be inaccurately parented rdar://53956555
   if (D->hasClangNode())
     return nullptr;

lib/Frontend/CompilerInvocation.cpp

@@ -552,6 +552,20 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
     Diags.diagnose(SourceLoc(), diag::warn_flag_deprecated,
                    "-check-api-availability-only");
 
+  if (const Arg *A = Args.getLastArg(OPT_unavailable_decl_optimization_EQ)) {
+    auto value =
+        llvm::StringSwitch<Optional<UnavailableDeclOptimization>>(A->getValue())
+            .Case("none", UnavailableDeclOptimization::None)
+            .Case("complete", UnavailableDeclOptimization::Complete)
+            .Default(None);
+
+    if (value)
+      Opts.UnavailableDeclOptimizationMode = *value;
+    else
+      Diags.diagnose(SourceLoc(), diag::error_invalid_arg_value,
+                     A->getAsString(Args), A->getValue());
+  }
+
   Opts.WeakLinkAtTarget |= Args.hasArg(OPT_weak_link_at_target);
 
   if (auto A = Args.getLastArg(OPT_enable_conformance_availability_errors,

lib/IRGen/GenDecl.cpp

@@ -2458,9 +2458,13 @@ void swift::irgen::disableAddressSanitizer(IRGenModule &IGM, llvm::GlobalVariabl
 
 /// Emit a global declaration.
 void IRGenModule::emitGlobalDecl(Decl *D) {
+  if (Lowering::shouldSkipLowering(D))
+    return;
+
   D->visitAuxiliaryDecls([&](Decl *decl) {
     emitGlobalDecl(decl);
   });
+
   switch (D->getKind()) {
   case DeclKind::Extension:
     return emitExtension(cast<ExtensionDecl>(D));

lib/IRGen/TBDGen.cpp

@@ -414,6 +414,9 @@ void TBDGenVisitor::addSymbol(StringRef name, SymbolSource source,
 }
 
 bool TBDGenVisitor::willVisitDecl(Decl *D) {
+  if (Lowering::shouldSkipLowering(D))
+    return false;
+
   // A @_silgen_name("...") function without a body only exists to
   // forward-declare a symbol from another library.
   if (auto AFD = dyn_cast<AbstractFunctionDecl>(D))

lib/SIL/IR/SILModule.cpp

@@ -955,3 +955,13 @@ bool Lowering::usesObjCAllocator(ClassDecl *theClass) {
   // allocation methods because they may have been overridden.
   return theClass->getObjectModel() == ReferenceCounting::ObjC;
 }
+
+bool Lowering::shouldSkipLowering(Decl *D) {
+  if (D->getASTContext().LangOpts.UnavailableDeclOptimizationMode !=
+      UnavailableDeclOptimization::Complete)
+    return false;
+
+  // Unavailable declarations should be skipped if
+  // -unavailable-decl-optimization=complete is specified.
+  return D->getSemanticUnavailableAttr() != None;
+}

lib/SILGen/SILGen.cpp

@@ -770,6 +770,13 @@ bool SILGenModule::hasFunction(SILDeclRef constant) {
   return emittedFunctions.count(constant);
 }
 
+void SILGenModule::visit(Decl *D) {
+  if (Lowering::shouldSkipLowering(D))
+    return;
+
+  ASTVisitor::visit(D);
+}
+
 void SILGenModule::visitFuncDecl(FuncDecl *fd) { emitFunction(fd); }
 
 void SILGenModule::emitFunctionDefinition(SILDeclRef constant, SILFunction *f) {