Merge pull request swiftlang#34430 from atrick/check-nested-semantics

Add NestedSemanticFunctionCheck warning diagnostic

Author: atrick

include/swift/AST/DiagnosticsSIL.def

@@ -643,5 +643,7 @@ ERROR(box_to_stack_cannot_promote_box_to_stack_due_to_escape_alloc, none,
 NOTE(box_to_stack_cannot_promote_box_to_stack_due_to_escape_location, none,
      "value escapes here", ())
 
+WARNING(semantic_function_improper_nesting, none, "'@_semantics' function calls non-'@_semantics' function with nested '@_semantics' calls", ())
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/SILOptimizer/Analysis/ArraySemantic.h

@@ -42,6 +42,7 @@ enum class ArrayCallKind {
   // a function, and it has a self parameter, make sure that it is defined
   // before this comment.
   kArrayInit,
+  kArrayInitEmpty,
   kArrayUninitialized,
   kArrayUninitializedIntrinsic,
   kArrayFinalizeIntrinsic
@@ -187,7 +188,7 @@ class ArraySemanticsCall {
 
   /// Could this array be backed by an NSArray.
   bool mayHaveBridgedObjectElementType() const;
-  
+
   /// Can this function be inlined by the early inliner.
   bool canInlineEarly() const;
 

include/swift/SILOptimizer/PassManager/Passes.def

@@ -251,6 +251,8 @@ PASS(Outliner, "outliner",
      "Function Outlining Optimization")
 PASS(OwnershipModelEliminator, "ownership-model-eliminator",
      "Eliminate Ownership Annotation of SIL")
+PASS(NestedSemanticFunctionCheck, "nested-semantic-function-check",
+     "Diagnose improperly nested '@_semantics' functions")
 PASS(NonTransparentFunctionOwnershipModelEliminator,
      "non-transparent-func-ownership-model-eliminator",
      "Eliminate Ownership Annotations from non-transparent SIL Functions")

include/swift/SILOptimizer/Utils/PerformanceInlinerUtils.h

@@ -39,13 +39,38 @@ enum class InlineSelection {
   OnlyInlineAlways,
 };
 
-// Returns the callee of an apply_inst if it is basically inlinable.
+/// Check if this ApplySite is eligible for inlining. If so, return the callee.
 SILFunction *getEligibleFunction(FullApplySite AI,
                                  InlineSelection WhatToInline);
 
 // Returns true if this is a pure call, i.e. the callee has no side-effects
 // and all arguments are constants.
 bool isPureCall(FullApplySite AI, SideEffectAnalysis *SEA);
+
+/// Fundamental @_semantic tags provide additional semantics for optimization
+/// beyond what SIL analysis can discover from the function body. They should be
+/// preserved until semantic passes can process them. For example, they may need
+/// to be hoisted by LICM after inlining up to the highest level caller.
+///
+/// Nested @_semantic tags also provide semantics beyond the function body but
+/// they hide the semantics of underlying calls. These need to be inlined into
+/// the highest level caller before semantics passes can process the underlying
+/// Fundamental semantic functions.
+///
+/// Transient @_semantic tags are not required for optimization.
+enum class SemanticFunctionLevel { Fundamental, Transient, Nested };
+
+/// Return the SemanticFunctionLevel of \p callee.
+SemanticFunctionLevel getSemanticFunctionLevel(SILFunction *function);
+
+inline bool isOptimizableSemanticFunction(SILFunction *function) {
+  return getSemanticFunctionLevel(function) != SemanticFunctionLevel::Transient;
+}
+
+/// Return true if \p apply calls into an optimizable semantic function from
+/// within another semantic function, or from a "trivial" wrapper.
+bool isNestedSemanticCall(FullApplySite apply);
+
 } // end swift namespace
 
 //===----------------------------------------------------------------------===//

lib/SILOptimizer/Analysis/ArraySemantic.cpp

@@ -30,7 +30,8 @@ ArrayCallKind swift::getArraySemanticsKind(SILFunction *f) {
         llvm::StringSwitch<ArrayCallKind>(Attrs)
             .Case("array.props.isNativeTypeChecked",
                   ArrayCallKind::kArrayPropsIsNativeTypeChecked)
-            .StartsWith("array.init", ArrayCallKind::kArrayInit)
+            .Case("array.init", ArrayCallKind::kArrayInit)
+            .Case("array.init.empty", ArrayCallKind::kArrayInitEmpty)
             .Case("array.uninitialized", ArrayCallKind::kArrayUninitialized)
             .Case("array.uninitialized_intrinsic", ArrayCallKind::kArrayUninitializedIntrinsic)
             .Case("array.finalize_intrinsic", ArrayCallKind::kArrayFinalizeIntrinsic)
@@ -682,8 +683,10 @@ static SILValue getArrayUninitializedInitResult(ArraySemanticsCall arrayCall,
 
 SILValue swift::ArraySemanticsCall::getArrayValue() const {
   ArrayCallKind arrayCallKind = getKind();
-  if (arrayCallKind == ArrayCallKind::kArrayInit)
+  if (arrayCallKind == ArrayCallKind::kArrayInit
+      || arrayCallKind == ArrayCallKind::kArrayInitEmpty) {
     return SILValue(SemanticsCall);
+  }
   return getArrayUninitializedInitResult(*this, 0);
 }
 

lib/SILOptimizer/Analysis/EscapeAnalysis.cpp

@@ -1943,6 +1943,7 @@ void EscapeAnalysis::analyzeInstruction(SILInstruction *I,
       !isa<BeginApplyInst>(I)) {
     ArraySemanticsCall ASC(FAS.getInstruction());
     switch (ASC.getKind()) {
+      // TODO: Model ReserveCapacityForAppend, AppendContentsOf, AppendElement.
       case ArrayCallKind::kArrayPropsIsNativeTypeChecked:
       case ArrayCallKind::kCheckSubscript:
       case ArrayCallKind::kCheckIndex:
@@ -2023,36 +2024,6 @@ void EscapeAnalysis::analyzeInstruction(SILInstruction *I,
         break;
       }
 
-    if (FAS.getReferencedFunctionOrNull() &&
-        FAS.getReferencedFunctionOrNull()->hasSemanticsAttr(
-            "self_no_escaping_closure") &&
-        ((FAS.hasIndirectSILResults() && FAS.getNumArguments() == 3) ||
-         (!FAS.hasIndirectSILResults() && FAS.getNumArguments() == 2)) &&
-        FAS.hasSelfArgument()) {
-      // The programmer has guaranteed that the closure will not capture the
-      // self pointer passed to it or anything that is transitively reachable
-      // from the pointer.
-      auto Args = FAS.getArgumentsWithoutIndirectResults();
-      // The first not indirect result argument is the closure.
-      ConGraph->setEscapesGlobal(Args[0]);
-      return;
-    }
-
-    if (FAS.getReferencedFunctionOrNull() &&
-        FAS.getReferencedFunctionOrNull()->hasSemanticsAttr(
-            "pair_no_escaping_closure") &&
-        ((FAS.hasIndirectSILResults() && FAS.getNumArguments() == 4) ||
-         (!FAS.hasIndirectSILResults() && FAS.getNumArguments() == 3)) &&
-        FAS.hasSelfArgument()) {
-      // The programmer has guaranteed that the closure will not capture the
-      // self pointer passed to it or anything that is transitively reachable
-      // from the pointer.
-      auto Args = FAS.getArgumentsWithoutIndirectResults();
-      // The second not indirect result argument is the closure.
-      ConGraph->setEscapesGlobal(Args[1]);
-      return;
-    }
-
     if (RecursionDepth < MaxRecursionDepth) {
       CalleeList Callees = BCA->getCalleeList(FAS);
       if (buildConnectionGraphForCallees(FAS.getInstruction(), Callees, FInfo,

lib/SILOptimizer/IPO/GlobalPropertyOpt.cpp

@@ -269,6 +269,7 @@ void GlobalPropertyOpt::scanInstruction(swift::SILInstruction *Inst) {
     ArraySemanticsCall semCall(AI);
     switch (semCall.getKind()) {
       case ArrayCallKind::kArrayInit:
+      case ArrayCallKind::kArrayInitEmpty:
       case ArrayCallKind::kArrayUninitialized:
       case ArrayCallKind::kMutateUnknown:
       case ArrayCallKind::kMakeMutable:

lib/SILOptimizer/LoopTransforms/COWArrayOpt.cpp

@@ -295,6 +295,7 @@ static bool isNonMutatingArraySemanticCall(SILInstruction *Inst) {
   case ArrayCallKind::kReserveCapacityForAppend:
   case ArrayCallKind::kWithUnsafeMutableBufferPointer:
   case ArrayCallKind::kArrayInit:
+  case ArrayCallKind::kArrayInitEmpty:
   case ArrayCallKind::kArrayUninitialized:
   case ArrayCallKind::kArrayUninitializedIntrinsic:
   case ArrayCallKind::kArrayFinalizeIntrinsic:
@@ -658,6 +659,7 @@ bool COWArrayOpt::hasLoopOnlyDestructorSafeArrayOperations() {
         auto Kind = Sem.getKind();
         // Safe because they create new arrays.
         if (Kind == ArrayCallKind::kArrayInit ||
+            Kind == ArrayCallKind::kArrayInitEmpty ||
             Kind == ArrayCallKind::kArrayUninitialized ||
             Kind == ArrayCallKind::kArrayUninitializedIntrinsic)
           continue;

lib/SILOptimizer/LoopTransforms/LoopUnroll.cpp

@@ -194,7 +194,7 @@ static bool canAndShouldUnrollLoop(SILLoop *Loop, uint64_t TripCount) {
         auto Callee = AI.getCalleeFunction();
         if (Callee && getEligibleFunction(AI, InlineSelection::Everything)) {
           // If callee is rather big and potentialy inlinable, it may be better
-          // not to unroll, so that the body of the calle can be inlined later.
+          // not to unroll, so that the body of the callee can be inlined later.
           Cost += Callee->size() * InsnsPerBB;
         }
       }

lib/SILOptimizer/Mandatory/CMakeLists.txt

@@ -14,6 +14,7 @@ target_sources(swiftSILOptimizer PRIVATE
   Differentiation.cpp
   IRGenPrepare.cpp
   MandatoryInlining.cpp
+  NestedSemanticFunctionCheck.cpp
   PredictableMemOpt.cpp
   PMOMemoryUseCollector.cpp
   RawSILInstLowering.cpp