Add support for inlining switches with returns inside.

Because we use `continue` for flow control handling now, we can escape
from the middle of a switch statement. This wasn't possible when we used
`break`.

This unlocks some pretty stellar optimization opportunities if the
switch value can be determined at compile time; see BlendEnum for an
example.

Change-Id: Id29be92c343c10fd604683a80c5d5bd2bd070cb0
Bug: skia:11097
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345419
Commit-Queue: John Stiles <[email protected]>
Auto-Submit: John Stiles <[email protected]>
Reviewed-by: Ethan Nicholas <[email protected]>

Author: johnstiles-google

gn/sksl_tests.gni

@@ -398,9 +398,10 @@ sksl_inliner_tests = [
   "$_tests/sksl/inliner/InlineWithUnnecessaryBlocks.sksl",
   "$_tests/sksl/inliner/InlinerAvoidsVariableNameOverlap.sksl",
   "$_tests/sksl/inliner/InlinerManglesNames.sksl",
+  "$_tests/sksl/inliner/InlinerWrapsEarlyReturnsWithForLoop.sksl",
+  "$_tests/sksl/inliner/InlinerWrapsSwitchWithReturnInsideWithForLoop.sksl",
   "$_tests/sksl/inliner/ShortCircuitEvaluationsCannotInlineRightHandSide.sksl",
   "$_tests/sksl/inliner/SwitchWithCastCanBeInlined.sksl",
-  "$_tests/sksl/inliner/SwitchWithReturnInsideCannotBeInlined.sksl",
   "$_tests/sksl/inliner/SwitchWithoutReturnInsideCanBeInlined.sksl",
   "$_tests/sksl/inliner/SwizzleCanBeInlinedDirectly.sksl",
   "$_tests/sksl/inliner/TernaryResultsCannotBeInlined.sksl",
@@ -447,7 +448,6 @@ sksl_settings_tests = [
   "$_tests/sksl/glsl/TypePrecision.sksl",
   "$_tests/sksl/inliner/ExponentialGrowth.sksl",
   "$_tests/sksl/inliner/InlinerCanBeDisabled.sksl",
-  "$_tests/sksl/inliner/InlinerWrapsEarlyReturnsWithForLoop.sksl",
   "$_tests/sksl/shared/Derivatives.sksl",
   "$_tests/sksl/shared/DerivativesFlipY.sksl",
   "$_tests/sksl/workarounds/AbsInt.sksl",

src/sksl/SkSLInliner.cpp

@@ -94,26 +94,25 @@ static int count_returns_at_end_of_control_flow(const FunctionDefinition& funcDe
     return CountReturnsAtEndOfControlFlow{funcDef}.fNumReturns;
 }
 
-static int count_returns_in_breakable_constructs(const FunctionDefinition& funcDef) {
-    class CountReturnsInBreakableConstructs : public ProgramVisitor {
+static int count_returns_in_continuable_constructs(const FunctionDefinition& funcDef) {
+    class CountReturnsInContinuableConstructs : public ProgramVisitor {
     public:
-        CountReturnsInBreakableConstructs(const FunctionDefinition& funcDef) {
+        CountReturnsInContinuableConstructs(const FunctionDefinition& funcDef) {
             this->visitProgramElement(funcDef);
         }
 
         bool visitStatement(const Statement& stmt) override {
             switch (stmt.kind()) {
-                case Statement::Kind::kSwitch:
                 case Statement::Kind::kDo:
                 case Statement::Kind::kFor: {
-                    ++fInsideBreakableConstruct;
+                    ++fInsideContinuableConstruct;
                     bool result = INHERITED::visitStatement(stmt);
-                    --fInsideBreakableConstruct;
+                    --fInsideContinuableConstruct;
                     return result;
                 }
 
                 case Statement::Kind::kReturn:
-                    fNumReturns += (fInsideBreakableConstruct > 0) ? 1 : 0;
+                    fNumReturns += (fInsideContinuableConstruct > 0) ? 1 : 0;
                     [[fallthrough]];
 
                 default:
@@ -122,11 +121,11 @@ static int count_returns_in_breakable_constructs(const FunctionDefinition& funcD
         }
 
         int fNumReturns = 0;
-        int fInsideBreakableConstruct = 0;
+        int fInsideContinuableConstruct = 0;
         using INHERITED = ProgramVisitor;
     };
 
-    return CountReturnsInBreakableConstructs{funcDef}.fNumReturns;
+    return CountReturnsInContinuableConstructs{funcDef}.fNumReturns;
 }
 
 static bool contains_recursive_call(const FunctionDeclaration& funcDecl) {
@@ -834,10 +833,11 @@ bool Inliner::isSafeToInline(const FunctionDefinition* functionDef) {
         return false;
     }
 
-    // We don't have any mechanism to simulate early returns within a breakable construct
-    // (switch/for/do/while), so we can't inline if there's a return inside one.
-    bool hasReturnInBreakableConstruct = (count_returns_in_breakable_constructs(*functionDef) > 0);
-    return !hasReturnInBreakableConstruct;
+    // We don't have any mechanism to simulate early returns within a construct that supports
+    // continues (for/do/while), so we can't inline if there's a return inside one.
+    bool hasReturnInContinuableConstruct =
+            (count_returns_in_continuable_constructs(*functionDef) > 0);
+    return !hasReturnInContinuableConstruct;
 }
 
 // A candidate function for inlining, containing everything that `inlineCall` needs.