Merge pull request #70152 from zoecarver/three-new-perf-annotations

zoecarver · web-flow · commit a6967e33516a · 2023-12-01T12:38:36.000-07:00
[opt] Add three new perf annotations: `@_noRuntime`, `@_noExistentials`, and `@_noObjCBridging`.
diff --git a/SwiftCompilerSources/Sources/SIL/Function.swift b/SwiftCompilerSources/Sources/SIL/Function.swift
@@ -203,13 +203,19 @@ final public class Function : CustomStringConvertible, HasShortDescription, Hash
     case none
     case noAllocations
     case noLocks
+    case noRuntime
+    case noExistentials
+    case noObjCRuntime
   }
 
   public var performanceConstraints: PerformanceConstraints {
     switch bridged.getPerformanceConstraints() {
       case .None: return .none
       case .NoAllocation: return .noAllocations
       case .NoLocks: return .noLocks
+      case .NoRuntime: return .noRuntime
+      case .NoExistentials: return .noExistentials
+      case .NoObjCBridging: return .noObjCRuntime
       default: fatalError("unknown performance constraint")
     }
   }
diff --git a/include/swift/AST/Attr.def b/include/swift/AST/Attr.def
@@ -536,6 +536,15 @@ SIMPLE_DECL_ATTR(_staticExclusiveOnly, StaticExclusiveOnly,
 SIMPLE_DECL_ATTR(extractConstantsFromMembers, ExtractConstantsFromMembers,
   OnProtocol | UserInaccessible | ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove,
   152)
+SIMPLE_DECL_ATTR(_noRuntime, NoRuntime,
+  OnAbstractFunction | OnSubscript | UserInaccessible | ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove,
+  153)
+SIMPLE_DECL_ATTR(_noExistentials, NoExistentials,
+  OnAbstractFunction | OnSubscript | UserInaccessible | ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove,
+  154)
+SIMPLE_DECL_ATTR(_noObjCBridging, NoObjCBridging,
+  OnAbstractFunction | OnSubscript | UserInaccessible | ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove,
+  155)
 
 #undef TYPE_ATTR
 #undef DECL_ATTR_ALIAS
diff --git a/include/swift/AST/DiagnosticsSIL.def b/include/swift/AST/DiagnosticsSIL.def
@@ -356,6 +356,10 @@ ERROR(embedded_swift_existential_type,none,
       "cannot use a value of protocol type %0 in embedded Swift", (Type))
 ERROR(embedded_swift_existential,none,
       "cannot use a value of protocol type in embedded Swift", ())
+ERROR(perf_diag_existential_type,none,
+      "cannot use a value of protocol type %0 in @_noExistential function", (Type))
+ERROR(perf_diag_existential,none,
+      "cannot use a value of protocol type in @_noExistential function", ())
 ERROR(embedded_swift_metatype_type,none,
       "cannot use metatype of type %0 in embedded Swift", (Type))
 ERROR(embedded_swift_metatype,none,
diff --git a/include/swift/SIL/SILBridging.h b/include/swift/SIL/SILBridging.h
@@ -302,7 +302,10 @@ struct BridgedFunction {
   enum class PerformanceConstraints {
     None = 0,
     NoAllocation = 1,
-    NoLocks = 2
+    NoLocks = 2,
+    NoRuntime = 3,
+    NoExistentials = 4,
+    NoObjCBridging = 5
   };
 
   enum class InlineStrategy {
diff --git a/include/swift/SIL/SILFunction.h b/include/swift/SIL/SILFunction.h
@@ -86,6 +86,9 @@ enum class PerformanceConstraints : uint8_t {
   None = 0,
   NoAllocation = 1,
   NoLocks = 2,
+  NoRuntime = 3,
+  NoExistentials = 4,
+  NoObjCBridging = 5
 };
 
 class SILSpecializeAttr final {
diff --git a/lib/SIL/IR/SILFunctionBuilder.cpp b/lib/SIL/IR/SILFunctionBuilder.cpp
@@ -193,6 +193,12 @@ void SILFunctionBuilder::addFunctionAttributes(
     F->setPerfConstraints(PerformanceConstraints::NoLocks);
   } else if (Attrs.hasAttribute<NoAllocationAttr>()) {
     F->setPerfConstraints(PerformanceConstraints::NoAllocation);
+  } else if (Attrs.hasAttribute<NoRuntimeAttr>()) {
+    F->setPerfConstraints(PerformanceConstraints::NoRuntime);
+  } else if (Attrs.hasAttribute<NoExistentialsAttr>()) {
+    F->setPerfConstraints(PerformanceConstraints::NoExistentials);
+  } else if (Attrs.hasAttribute<NoObjCBridgingAttr>()) {
+    F->setPerfConstraints(PerformanceConstraints::NoObjCBridging);
   }
 
   if (Attrs.hasAttribute<LexicalLifetimesAttr>()) {
diff --git a/lib/SIL/IR/SILPrinter.cpp b/lib/SIL/IR/SILPrinter.cpp
@@ -3318,9 +3318,12 @@ void SILFunction::print(SILPrintContext &PrintCtx) const {
 
   PerformanceConstraints perf = getPerfConstraints();
   switch (perf) {
-    case PerformanceConstraints::None:         break;
-    case PerformanceConstraints::NoLocks:      OS << "[no_locks] "; break;
-    case PerformanceConstraints::NoAllocation: OS << "[no_allocation] "; break;
+    case PerformanceConstraints::None:           break;
+    case PerformanceConstraints::NoLocks:        OS << "[no_locks] "; break;
+    case PerformanceConstraints::NoAllocation:   OS << "[no_allocation] "; break;
+    case PerformanceConstraints::NoRuntime:      OS << "[no_runtime] "; break;
+    case PerformanceConstraints::NoExistentials: OS << "[no_existentials] "; break;
+    case PerformanceConstraints::NoObjCBridging: OS << "[no_objc_bridging] "; break;
   }
 
   if (getEffectsKind() == EffectsKind::ReadOnly)
diff --git a/lib/SIL/Parser/ParseSIL.cpp b/lib/SIL/Parser/ParseSIL.cpp
@@ -1149,6 +1149,12 @@ static bool parseDeclSILOptional(bool *isTransparent,
       *perfConstraints = PerformanceConstraints::NoLocks;
     else if (perfConstraints && SP.P.Tok.getText() == "no_allocation")
       *perfConstraints = PerformanceConstraints::NoAllocation;
+    else if (perfConstraints && SP.P.Tok.getText() == "no_runtime")
+      *perfConstraints = PerformanceConstraints::NoRuntime;
+    else if (perfConstraints && SP.P.Tok.getText() == "no_existentials")
+      *perfConstraints = PerformanceConstraints::NoExistentials;
+    else if (perfConstraints && SP.P.Tok.getText() == "no_objc_bridging")
+      *perfConstraints = PerformanceConstraints::NoObjCBridging;
     else if (markedAsUsed && SP.P.Tok.getText() == "used")
       *markedAsUsed = true;
     else if (section && SP.P.Tok.getText() == "section") {
diff --git a/lib/SIL/Utils/SILBridging.cpp b/lib/SIL/Utils/SILBridging.cpp
@@ -212,6 +212,9 @@ static_assert((int)BridgedFunction::EffectsKind::Custom == (int)swift::EffectsKi
 static_assert((int)BridgedFunction::PerformanceConstraints::None == (int)swift::PerformanceConstraints::None);
 static_assert((int)BridgedFunction::PerformanceConstraints::NoAllocation == (int)swift::PerformanceConstraints::NoAllocation);
 static_assert((int)BridgedFunction::PerformanceConstraints::NoLocks == (int)swift::PerformanceConstraints::NoLocks);
+static_assert((int)BridgedFunction::PerformanceConstraints::NoRuntime == (int)swift::PerformanceConstraints::NoRuntime);
+static_assert((int)BridgedFunction::PerformanceConstraints::NoExistentials == (int)swift::PerformanceConstraints::NoExistentials);
+static_assert((int)BridgedFunction::PerformanceConstraints::NoObjCBridging == (int)swift::PerformanceConstraints::NoObjCBridging);
 
 static_assert((int)BridgedFunction::InlineStrategy::InlineDefault == (int)swift::InlineDefault);
 static_assert((int)BridgedFunction::InlineStrategy::NoInline == (int)swift::NoInline);
diff --git a/lib/SILOptimizer/Mandatory/PerformanceDiagnostics.cpp b/lib/SILOptimizer/Mandatory/PerformanceDiagnostics.cpp
@@ -388,6 +388,28 @@ bool PerformanceDiagnostics::visitInst(SILInstruction *inst,
   RuntimeEffect impact = getRuntimeEffect(inst, impactType);
   LocWithParent loc(inst->getLoc().getSourceLoc(), parentLoc);
 
+  if (perfConstr == PerformanceConstraints::NoExistentials &&
+      (impact & RuntimeEffect::Existential)) {
+    PrettyStackTracePerformanceDiagnostics stackTrace("existential", inst);
+    if (impactType) {
+      diagnose(loc, diag::perf_diag_existential_type, impactType.getASTType());
+    } else {
+      diagnose(loc, diag::perf_diag_existential);
+    }
+    return true;
+  }
+
+  if ((perfConstr == PerformanceConstraints::NoObjCBridging ||
+       perfConstr == PerformanceConstraints::NoAllocation ||
+       perfConstr == PerformanceConstraints::NoLocks) &&
+      (impact & RuntimeEffect::ObjectiveC)) {
+    PrettyStackTracePerformanceDiagnostics stackTrace(
+        "found objc effect", inst);
+
+    diagnose(loc, diag::performance_objectivec);
+    return true;
+  }
+
   if (module.getOptions().EmbeddedSwift) {
     if (impact & RuntimeEffect::Existential) {
       PrettyStackTracePerformanceDiagnostics stackTrace("existential", inst);
@@ -412,7 +434,9 @@ bool PerformanceDiagnostics::visitInst(SILInstruction *inst,
     }
   }
 
-  if (perfConstr == PerformanceConstraints::None)
+  if (perfConstr == PerformanceConstraints::None ||
+      perfConstr == PerformanceConstraints::NoExistentials ||
+      perfConstr == PerformanceConstraints::NoObjCBridging)
     return false;
 
   if (impact & RuntimeEffect::Casting) {
@@ -477,6 +501,10 @@ bool PerformanceDiagnostics::visitInst(SILInstruction *inst,
     }
     return true;
   }
+  
+  if (perfConstr == PerformanceConstraints::NoRuntime)
+    return false;
+  
   if (impact & RuntimeEffect::Allocating) {
     PrettyStackTracePerformanceDiagnostics stackTrace(
         "found allocation effect", inst);
@@ -523,13 +551,6 @@ bool PerformanceDiagnostics::visitInst(SILInstruction *inst,
     diagnose(loc, diag::performance_deallocating, "this code pattern");
     return true;
   }
-  if (impact & RuntimeEffect::ObjectiveC) {
-    PrettyStackTracePerformanceDiagnostics stackTrace(
-        "found objc effect", inst);
-
-    diagnose(loc, diag::performance_objectivec);
-    return true;
-  }
 
   if (perfConstr == PerformanceConstraints::NoAllocation)
     return false;
diff --git a/lib/Sema/TypeCheckAttr.cpp b/lib/Sema/TypeCheckAttr.cpp
@@ -137,6 +137,9 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
   IGNORED_ATTR(Semantics)
   IGNORED_ATTR(NoLocks)
   IGNORED_ATTR(NoAllocation)
+  IGNORED_ATTR(NoRuntime)
+  IGNORED_ATTR(NoExistentials)
+  IGNORED_ATTR(NoObjCBridging)
   IGNORED_ATTR(EmitAssemblyVisionRemarks)
   IGNORED_ATTR(ShowInInterface)
   IGNORED_ATTR(SILGenName)
diff --git a/lib/Sema/TypeCheckDeclOverride.cpp b/lib/Sema/TypeCheckDeclOverride.cpp
@@ -1509,6 +1509,9 @@ namespace  {
     UNINTERESTING_ATTR(Exclusivity)
     UNINTERESTING_ATTR(NoLocks)
     UNINTERESTING_ATTR(NoAllocation)
+    UNINTERESTING_ATTR(NoRuntime)
+    UNINTERESTING_ATTR(NoExistentials)
+    UNINTERESTING_ATTR(NoObjCBridging)
     UNINTERESTING_ATTR(Inlinable)
     UNINTERESTING_ATTR(Effects)
     UNINTERESTING_ATTR(Expose)
diff --git a/test/SILOptimizer/no-objc-bridging-performance-annotation.swift b/test/SILOptimizer/no-objc-bridging-performance-annotation.swift
@@ -0,0 +1,11 @@
+// RUN: %target-swift-frontend -parse-as-library -emit-sil %s -o /dev/null -verify
+// REQUIRES: swift_stdlib_no_asserts,optimized_stdlib
+// REQUIRES: swift_in_compiler
+// REQUIRES: objc_interop, OS=macosx
+
+import Foundation
+
+@_noObjCBridging
+func useOfExistentialNoObjc() -> NSArray.Type {
+  NSArray.self // expected-error{{calls of Objective-C methods can have unpredictable performance}}
+}
diff --git a/test/SILOptimizer/performance-annotations.swift b/test/SILOptimizer/performance-annotations.swift
@@ -429,3 +429,45 @@ func testPrecondition(_ count: Int) {
   precondition(count == 2, "abc")
 }
 
+@_noRuntime
+func dynamicCastNoRuntime(_ a: AnyObject) -> Cl? {
+  return a as? Cl // expected-error {{dynamic casting can lock or allocate}}
+}
+
+func useExistential<T: P>(_: T) {}
+
+@_noRuntime
+func openExistentialNoRuntime(_ existential: P) {
+  _openExistential(existential, do: useExistential) // expected-error {{generic function calls can cause metadata allocation or locks}}
+}
+
+@_noExistentials
+func dynamicCastNoExistential(_ a: AnyObject) -> Cl? {
+  return a as? Cl
+}
+
+@_noExistentials
+func useOfExistential() -> P {
+  Str(x: 1) // expected-error {{cannot use a value of protocol type 'any P' in @_noExistential function}}
+}
+
+@_noExistentials
+func genericNoExistential() -> some P {
+  Str(x: 1)
+}
+
+@_noRuntime
+func genericNoRuntime() -> some P {
+  Str(x: 1)
+}
+
+@_noObjCBridging
+func useOfExistentialNoObjc() -> P {
+  Str(x: 1)
+}
+
+@_noRuntime
+func useOfExistentialNoRuntime() -> P {
+  Str(x: 1) // expected-error {{Using type 'any P' can cause metadata allocation or locks}}
+}
+

Original file line number	Diff line number	Diff line change
`@@ -203,13 +203,19 @@ final public class Function : CustomStringConvertible, HasShortDescription, Hash`
`203`	`203`	`case none`
`204`	`204`	`case noAllocations`
`205`	`205`	`case noLocks`
	`206`	`+ case noRuntime`
	`207`	`+ case noExistentials`
	`208`	`+ case noObjCRuntime`
`206`	`209`	`}`
`207`	`210`
`208`	`211`	`public var performanceConstraints: PerformanceConstraints {`
`209`	`212`	`switch bridged.getPerformanceConstraints() {`
`210`	`213`	`case .None: return .none`
`211`	`214`	`case .NoAllocation: return .noAllocations`
`212`	`215`	`case .NoLocks: return .noLocks`
	`216`	`+ case .NoRuntime: return .noRuntime`
	`217`	`+ case .NoExistentials: return .noExistentials`
	`218`	`+ case .NoObjCBridging: return .noObjCRuntime`
`213`	`219`	`default: fatalError("unknown performance constraint")`
`214`	`220`	`}`
`215`	`221`	`}`