SILGen: Implement 'complete' unavailable decl optimization.

tshortli · tshortli · commit ada0f0961534 · 2023-03-27T11:40:54.000-07:00
Avoid SIL lowering for declarations marked unavailable when
`-unavailable-decl-optimiation=complete` is specified.

Part of rdar://106674022
diff --git a/include/swift/SIL/SILModule.h b/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
diff --git a/include/swift/SIL/SILVTableVisitor.h b/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);
+    });
   }
 };
 
diff --git a/lib/SIL/IR/SILModule.cpp b/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;
+}
diff --git a/lib/SILGen/SILGen.cpp b/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) {
diff --git a/lib/SILGen/SILGen.h b/lib/SILGen/SILGen.h
@@ -266,6 +266,8 @@ class LLVM_LIBRARY_VISIBILITY SILGenModule : public ASTVisitor<SILGenModule> {
   // Visitors for top-level forms
   //===--------------------------------------------------------------------===//
 
+  void visit(Decl *D);
+
   // These are either not allowed at global scope or don't require
   // code emission.
   void visitImportDecl(ImportDecl *d) {}
diff --git a/lib/SILGen/SILGenType.cpp b/lib/SILGen/SILGenType.cpp
@@ -1085,8 +1085,9 @@ class SILGenType : public TypeMemberVisitor<SILGenType> {
   void emitType() {
     SGM.emitLazyConformancesForType(theType);
 
-    for (Decl *member : theType->getABIMembers())
+    forEachMemberToLower(theType, [&](Decl *member) {
       visit(member);
+    });
 
     // Build a vtable if this is a class.
     if (auto theClass = dyn_cast<ClassDecl>(theType)) {
@@ -1252,9 +1253,10 @@ class SILGenExtension : public TypeMemberVisitor<SILGenExtension> {
     // @_objcImplementation extension, but we don't actually need to do any of
     // the stuff that it currently does.
 
-    for (Decl *member : e->getABIMembers())
+    forEachMemberToLower(e, [&](Decl *member) {
       visit(member);
-    
+    });
+
     // If this is a main-interface @_objcImplementation extension and the class
     // has a synthesized destructor, emit it now.
     if (auto cd = dyn_cast_or_null<ClassDecl>(e->getImplementedObjCDecl())) {
diff --git a/test/SILGen/unavailable_decl_optimization.swift b/test/SILGen/unavailable_decl_optimization.swift
@@ -0,0 +1,228 @@
+// RUN: %target-swift-emit-silgen -module-name Test -parse-as-library %s -verify | %FileCheck %s --check-prefixes=CHECK,CHECK-NO-STRIP
+// RUN: %target-swift-emit-silgen -module-name Test -parse-as-library %s -verify -unavailable-decl-optimization=none | %FileCheck %s --check-prefixes=CHECK,CHECK-NO-STRIP
+// RUN: %target-swift-emit-silgen -module-name Test -parse-as-library %s -verify -unavailable-decl-optimization=complete | %FileCheck %s --check-prefixes=CHECK,CHECK-STRIP
+
+// CHECK-NO-STRIP: s4Test14globalConstant_Wz
+// CHECK-NO-STRIP: s4Test14globalConstantSbvp
+// CHECK-NO-STRIP: s4Test14globalConstant_WZ
+// CHECK-NO-STRIP: s4Test14globalConstantSbvau
+// FIXME: global var isn't stripped
+// HECK-STRIP-NOT: s4Test14globalConstant_Wz
+// HECK-STRIP-NOT: s4Test14globalConstantSbvp
+// HECK-STRIP-NOT: s4Test14globalConstant_WZ
+// HECK-STRIP-NOT: s4Test14globalConstantSbvau
+@available(*, unavailable)
+public let globalConstant = true
+
+// CHECK-NO-STRIP: s4Test15unavailableFuncyyF
+// CHECK-STRIP-NOT: s4Test15unavailableFuncyyF
+@available(*, unavailable)
+public func unavailableFunc() {}
+
+@available(*, unavailable)
+public struct UnavailableStruct<T> {
+  // CHECK-NO-STRIP: s4Test17UnavailableStructV8propertyxvg
+  // CHECK-NO-STRIP: s4Test17UnavailableStructV8propertyxvs
+  // CHECK-NO-STRIP: s4Test17UnavailableStructV8propertyxvM
+  // CHECK-STRIP-NOT: s4Test17UnavailableStructV8propertyxvg
+  // CHECK-STRIP-NOT: s4Test17UnavailableStructV8propertyxvs
+  // CHECK-STRIP-NOT: s4Test17UnavailableStructV8propertyxvM
+  public var property: T
+
+  // CHECK-NO-STRIP: s4Test17UnavailableStructVyACyxGxcfC
+  // CHECK-STRIP-NOT: s4Test17UnavailableStructVyACyxGxcfC
+  public init(_ t: T) {
+    self.property = t
+  }
+
+  // CHECK-NO-STRIP: s4Test17UnavailableStructV6methodyyF
+  // CHECK-STRIP-NOT: s4Test17UnavailableStructV6methodyyF
+  public func method() {}
+}
+
+@available(*, unavailable)
+extension UnavailableStruct {
+  // CHECK-NO-STRIP: s4Test17UnavailableStructV15extensionMethodyyF
+  // CHECK-STRIP-NOT: s4Test17UnavailableStructV15extensionMethodyyF
+  public func extensionMethod() {}
+}
+
+@available(*, unavailable)
+public enum UnavailableEnum {
+  case a, b
+
+  // CHECK-NO-STRIP: s4Test15UnavailableEnumO6methodyyF
+  // CHECK-STRIP-NOT: s4Test15UnavailableEnumO6methodyyF
+  public func method() {}
+}
+
+@available(*, unavailable)
+public class UnavailableClass<T> {
+  // CHECK-NO-STRIP: s4Test16UnavailableClassC8propertyxvg
+  // CHECK-NO-STRIP: s4Test16UnavailableClassC8propertyxvs
+  // CHECK-NO-STRIP: s4Test16UnavailableClassC8propertyxvM
+  // CHECK-STRIP-NOT: s4Test16UnavailableClassC8propertyxvg
+  // CHECK-STRIP-NOT: s4Test16UnavailableClassC8propertyxvs
+  // CHECK-STRIP-NOT: s4Test16UnavailableClassC8propertyxvM
+  public var property: T
+
+  // CHECK-NO-STRIP: s4Test16UnavailableClassCyACyxGxcfC
+  // CHECK-NO-STRIP: s4Test16UnavailableClassCyACyxGxcfc
+  // CHECK-STRIP-NOT: s4Test16UnavailableClassCyACyxGxcfC
+  // CHECK-STRIP-NOT: s4Test16UnavailableClassCyACyxGxcfc
+  public init(_ t: T) {
+    self.property = t
+  }
+
+  // CHECK-NO-STRIP: s4Test16UnavailableClassCfd
+  // CHECK-NO-STRIP: s4Test16UnavailableClassCfD
+  // CHECK-STRIP-NOT: s4Test16UnavailableClassCfd
+  // CHECK-STRIP-NOT: s4Test16UnavailableClassCfD
+  deinit {}
+}
+
+public struct S<T> {
+  // CHECK-NO-STRIP: s4Test1SV19unavailablePropertyxvg
+  // CHECK-NO-STRIP: s4Test1SV19unavailablePropertyxvs
+  // CHECK-NO-STRIP: s4Test1SV19unavailablePropertyxvM
+  // CHECK-STRIP-NOT: s4Test1SV19unavailablePropertyxvg
+  // CHECK-STRIP-NOT: s4Test1SV19unavailablePropertyxvs
+  // CHECK-STRIP-NOT: s4Test1SV19unavailablePropertyxvM
+  @available(*, unavailable)
+  public var unavailableProperty: T
+
+  // CHECK-NO-STRIP: s4Test1SVyACyxGxcfC
+  // CHECK-STRIP-NOT: s4Test1SVyACyxGxcfC
+  @available(*, unavailable)
+  public init(_ t: T) {}
+
+  // CHECK-NO-STRIP: s4Test1SV17unavailableMethodyyF
+  // CHECK-STRIP-NOT: s4Test1SV17unavailableMethodyyF
+  @available(*, unavailable)
+  public func unavailableMethod() {}
+}
+
+@available(*, unavailable)
+extension S {
+  // CHECK-NO-STRIP: s4Test1SV28methodInUnavailableExtensionyyF
+  // CHECK-STRIP-NOT: s4Test1SV28methodInUnavailableExtensionyyF
+  public func methodInUnavailableExtension() {}
+}
+
+public enum E {
+  case a
+
+  @available(*, unavailable)
+  case b
+
+  // CHECK-NO-STRIP: s4Test1EO17unavailableMethodyyF
+  // CHECK-STRIP-NOT: s4Test1EO17unavailableMethodyyF
+  @available(*, unavailable)
+  public func unavailableMethod() {}
+}
+
+public class C<T> {
+  // CHECK-NO-STRIP: s4Test1CC19unavailablePropertyxvg
+  // CHECK-NO-STRIP: s4Test1CC19unavailablePropertyxvs
+  // CHECK-NO-STRIP: s4Test1CC19unavailablePropertyxvM
+  // CHECK-STRIP-NOT: s4Test1CC19unavailablePropertyxvg
+  // CHECK-STRIP-NOT: s4Test1CC19unavailablePropertyxvs
+  // CHECK-STRIP-NOT: s4Test1CC19unavailablePropertyxvM
+  @available(*, unavailable)
+  public var unavailableProperty: T
+
+  // CHECK-NO-STRIP: s4Test1CCyACyxGxcfC
+  // CHECK-NO-STRIP: s4Test1CCyACyxGxcfc
+  // CHECK-STRIP-NOT: s4Test1CCyACyxGxcfC
+  // CHECK-STRIP-NOT: s4Test1CCyACyxGxcfc
+  @available(*, unavailable)
+  public init(_ t: T) {}
+
+  // CHECK: s4Test1CCfd
+  // CHECK: s4Test1CCfD
+  deinit {}
+}
+
+public protocol P {
+  func requirement()
+}
+
+@available(*, unavailable)
+extension S: P {
+  // CHECK-NO-STRIP: s4Test1SV11requirementyyF
+  // CHECK-STRIP-NOT: s4Test1SV11requirementyyF
+  public func requirement() {}
+}
+
+// CHECK-NO-STRIP: s4Test29unavailableFuncWithNestedTypeyyF
+// CHECK-STRIP-NOT: s4Test29unavailableFuncWithNestedTypeyyF
+@available(*, unavailable)
+public func unavailableFuncWithNestedType() {
+  // NOTE: Check lines for this decl are below since local types are emitted
+  // after top level decls.
+  struct Nested {
+    // s4Test29unavailableFuncWithNestedTypeyyF0E0L_V6methodyyF
+    public func method() {}
+  }
+}
+
+
+// MARK: Local types SIL
+
+// CHECK-NO-STRIP: s4Test29unavailableFuncWithNestedTypeyyF0E0L_V6methodyyF
+// CHECK-STRIP-NOT: s4Test29unavailableFuncWithNestedTypeyyF0E0L_V6methodyyF
+
+// MARK: SIL vtables
+
+// CHECK-NO-STRIP: sil_vtable [serialized] UnavailableClass
+// CHECK-STRIP-NOT: sil_vtable [serialized] UnavailableClass
+
+// CHECK-NO-STRIP:      sil_vtable [serialized] C {
+// CHECK-NO-STRIP-NEXT:   #C.unavailableProperty!getter:
+// CHECK-NO-STRIP-NEXT:   #C.unavailableProperty!setter:
+// CHECK-NO-STRIP-NEXT:   #C.unavailableProperty!modify:
+// CHECK-NO-STRIP-NEXT:   #C.init!allocator:
+// CHECK-NO-STRIP-NEXT:   #C.deinit!deallocator:
+// CHECK-NO-STRIP-NEXT: }
+
+// CHECK-STRIP:     sil_vtable [serialized] C {
+// CHECK-STRIP-NOT:   #C.unavailableProperty!getter:
+// CHECK-STRIP-NOT:   #C.unavailableProperty!setter:
+// CHECK-STRIP-NOT:   #C.unavailableProperty!modify:
+// CHECK-STRIP-NOT:   #C.init!allocator:
+// CHECK-STRIP:       #C.deinit!deallocator:
+// CHECK-STRIP:     }
+
+// MARK: SIL witness tables
+
+// CHECK-NO-STRIP: sil_witness_table [serialized] UnavailableEnum: Equatable module Test
+// CHECK-STRIP-NOT: sil_witness_table [serialized] UnavailableEnum: Equatable module Test
+
+// CHECK-NO-STRIP: sil_witness_table [serialized] UnavailableEnum: Hashable module Test
+// CHECK-STRIP-NOT: sil_witness_table [serialized] UnavailableEnum: Hashable module Test
+
+// CHECK: sil_witness_table [serialized] E: Equatable module Test
+
+// CHECK: sil_witness_table [serialized] E: Hashable module Test
+
+// CHECK-NO-STRIP: sil_witness_table [serialized] <T> S<T>: P module Test
+// CHECK-STRIP-NOT: sil_witness_table [serialized] <T> S<T>: P module Test
+
+// MARK: SIL properties
+
+// CHECK-NO-STRIP: sil_property #UnavailableStruct.property<τ_0_0> ()
+// CHECK-STRIP-NOT: sil_property #UnavailableStruct.property<τ_0_0> ()
+
+// CHECK-NO-STRIP: sil_property #UnavailableEnum.hashValue ()
+// CHECK-STRIP-NOT: sil_property #UnavailableEnum.hashValue ()
+
+// CHECK-NO-STRIP: sil_property #UnavailableClass.property<τ_0_0> ()
+// CHECK-STRIP-NOT: sil_property #UnavailableClass.property<τ_0_0> ()
+
+// CHECK-NO-STRIP: sil_property #S.unavailableProperty<τ_0_0> ()
+// CHECK-STRIP-NOT: sil_property #S.unavailableProperty<τ_0_0> ()
+
+// CHECK: sil_property #E.hashValue ()
+
+// CHECK-NO-STRIP: sil_property #C.unavailableProperty<τ_0_0> ()
+// CHECK-STRIP-NOT: sil_property #C.unavailableProperty<τ_0_0> ()

Original file line number	Diff line number	Diff line change
`@@ -141,8 +141,9 @@ template <class T> class SILVTableVisitor {`
`141`	`141`	`if (!theClass->hasKnownSwiftImplementation())`
`142`	`142`	`return;`
`143`	`143`
`144`		`- for (auto member : theClass->getABIMembers())`
	`144`	`+ forEachMemberToLower(theClass, [&](Decl *member) {`
`145`	`145`	`maybeAddMember(member);`
	`146`	`+ });`
`146`	`147`	`}`
`147`	`148`	`};`
`148`	`149`