AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
792c2cb44e
skia2/tests/sksl/blend/BlendSaturation.asm.frag

476 lines
16 KiB
GLSL
Raw Normal View History

Enable SPIR-V disassembly output from skslc. We now have SPIR-V golden outputs for `blend` and `shared` tests. This exposes a handful of SPIR-V limitations for us to address. Change-Id: Ie5278889b8a61432403d06231b17765885bee0ac Bug: skia:10694 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337182 Commit-Queue: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2020-11-20 21:28:50 +00:00
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %main "main" %sk_FragColor %sk_Clockwise %src %dst
OpExecutionMode %main OriginUpperLeft
OpName %sk_FragColor "sk_FragColor"
OpName %sk_Clockwise "sk_Clockwise"
OpName %src "src"
OpName %dst "dst"
Avoid inlining functions that are called repeatedly. Previously, we'd gauge suitability for inlining by counting the nodes in a function; past a certain limit, the function was considered "too big." Now, we also incorporate the number of times that function is called. So if a function is called three times, and its size is 20 nodes, it would be considered to have an inlining cost of 60 (3 * 20) instead of 20. This should tamp down the aggressive nature of the inliner in cases like gaussian convolution or complicated blends, and will hopefully satisfy Pinpoint. No change visible in Nanobench (which doesn't test any of these sorts of patterns, but certainly inlines things): http://screen/AwD5hkgkEfjVx4g Change-Id: Ie5e32898245ac854adb9ddd52d87001df6a67125 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337676 Commit-Queue: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Auto-Submit: John Stiles <johnstiles@google.com>
2020-11-23 19:48:06 +00:00
OpName %_blend_set_color_saturation_helper "_blend_set_color_saturation_helper"
Enable SPIR-V disassembly output from skslc. We now have SPIR-V golden outputs for `blend` and `shared` tests. This exposes a handful of SPIR-V limitations for us to address. Change-Id: Ie5278889b8a61432403d06231b17765885bee0ac Bug: skia:10694 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337182 Commit-Queue: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2020-11-20 21:28:50 +00:00
OpName %main "main"
OpName %_1_alpha "_1_alpha"
OpName %_2_sda "_2_sda"
OpName %_3_dsa "_3_dsa"
OpName %_4_blend_set_color_saturation "_4_blend_set_color_saturation"
Eliminate inliner temporary variables for top-level-exit functions. When we determine that a function only contains a single return statement and it is at the top level (i.e. not inside any scopes), there is no need to create a temporary variable and store the result expression into a variable. Instead, we can directly replace the function-call expression with the return-statement's expression. Unlike my previous solution, this does not require variable declarations to be rewritten. The no-scopes limitation makes it slightly less effective in theory, but in practice we still get almost all of the benefit. The no-scope limitation bites us on structures like @if (true) { return x; } else { return y; } Which will optimize away the if, but leave the scope: { return x; } However, this is not a big deal; the biggest wins are single-line helper functions like `guarded_divide` and `unpremul` which retain the full benefit. Change-Id: I7fbb725e65db021b9795c04c816819669815578f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345167 Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
2020-12-17 19:38:56 +00:00
OpName %_5_sat "_5_sat"
OpName %_7_lum "_7_lum"
OpName %_8_result "_8_result"
OpName %_9_minComp "_9_minComp"
OpName %_10_maxComp "_10_maxComp"
Enable SPIR-V disassembly output from skslc. We now have SPIR-V golden outputs for `blend` and `shared` tests. This exposes a handful of SPIR-V limitations for us to address. Change-Id: Ie5278889b8a61432403d06231b17765885bee0ac Bug: skia:10694 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337182 Commit-Queue: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2020-11-20 21:28:50 +00:00
OpDecorate %sk_FragColor RelaxedPrecision
OpDecorate %sk_FragColor Location 0
OpDecorate %sk_FragColor Index 0
OpDecorate %sk_Clockwise RelaxedPrecision
OpDecorate %sk_Clockwise BuiltIn FrontFacing
OpDecorate %src RelaxedPrecision
OpDecorate %dst RelaxedPrecision
Avoid inlining functions that are called repeatedly. Previously, we'd gauge suitability for inlining by counting the nodes in a function; past a certain limit, the function was considered "too big." Now, we also incorporate the number of times that function is called. So if a function is called three times, and its size is 20 nodes, it would be considered to have an inlining cost of 60 (3 * 20) instead of 20. This should tamp down the aggressive nature of the inliner in cases like gaussian convolution or complicated blends, and will hopefully satisfy Pinpoint. No change visible in Nanobench (which doesn't test any of these sorts of patterns, but certainly inlines things): http://screen/AwD5hkgkEfjVx4g Change-Id: Ie5e32898245ac854adb9ddd52d87001df6a67125 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337676 Commit-Queue: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Auto-Submit: John Stiles <johnstiles@google.com>
2020-11-23 19:48:06 +00:00
OpDecorate %21 RelaxedPrecision
OpDecorate %23 RelaxedPrecision
OpDecorate %31 RelaxedPrecision
OpDecorate %32 RelaxedPrecision
Enable SPIR-V disassembly output from skslc. We now have SPIR-V golden outputs for `blend` and `shared` tests. This exposes a handful of SPIR-V limitations for us to address. Change-Id: Ie5278889b8a61432403d06231b17765885bee0ac Bug: skia:10694 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337182 Commit-Queue: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2020-11-20 21:28:50 +00:00
OpDecorate %34 RelaxedPrecision
OpDecorate %36 RelaxedPrecision
Avoid inlining functions that are called repeatedly. Previously, we'd gauge suitability for inlining by counting the nodes in a function; past a certain limit, the function was considered "too big." Now, we also incorporate the number of times that function is called. So if a function is called three times, and its size is 20 nodes, it would be considered to have an inlining cost of 60 (3 * 20) instead of 20. This should tamp down the aggressive nature of the inliner in cases like gaussian convolution or complicated blends, and will hopefully satisfy Pinpoint. No change visible in Nanobench (which doesn't test any of these sorts of patterns, but certainly inlines things): http://screen/AwD5hkgkEfjVx4g Change-Id: Ie5e32898245ac854adb9ddd52d87001df6a67125 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337676 Commit-Queue: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Auto-Submit: John Stiles <johnstiles@google.com>
2020-11-23 19:48:06 +00:00
OpDecorate %37 RelaxedPrecision
OpDecorate %38 RelaxedPrecision
OpDecorate %40 RelaxedPrecision
OpDecorate %42 RelaxedPrecision
OpDecorate %43 RelaxedPrecision
OpDecorate %44 RelaxedPrecision
Enable SPIR-V disassembly output from skslc. We now have SPIR-V golden outputs for `blend` and `shared` tests. This exposes a handful of SPIR-V limitations for us to address. Change-Id: Ie5278889b8a61432403d06231b17765885bee0ac Bug: skia:10694 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337182 Commit-Queue: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2020-11-20 21:28:50 +00:00
OpDecorate %47 RelaxedPrecision
Eliminate inliner temporary variables for top-level-exit functions. When we determine that a function only contains a single return statement and it is at the top level (i.e. not inside any scopes), there is no need to create a temporary variable and store the result expression into a variable. Instead, we can directly replace the function-call expression with the return-statement's expression. Unlike my previous solution, this does not require variable declarations to be rewritten. The no-scopes limitation makes it slightly less effective in theory, but in practice we still get almost all of the benefit. The no-scope limitation bites us on structures like @if (true) { return x; } else { return y; } Which will optimize away the if, but leave the scope: { return x; } However, this is not a big deal; the biggest wins are single-line helper functions like `guarded_divide` and `unpremul` which retain the full benefit. Change-Id: I7fbb725e65db021b9795c04c816819669815578f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345167 Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
2020-12-17 19:38:56 +00:00
OpDecorate %52 RelaxedPrecision
Revert "Declare all inlined variables at the topmost scope possible." This reverts commit e8e4aca955bc87732ada3dd42ec60f6b1a37443e. Reason for revert: can break ES2 for-loop rules Original change's description: > Declare all inlined variables at the topmost scope possible. > > By itself, this is uninteresting and even perhaps slightly > counterproductive (as it separates vardecl from its initializer, > increasing LOC). However, this enables a followup CL > (http://review.skia.org/344665) which allows single-return functions to > be inlined without the creation of a temporary variable at all. This > applies to the majority of fragment processors in a typical Ganesh > hierarchy. This change will greatly reduce the number of inliner-created > temporary copies when compiling a typical tree of FPs. > > Change-Id: I03423a13cf35050637dabace4a32973a08a4ed0a > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/344764 > Reviewed-by: Brian Osman <brianosman@google.com> > Commit-Queue: John Stiles <johnstiles@google.com> TBR=brianosman@google.com,ethannicholas@google.com,johnstiles@google.com Change-Id: Ica01d6906bcb9cef1f49d22dda714fc9cbfa3885 No-Presubmit: true No-Tree-Checks: true No-Try: true Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345121 Reviewed-by: John Stiles <johnstiles@google.com> Commit-Queue: John Stiles <johnstiles@google.com>
2020-12-16 18:25:14 +00:00
OpDecorate %54 RelaxedPrecision
Avoid inlining functions that are called repeatedly. Previously, we'd gauge suitability for inlining by counting the nodes in a function; past a certain limit, the function was considered "too big." Now, we also incorporate the number of times that function is called. So if a function is called three times, and its size is 20 nodes, it would be considered to have an inlining cost of 60 (3 * 20) instead of 20. This should tamp down the aggressive nature of the inliner in cases like gaussian convolution or complicated blends, and will hopefully satisfy Pinpoint. No change visible in Nanobench (which doesn't test any of these sorts of patterns, but certainly inlines things): http://screen/AwD5hkgkEfjVx4g Change-Id: Ie5e32898245ac854adb9ddd52d87001df6a67125 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337676 Commit-Queue: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Auto-Submit: John Stiles <johnstiles@google.com>
2020-11-23 19:48:06 +00:00
OpDecorate %56 RelaxedPrecision
OpDecorate %58 RelaxedPrecision
Revert "Eliminate inliner temporary variables for functions with a single exit." This reverts commit 345d72124d35b7c434be7bd9b6b16a66fbd980e6. Reason for revert: can break ES2 for-loop rules Original change's description: > Eliminate inliner temporary variables for functions with a single exit. > > When we determine that a function only contains a single return > statement, there is no need to create a temporary variable and store the > result expression into a variable. Instead, we can directly replace the > function-call expression with the return-statement's expression. > > This dramatically simplifies the final optimized output from chains of > very simple inlined functions, which is a very common pattern for trees > of Skia fragment processors. > > Change-Id: I6789064a321daf43db2e1cef4915f25ed74d6131 > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/344665 > Commit-Queue: John Stiles <johnstiles@google.com> > Reviewed-by: Brian Osman <brianosman@google.com> > Auto-Submit: John Stiles <johnstiles@google.com> TBR=brianosman@google.com,ethannicholas@google.com,johnstiles@google.com Change-Id: I60845f22159605a06047b030e2686a769121a35a No-Presubmit: true No-Tree-Checks: true No-Try: true Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345120 Reviewed-by: John Stiles <johnstiles@google.com> Commit-Queue: John Stiles <johnstiles@google.com>
2020-12-16 18:24:48 +00:00
OpDecorate %60 RelaxedPrecision
Eliminate inliner temporary variables for top-level-exit functions. When we determine that a function only contains a single return statement and it is at the top level (i.e. not inside any scopes), there is no need to create a temporary variable and store the result expression into a variable. Instead, we can directly replace the function-call expression with the return-statement's expression. Unlike my previous solution, this does not require variable declarations to be rewritten. The no-scopes limitation makes it slightly less effective in theory, but in practice we still get almost all of the benefit. The no-scope limitation bites us on structures like @if (true) { return x; } else { return y; } Which will optimize away the if, but leave the scope: { return x; } However, this is not a big deal; the biggest wins are single-line helper functions like `guarded_divide` and `unpremul` which retain the full benefit. Change-Id: I7fbb725e65db021b9795c04c816819669815578f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345167 Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
2020-12-17 19:38:56 +00:00
OpDecorate %64 RelaxedPrecision
Avoid inlining functions that are called repeatedly. Previously, we'd gauge suitability for inlining by counting the nodes in a function; past a certain limit, the function was considered "too big." Now, we also incorporate the number of times that function is called. So if a function is called three times, and its size is 20 nodes, it would be considered to have an inlining cost of 60 (3 * 20) instead of 20. This should tamp down the aggressive nature of the inliner in cases like gaussian convolution or complicated blends, and will hopefully satisfy Pinpoint. No change visible in Nanobench (which doesn't test any of these sorts of patterns, but certainly inlines things): http://screen/AwD5hkgkEfjVx4g Change-Id: Ie5e32898245ac854adb9ddd52d87001df6a67125 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337676 Commit-Queue: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Auto-Submit: John Stiles <johnstiles@google.com>
2020-11-23 19:48:06 +00:00
OpDecorate %66 RelaxedPrecision
Eliminate inliner temporary variables for top-level-exit functions. When we determine that a function only contains a single return statement and it is at the top level (i.e. not inside any scopes), there is no need to create a temporary variable and store the result expression into a variable. Instead, we can directly replace the function-call expression with the return-statement's expression. Unlike my previous solution, this does not require variable declarations to be rewritten. The no-scopes limitation makes it slightly less effective in theory, but in practice we still get almost all of the benefit. The no-scope limitation bites us on structures like @if (true) { return x; } else { return y; } Which will optimize away the if, but leave the scope: { return x; } However, this is not a big deal; the biggest wins are single-line helper functions like `guarded_divide` and `unpremul` which retain the full benefit. Change-Id: I7fbb725e65db021b9795c04c816819669815578f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345167 Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
2020-12-17 19:38:56 +00:00
OpDecorate %73 RelaxedPrecision
Revert "Declare all inlined variables at the topmost scope possible." This reverts commit e8e4aca955bc87732ada3dd42ec60f6b1a37443e. Reason for revert: can break ES2 for-loop rules Original change's description: > Declare all inlined variables at the topmost scope possible. > > By itself, this is uninteresting and even perhaps slightly > counterproductive (as it separates vardecl from its initializer, > increasing LOC). However, this enables a followup CL > (http://review.skia.org/344665) which allows single-return functions to > be inlined without the creation of a temporary variable at all. This > applies to the majority of fragment processors in a typical Ganesh > hierarchy. This change will greatly reduce the number of inliner-created > temporary copies when compiling a typical tree of FPs. > > Change-Id: I03423a13cf35050637dabace4a32973a08a4ed0a > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/344764 > Reviewed-by: Brian Osman <brianosman@google.com> > Commit-Queue: John Stiles <johnstiles@google.com> TBR=brianosman@google.com,ethannicholas@google.com,johnstiles@google.com Change-Id: Ica01d6906bcb9cef1f49d22dda714fc9cbfa3885 No-Presubmit: true No-Tree-Checks: true No-Try: true Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345121 Reviewed-by: John Stiles <johnstiles@google.com> Commit-Queue: John Stiles <johnstiles@google.com>
2020-12-16 18:25:14 +00:00
OpDecorate %75 RelaxedPrecision
OpDecorate %77 RelaxedPrecision
Eliminate inliner temporary variables for top-level-exit functions. When we determine that a function only contains a single return statement and it is at the top level (i.e. not inside any scopes), there is no need to create a temporary variable and store the result expression into a variable. Instead, we can directly replace the function-call expression with the return-statement's expression. Unlike my previous solution, this does not require variable declarations to be rewritten. The no-scopes limitation makes it slightly less effective in theory, but in practice we still get almost all of the benefit. The no-scope limitation bites us on structures like @if (true) { return x; } else { return y; } Which will optimize away the if, but leave the scope: { return x; } However, this is not a big deal; the biggest wins are single-line helper functions like `guarded_divide` and `unpremul` which retain the full benefit. Change-Id: I7fbb725e65db021b9795c04c816819669815578f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345167 Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
2020-12-17 19:38:56 +00:00
OpDecorate %81 RelaxedPrecision
Revert "Declare all inlined variables at the topmost scope possible." This reverts commit e8e4aca955bc87732ada3dd42ec60f6b1a37443e. Reason for revert: can break ES2 for-loop rules Original change's description: > Declare all inlined variables at the topmost scope possible. > > By itself, this is uninteresting and even perhaps slightly > counterproductive (as it separates vardecl from its initializer, > increasing LOC). However, this enables a followup CL > (http://review.skia.org/344665) which allows single-return functions to > be inlined without the creation of a temporary variable at all. This > applies to the majority of fragment processors in a typical Ganesh > hierarchy. This change will greatly reduce the number of inliner-created > temporary copies when compiling a typical tree of FPs. > > Change-Id: I03423a13cf35050637dabace4a32973a08a4ed0a > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/344764 > Reviewed-by: Brian Osman <brianosman@google.com> > Commit-Queue: John Stiles <johnstiles@google.com> TBR=brianosman@google.com,ethannicholas@google.com,johnstiles@google.com Change-Id: Ica01d6906bcb9cef1f49d22dda714fc9cbfa3885 No-Presubmit: true No-Tree-Checks: true No-Try: true Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345121 Reviewed-by: John Stiles <johnstiles@google.com> Commit-Queue: John Stiles <johnstiles@google.com>
2020-12-16 18:25:14 +00:00
OpDecorate %83 RelaxedPrecision
OpDecorate %85 RelaxedPrecision
OpDecorate %87 RelaxedPrecision
Eliminate inliner temporary variables for top-level-exit functions. When we determine that a function only contains a single return statement and it is at the top level (i.e. not inside any scopes), there is no need to create a temporary variable and store the result expression into a variable. Instead, we can directly replace the function-call expression with the return-statement's expression. Unlike my previous solution, this does not require variable declarations to be rewritten. The no-scopes limitation makes it slightly less effective in theory, but in practice we still get almost all of the benefit. The no-scope limitation bites us on structures like @if (true) { return x; } else { return y; } Which will optimize away the if, but leave the scope: { return x; } However, this is not a big deal; the biggest wins are single-line helper functions like `guarded_divide` and `unpremul` which retain the full benefit. Change-Id: I7fbb725e65db021b9795c04c816819669815578f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345167 Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
2020-12-17 19:38:56 +00:00
OpDecorate %88 RelaxedPrecision
OpDecorate %90 RelaxedPrecision
OpDecorate %96 RelaxedPrecision
OpDecorate %98 RelaxedPrecision
OpDecorate %104 RelaxedPrecision
OpDecorate %106 RelaxedPrecision
OpDecorate %109 RelaxedPrecision
OpDecorate %111 RelaxedPrecision
OpDecorate %117 RelaxedPrecision
OpDecorate %120 RelaxedPrecision
Reland "Simplify _blend_set_color_saturation, removing an instruction." This reverts commit e81fb87bb444c7f1dd087479b0a868f365a465ae. Reason for revert: checking results with less-aggressive inliner Original change's description: > Revert "Simplify _blend_set_color_saturation, removing an instruction." > > This reverts commit ed289e777cfa41c059b94e64e0c749fe47db563b. > > Reason for revert: causing strange artifacts, only on Adreno > > Original change's description: > > Simplify _blend_set_color_saturation, removing an instruction. > > > > This tightens up our intrinsics slightly; after inlining, it eliminates > > one scratch variable. (We no longer need to copy `sda` into `hueColor` > > as hueColor is now unchanged.) > > > > Change-Id: Iece5ba2fe11cde54481704a1787114a2c2a66d9b > > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/336599 > > Commit-Queue: John Stiles <johnstiles@google.com> > > Commit-Queue: Brian Osman <brianosman@google.com> > > Auto-Submit: John Stiles <johnstiles@google.com> > > Reviewed-by: Brian Osman <brianosman@google.com> > > TBR=brianosman@google.com,johnstiles@google.com > > Change-Id: Ica506467b0a4e03d0cbe482034acfa2d9f8d2c16 > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337560 > Reviewed-by: John Stiles <johnstiles@google.com> TBR=brianosman@google.com,johnstiles@google.com Change-Id: Ia93263f3269c057e7eaa69ca2b05e783d18c0199 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337944 Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: John Stiles <johnstiles@google.com>
2020-11-24 03:19:04 +00:00
OpDecorate %124 RelaxedPrecision
Eliminate inliner temporary variables for top-level-exit functions. When we determine that a function only contains a single return statement and it is at the top level (i.e. not inside any scopes), there is no need to create a temporary variable and store the result expression into a variable. Instead, we can directly replace the function-call expression with the return-statement's expression. Unlike my previous solution, this does not require variable declarations to be rewritten. The no-scopes limitation makes it slightly less effective in theory, but in practice we still get almost all of the benefit. The no-scope limitation bites us on structures like @if (true) { return x; } else { return y; } Which will optimize away the if, but leave the scope: { return x; } However, this is not a big deal; the biggest wins are single-line helper functions like `guarded_divide` and `unpremul` which retain the full benefit. Change-Id: I7fbb725e65db021b9795c04c816819669815578f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345167 Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
2020-12-17 19:38:56 +00:00
OpDecorate %127 RelaxedPrecision
Reland "Simplify _blend_set_color_saturation, removing an instruction." This reverts commit e81fb87bb444c7f1dd087479b0a868f365a465ae. Reason for revert: checking results with less-aggressive inliner Original change's description: > Revert "Simplify _blend_set_color_saturation, removing an instruction." > > This reverts commit ed289e777cfa41c059b94e64e0c749fe47db563b. > > Reason for revert: causing strange artifacts, only on Adreno > > Original change's description: > > Simplify _blend_set_color_saturation, removing an instruction. > > > > This tightens up our intrinsics slightly; after inlining, it eliminates > > one scratch variable. (We no longer need to copy `sda` into `hueColor` > > as hueColor is now unchanged.) > > > > Change-Id: Iece5ba2fe11cde54481704a1787114a2c2a66d9b > > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/336599 > > Commit-Queue: John Stiles <johnstiles@google.com> > > Commit-Queue: Brian Osman <brianosman@google.com> > > Auto-Submit: John Stiles <johnstiles@google.com> > > Reviewed-by: Brian Osman <brianosman@google.com> > > TBR=brianosman@google.com,johnstiles@google.com > > Change-Id: Ica506467b0a4e03d0cbe482034acfa2d9f8d2c16 > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337560 > Reviewed-by: John Stiles <johnstiles@google.com> TBR=brianosman@google.com,johnstiles@google.com Change-Id: Ia93263f3269c057e7eaa69ca2b05e783d18c0199 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337944 Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: John Stiles <johnstiles@google.com>
2020-11-24 03:19:04 +00:00
OpDecorate %131 RelaxedPrecision
Eliminate inliner temporary variables for top-level-exit functions. When we determine that a function only contains a single return statement and it is at the top level (i.e. not inside any scopes), there is no need to create a temporary variable and store the result expression into a variable. Instead, we can directly replace the function-call expression with the return-statement's expression. Unlike my previous solution, this does not require variable declarations to be rewritten. The no-scopes limitation makes it slightly less effective in theory, but in practice we still get almost all of the benefit. The no-scope limitation bites us on structures like @if (true) { return x; } else { return y; } Which will optimize away the if, but leave the scope: { return x; } However, this is not a big deal; the biggest wins are single-line helper functions like `guarded_divide` and `unpremul` which retain the full benefit. Change-Id: I7fbb725e65db021b9795c04c816819669815578f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345167 Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
2020-12-17 19:38:56 +00:00
OpDecorate %133 RelaxedPrecision
OpDecorate %139 RelaxedPrecision
OpDecorate %142 RelaxedPrecision
Reland "Simplify _blend_set_color_saturation, removing an instruction." This reverts commit e81fb87bb444c7f1dd087479b0a868f365a465ae. Reason for revert: checking results with less-aggressive inliner Original change's description: > Revert "Simplify _blend_set_color_saturation, removing an instruction." > > This reverts commit ed289e777cfa41c059b94e64e0c749fe47db563b. > > Reason for revert: causing strange artifacts, only on Adreno > > Original change's description: > > Simplify _blend_set_color_saturation, removing an instruction. > > > > This tightens up our intrinsics slightly; after inlining, it eliminates > > one scratch variable. (We no longer need to copy `sda` into `hueColor` > > as hueColor is now unchanged.) > > > > Change-Id: Iece5ba2fe11cde54481704a1787114a2c2a66d9b > > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/336599 > > Commit-Queue: John Stiles <johnstiles@google.com> > > Commit-Queue: Brian Osman <brianosman@google.com> > > Auto-Submit: John Stiles <johnstiles@google.com> > > Reviewed-by: Brian Osman <brianosman@google.com> > > TBR=brianosman@google.com,johnstiles@google.com > > Change-Id: Ica506467b0a4e03d0cbe482034acfa2d9f8d2c16 > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337560 > Reviewed-by: John Stiles <johnstiles@google.com> TBR=brianosman@google.com,johnstiles@google.com Change-Id: Ia93263f3269c057e7eaa69ca2b05e783d18c0199 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337944 Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: John Stiles <johnstiles@google.com>
2020-11-24 03:19:04 +00:00
OpDecorate %146 RelaxedPrecision
Eliminate inliner temporary variables for top-level-exit functions. When we determine that a function only contains a single return statement and it is at the top level (i.e. not inside any scopes), there is no need to create a temporary variable and store the result expression into a variable. Instead, we can directly replace the function-call expression with the return-statement's expression. Unlike my previous solution, this does not require variable declarations to be rewritten. The no-scopes limitation makes it slightly less effective in theory, but in practice we still get almost all of the benefit. The no-scope limitation bites us on structures like @if (true) { return x; } else { return y; } Which will optimize away the if, but leave the scope: { return x; } However, this is not a big deal; the biggest wins are single-line helper functions like `guarded_divide` and `unpremul` which retain the full benefit. Change-Id: I7fbb725e65db021b9795c04c816819669815578f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345167 Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
2020-12-17 19:38:56 +00:00
OpDecorate %148 RelaxedPrecision
OpDecorate %154 RelaxedPrecision
OpDecorate %157 RelaxedPrecision
Reland "Simplify _blend_set_color_saturation, removing an instruction." This reverts commit e81fb87bb444c7f1dd087479b0a868f365a465ae. Reason for revert: checking results with less-aggressive inliner Original change's description: > Revert "Simplify _blend_set_color_saturation, removing an instruction." > > This reverts commit ed289e777cfa41c059b94e64e0c749fe47db563b. > > Reason for revert: causing strange artifacts, only on Adreno > > Original change's description: > > Simplify _blend_set_color_saturation, removing an instruction. > > > > This tightens up our intrinsics slightly; after inlining, it eliminates > > one scratch variable. (We no longer need to copy `sda` into `hueColor` > > as hueColor is now unchanged.) > > > > Change-Id: Iece5ba2fe11cde54481704a1787114a2c2a66d9b > > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/336599 > > Commit-Queue: John Stiles <johnstiles@google.com> > > Commit-Queue: Brian Osman <brianosman@google.com> > > Auto-Submit: John Stiles <johnstiles@google.com> > > Reviewed-by: Brian Osman <brianosman@google.com> > > TBR=brianosman@google.com,johnstiles@google.com > > Change-Id: Ica506467b0a4e03d0cbe482034acfa2d9f8d2c16 > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337560 > Reviewed-by: John Stiles <johnstiles@google.com> TBR=brianosman@google.com,johnstiles@google.com Change-Id: Ia93263f3269c057e7eaa69ca2b05e783d18c0199 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337944 Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: John Stiles <johnstiles@google.com>
2020-11-24 03:19:04 +00:00
OpDecorate %161 RelaxedPrecision
Eliminate inliner temporary variables for top-level-exit functions. When we determine that a function only contains a single return statement and it is at the top level (i.e. not inside any scopes), there is no need to create a temporary variable and store the result expression into a variable. Instead, we can directly replace the function-call expression with the return-statement's expression. Unlike my previous solution, this does not require variable declarations to be rewritten. The no-scopes limitation makes it slightly less effective in theory, but in practice we still get almost all of the benefit. The no-scope limitation bites us on structures like @if (true) { return x; } else { return y; } Which will optimize away the if, but leave the scope: { return x; } However, this is not a big deal; the biggest wins are single-line helper functions like `guarded_divide` and `unpremul` which retain the full benefit. Change-Id: I7fbb725e65db021b9795c04c816819669815578f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345167 Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
2020-12-17 19:38:56 +00:00
OpDecorate %164 RelaxedPrecision
OpDecorate %174 RelaxedPrecision
OpDecorate %176 RelaxedPrecision
Deduplicate vector constants in SPIR-V output. Many of our shaders generate the same vector constant dozens of times, e.g. Gaussian blur uses float4(1) repeatedly. This change avoids re-emitting redundant vector constants. Change-Id: I22a71cd8b2783fb997f52d485b49031f64ca6d96 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/350701 Auto-Submit: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2021-01-06 18:33:31 +00:00
OpDecorate %178 RelaxedPrecision
Revert "Declare all inlined variables at the topmost scope possible." This reverts commit e8e4aca955bc87732ada3dd42ec60f6b1a37443e. Reason for revert: can break ES2 for-loop rules Original change's description: > Declare all inlined variables at the topmost scope possible. > > By itself, this is uninteresting and even perhaps slightly > counterproductive (as it separates vardecl from its initializer, > increasing LOC). However, this enables a followup CL > (http://review.skia.org/344665) which allows single-return functions to > be inlined without the creation of a temporary variable at all. This > applies to the majority of fragment processors in a typical Ganesh > hierarchy. This change will greatly reduce the number of inliner-created > temporary copies when compiling a typical tree of FPs. > > Change-Id: I03423a13cf35050637dabace4a32973a08a4ed0a > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/344764 > Reviewed-by: Brian Osman <brianosman@google.com> > Commit-Queue: John Stiles <johnstiles@google.com> TBR=brianosman@google.com,ethannicholas@google.com,johnstiles@google.com Change-Id: Ica01d6906bcb9cef1f49d22dda714fc9cbfa3885 No-Presubmit: true No-Tree-Checks: true No-Try: true Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345121 Reviewed-by: John Stiles <johnstiles@google.com> Commit-Queue: John Stiles <johnstiles@google.com>
2020-12-16 18:25:14 +00:00
OpDecorate %179 RelaxedPrecision
Eliminate inliner temporary variables for top-level-exit functions. When we determine that a function only contains a single return statement and it is at the top level (i.e. not inside any scopes), there is no need to create a temporary variable and store the result expression into a variable. Instead, we can directly replace the function-call expression with the return-statement's expression. Unlike my previous solution, this does not require variable declarations to be rewritten. The no-scopes limitation makes it slightly less effective in theory, but in practice we still get almost all of the benefit. The no-scope limitation bites us on structures like @if (true) { return x; } else { return y; } Which will optimize away the if, but leave the scope: { return x; } However, this is not a big deal; the biggest wins are single-line helper functions like `guarded_divide` and `unpremul` which retain the full benefit. Change-Id: I7fbb725e65db021b9795c04c816819669815578f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345167 Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
2020-12-17 19:38:56 +00:00
OpDecorate %180 RelaxedPrecision
Deduplicate vector constants in SPIR-V output. Many of our shaders generate the same vector constant dozens of times, e.g. Gaussian blur uses float4(1) repeatedly. This change avoids re-emitting redundant vector constants. Change-Id: I22a71cd8b2783fb997f52d485b49031f64ca6d96 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/350701 Auto-Submit: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2021-01-06 18:33:31 +00:00
OpDecorate %186 RelaxedPrecision
OpDecorate %188 RelaxedPrecision
OpDecorate %190 RelaxedPrecision
OpDecorate %195 RelaxedPrecision
OpDecorate %197 RelaxedPrecision
OpDecorate %199 RelaxedPrecision
OpDecorate %202 RelaxedPrecision
OpDecorate %206 RelaxedPrecision
Reland "Simplify _blend_set_color_saturation, removing an instruction." This reverts commit e81fb87bb444c7f1dd087479b0a868f365a465ae. Reason for revert: checking results with less-aggressive inliner Original change's description: > Revert "Simplify _blend_set_color_saturation, removing an instruction." > > This reverts commit ed289e777cfa41c059b94e64e0c749fe47db563b. > > Reason for revert: causing strange artifacts, only on Adreno > > Original change's description: > > Simplify _blend_set_color_saturation, removing an instruction. > > > > This tightens up our intrinsics slightly; after inlining, it eliminates > > one scratch variable. (We no longer need to copy `sda` into `hueColor` > > as hueColor is now unchanged.) > > > > Change-Id: Iece5ba2fe11cde54481704a1787114a2c2a66d9b > > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/336599 > > Commit-Queue: John Stiles <johnstiles@google.com> > > Commit-Queue: Brian Osman <brianosman@google.com> > > Auto-Submit: John Stiles <johnstiles@google.com> > > Reviewed-by: Brian Osman <brianosman@google.com> > > TBR=brianosman@google.com,johnstiles@google.com > > Change-Id: Ica506467b0a4e03d0cbe482034acfa2d9f8d2c16 > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337560 > Reviewed-by: John Stiles <johnstiles@google.com> TBR=brianosman@google.com,johnstiles@google.com Change-Id: Ia93263f3269c057e7eaa69ca2b05e783d18c0199 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337944 Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: John Stiles <johnstiles@google.com>
2020-11-24 03:19:04 +00:00
OpDecorate %207 RelaxedPrecision
Deduplicate vector constants in SPIR-V output. Many of our shaders generate the same vector constant dozens of times, e.g. Gaussian blur uses float4(1) repeatedly. This change avoids re-emitting redundant vector constants. Change-Id: I22a71cd8b2783fb997f52d485b49031f64ca6d96 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/350701 Auto-Submit: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2021-01-06 18:33:31 +00:00
OpDecorate %212 RelaxedPrecision
Eliminate inliner temporary variables for top-level-exit functions. When we determine that a function only contains a single return statement and it is at the top level (i.e. not inside any scopes), there is no need to create a temporary variable and store the result expression into a variable. Instead, we can directly replace the function-call expression with the return-statement's expression. Unlike my previous solution, this does not require variable declarations to be rewritten. The no-scopes limitation makes it slightly less effective in theory, but in practice we still get almost all of the benefit. The no-scope limitation bites us on structures like @if (true) { return x; } else { return y; } Which will optimize away the if, but leave the scope: { return x; } However, this is not a big deal; the biggest wins are single-line helper functions like `guarded_divide` and `unpremul` which retain the full benefit. Change-Id: I7fbb725e65db021b9795c04c816819669815578f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345167 Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
2020-12-17 19:38:56 +00:00
OpDecorate %213 RelaxedPrecision
OpDecorate %214 RelaxedPrecision
Deduplicate vector constants in SPIR-V output. Many of our shaders generate the same vector constant dozens of times, e.g. Gaussian blur uses float4(1) repeatedly. This change avoids re-emitting redundant vector constants. Change-Id: I22a71cd8b2783fb997f52d485b49031f64ca6d96 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/350701 Auto-Submit: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2021-01-06 18:33:31 +00:00
OpDecorate %217 RelaxedPrecision
OpDecorate %219 RelaxedPrecision
Eliminate inliner temporary variables for top-level-exit functions. When we determine that a function only contains a single return statement and it is at the top level (i.e. not inside any scopes), there is no need to create a temporary variable and store the result expression into a variable. Instead, we can directly replace the function-call expression with the return-statement's expression. Unlike my previous solution, this does not require variable declarations to be rewritten. The no-scopes limitation makes it slightly less effective in theory, but in practice we still get almost all of the benefit. The no-scope limitation bites us on structures like @if (true) { return x; } else { return y; } Which will optimize away the if, but leave the scope: { return x; } However, this is not a big deal; the biggest wins are single-line helper functions like `guarded_divide` and `unpremul` which retain the full benefit. Change-Id: I7fbb725e65db021b9795c04c816819669815578f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345167 Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
2020-12-17 19:38:56 +00:00
OpDecorate %220 RelaxedPrecision
OpDecorate %221 RelaxedPrecision
Deduplicate vector constants in SPIR-V output. Many of our shaders generate the same vector constant dozens of times, e.g. Gaussian blur uses float4(1) repeatedly. This change avoids re-emitting redundant vector constants. Change-Id: I22a71cd8b2783fb997f52d485b49031f64ca6d96 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/350701 Auto-Submit: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2021-01-06 18:33:31 +00:00
OpDecorate %227 RelaxedPrecision
Eliminate inliner temporary variables for top-level-exit functions. When we determine that a function only contains a single return statement and it is at the top level (i.e. not inside any scopes), there is no need to create a temporary variable and store the result expression into a variable. Instead, we can directly replace the function-call expression with the return-statement's expression. Unlike my previous solution, this does not require variable declarations to be rewritten. The no-scopes limitation makes it slightly less effective in theory, but in practice we still get almost all of the benefit. The no-scope limitation bites us on structures like @if (true) { return x; } else { return y; } Which will optimize away the if, but leave the scope: { return x; } However, this is not a big deal; the biggest wins are single-line helper functions like `guarded_divide` and `unpremul` which retain the full benefit. Change-Id: I7fbb725e65db021b9795c04c816819669815578f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345167 Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
2020-12-17 19:38:56 +00:00
OpDecorate %228 RelaxedPrecision
Deduplicate vector constants in SPIR-V output. Many of our shaders generate the same vector constant dozens of times, e.g. Gaussian blur uses float4(1) repeatedly. This change avoids re-emitting redundant vector constants. Change-Id: I22a71cd8b2783fb997f52d485b49031f64ca6d96 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/350701 Auto-Submit: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2021-01-06 18:33:31 +00:00
OpDecorate %232 RelaxedPrecision
Eliminate inliner temporary variables for top-level-exit functions. When we determine that a function only contains a single return statement and it is at the top level (i.e. not inside any scopes), there is no need to create a temporary variable and store the result expression into a variable. Instead, we can directly replace the function-call expression with the return-statement's expression. Unlike my previous solution, this does not require variable declarations to be rewritten. The no-scopes limitation makes it slightly less effective in theory, but in practice we still get almost all of the benefit. The no-scope limitation bites us on structures like @if (true) { return x; } else { return y; } Which will optimize away the if, but leave the scope: { return x; } However, this is not a big deal; the biggest wins are single-line helper functions like `guarded_divide` and `unpremul` which retain the full benefit. Change-Id: I7fbb725e65db021b9795c04c816819669815578f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345167 Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
2020-12-17 19:38:56 +00:00
OpDecorate %233 RelaxedPrecision
Deduplicate vector constants in SPIR-V output. Many of our shaders generate the same vector constant dozens of times, e.g. Gaussian blur uses float4(1) repeatedly. This change avoids re-emitting redundant vector constants. Change-Id: I22a71cd8b2783fb997f52d485b49031f64ca6d96 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/350701 Auto-Submit: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2021-01-06 18:33:31 +00:00
OpDecorate %240 RelaxedPrecision
Eliminate inliner temporary variables for top-level-exit functions. When we determine that a function only contains a single return statement and it is at the top level (i.e. not inside any scopes), there is no need to create a temporary variable and store the result expression into a variable. Instead, we can directly replace the function-call expression with the return-statement's expression. Unlike my previous solution, this does not require variable declarations to be rewritten. The no-scopes limitation makes it slightly less effective in theory, but in practice we still get almost all of the benefit. The no-scope limitation bites us on structures like @if (true) { return x; } else { return y; } Which will optimize away the if, but leave the scope: { return x; } However, this is not a big deal; the biggest wins are single-line helper functions like `guarded_divide` and `unpremul` which retain the full benefit. Change-Id: I7fbb725e65db021b9795c04c816819669815578f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345167 Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
2020-12-17 19:38:56 +00:00
OpDecorate %241 RelaxedPrecision
Reland "Simplify _blend_set_color_saturation, removing an instruction." This reverts commit e81fb87bb444c7f1dd087479b0a868f365a465ae. Reason for revert: checking results with less-aggressive inliner Original change's description: > Revert "Simplify _blend_set_color_saturation, removing an instruction." > > This reverts commit ed289e777cfa41c059b94e64e0c749fe47db563b. > > Reason for revert: causing strange artifacts, only on Adreno > > Original change's description: > > Simplify _blend_set_color_saturation, removing an instruction. > > > > This tightens up our intrinsics slightly; after inlining, it eliminates > > one scratch variable. (We no longer need to copy `sda` into `hueColor` > > as hueColor is now unchanged.) > > > > Change-Id: Iece5ba2fe11cde54481704a1787114a2c2a66d9b > > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/336599 > > Commit-Queue: John Stiles <johnstiles@google.com> > > Commit-Queue: Brian Osman <brianosman@google.com> > > Auto-Submit: John Stiles <johnstiles@google.com> > > Reviewed-by: Brian Osman <brianosman@google.com> > > TBR=brianosman@google.com,johnstiles@google.com > > Change-Id: Ica506467b0a4e03d0cbe482034acfa2d9f8d2c16 > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337560 > Reviewed-by: John Stiles <johnstiles@google.com> TBR=brianosman@google.com,johnstiles@google.com Change-Id: Ia93263f3269c057e7eaa69ca2b05e783d18c0199 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337944 Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: John Stiles <johnstiles@google.com>
2020-11-24 03:19:04 +00:00
OpDecorate %242 RelaxedPrecision
Deduplicate vector constants in SPIR-V output. Many of our shaders generate the same vector constant dozens of times, e.g. Gaussian blur uses float4(1) repeatedly. This change avoids re-emitting redundant vector constants. Change-Id: I22a71cd8b2783fb997f52d485b49031f64ca6d96 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/350701 Auto-Submit: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2021-01-06 18:33:31 +00:00
OpDecorate %245 RelaxedPrecision
Eliminate inliner temporary variables for top-level-exit functions. When we determine that a function only contains a single return statement and it is at the top level (i.e. not inside any scopes), there is no need to create a temporary variable and store the result expression into a variable. Instead, we can directly replace the function-call expression with the return-statement's expression. Unlike my previous solution, this does not require variable declarations to be rewritten. The no-scopes limitation makes it slightly less effective in theory, but in practice we still get almost all of the benefit. The no-scope limitation bites us on structures like @if (true) { return x; } else { return y; } Which will optimize away the if, but leave the scope: { return x; } However, this is not a big deal; the biggest wins are single-line helper functions like `guarded_divide` and `unpremul` which retain the full benefit. Change-Id: I7fbb725e65db021b9795c04c816819669815578f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345167 Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
2020-12-17 19:38:56 +00:00
OpDecorate %246 RelaxedPrecision
OpDecorate %247 RelaxedPrecision
Deduplicate vector constants in SPIR-V output. Many of our shaders generate the same vector constant dozens of times, e.g. Gaussian blur uses float4(1) repeatedly. This change avoids re-emitting redundant vector constants. Change-Id: I22a71cd8b2783fb997f52d485b49031f64ca6d96 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/350701 Auto-Submit: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2021-01-06 18:33:31 +00:00
OpDecorate %249 RelaxedPrecision
Reland "Simplify _blend_set_color_saturation, removing an instruction." This reverts commit e81fb87bb444c7f1dd087479b0a868f365a465ae. Reason for revert: checking results with less-aggressive inliner Original change's description: > Revert "Simplify _blend_set_color_saturation, removing an instruction." > > This reverts commit ed289e777cfa41c059b94e64e0c749fe47db563b. > > Reason for revert: causing strange artifacts, only on Adreno > > Original change's description: > > Simplify _blend_set_color_saturation, removing an instruction. > > > > This tightens up our intrinsics slightly; after inlining, it eliminates > > one scratch variable. (We no longer need to copy `sda` into `hueColor` > > as hueColor is now unchanged.) > > > > Change-Id: Iece5ba2fe11cde54481704a1787114a2c2a66d9b > > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/336599 > > Commit-Queue: John Stiles <johnstiles@google.com> > > Commit-Queue: Brian Osman <brianosman@google.com> > > Auto-Submit: John Stiles <johnstiles@google.com> > > Reviewed-by: Brian Osman <brianosman@google.com> > > TBR=brianosman@google.com,johnstiles@google.com > > Change-Id: Ica506467b0a4e03d0cbe482034acfa2d9f8d2c16 > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337560 > Reviewed-by: John Stiles <johnstiles@google.com> TBR=brianosman@google.com,johnstiles@google.com Change-Id: Ia93263f3269c057e7eaa69ca2b05e783d18c0199 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337944 Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: John Stiles <johnstiles@google.com>
2020-11-24 03:19:04 +00:00
OpDecorate %250 RelaxedPrecision
OpDecorate %251 RelaxedPrecision
Deduplicate vector constants in SPIR-V output. Many of our shaders generate the same vector constant dozens of times, e.g. Gaussian blur uses float4(1) repeatedly. This change avoids re-emitting redundant vector constants. Change-Id: I22a71cd8b2783fb997f52d485b49031f64ca6d96 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/350701 Auto-Submit: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2021-01-06 18:33:31 +00:00
OpDecorate %256 RelaxedPrecision
Reland "Simplify _blend_set_color_saturation, removing an instruction." This reverts commit e81fb87bb444c7f1dd087479b0a868f365a465ae. Reason for revert: checking results with less-aggressive inliner Original change's description: > Revert "Simplify _blend_set_color_saturation, removing an instruction." > > This reverts commit ed289e777cfa41c059b94e64e0c749fe47db563b. > > Reason for revert: causing strange artifacts, only on Adreno > > Original change's description: > > Simplify _blend_set_color_saturation, removing an instruction. > > > > This tightens up our intrinsics slightly; after inlining, it eliminates > > one scratch variable. (We no longer need to copy `sda` into `hueColor` > > as hueColor is now unchanged.) > > > > Change-Id: Iece5ba2fe11cde54481704a1787114a2c2a66d9b > > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/336599 > > Commit-Queue: John Stiles <johnstiles@google.com> > > Commit-Queue: Brian Osman <brianosman@google.com> > > Auto-Submit: John Stiles <johnstiles@google.com> > > Reviewed-by: Brian Osman <brianosman@google.com> > > TBR=brianosman@google.com,johnstiles@google.com > > Change-Id: Ica506467b0a4e03d0cbe482034acfa2d9f8d2c16 > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337560 > Reviewed-by: John Stiles <johnstiles@google.com> TBR=brianosman@google.com,johnstiles@google.com Change-Id: Ia93263f3269c057e7eaa69ca2b05e783d18c0199 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337944 Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: John Stiles <johnstiles@google.com>
2020-11-24 03:19:04 +00:00
OpDecorate %257 RelaxedPrecision
Eliminate inliner temporary variables for top-level-exit functions. When we determine that a function only contains a single return statement and it is at the top level (i.e. not inside any scopes), there is no need to create a temporary variable and store the result expression into a variable. Instead, we can directly replace the function-call expression with the return-statement's expression. Unlike my previous solution, this does not require variable declarations to be rewritten. The no-scopes limitation makes it slightly less effective in theory, but in practice we still get almost all of the benefit. The no-scope limitation bites us on structures like @if (true) { return x; } else { return y; } Which will optimize away the if, but leave the scope: { return x; } However, this is not a big deal; the biggest wins are single-line helper functions like `guarded_divide` and `unpremul` which retain the full benefit. Change-Id: I7fbb725e65db021b9795c04c816819669815578f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345167 Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
2020-12-17 19:38:56 +00:00
OpDecorate %258 RelaxedPrecision
Deduplicate vector constants in SPIR-V output. Many of our shaders generate the same vector constant dozens of times, e.g. Gaussian blur uses float4(1) repeatedly. This change avoids re-emitting redundant vector constants. Change-Id: I22a71cd8b2783fb997f52d485b49031f64ca6d96 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/350701 Auto-Submit: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2021-01-06 18:33:31 +00:00
OpDecorate %260 RelaxedPrecision
Avoid inlining functions that are called repeatedly. Previously, we'd gauge suitability for inlining by counting the nodes in a function; past a certain limit, the function was considered "too big." Now, we also incorporate the number of times that function is called. So if a function is called three times, and its size is 20 nodes, it would be considered to have an inlining cost of 60 (3 * 20) instead of 20. This should tamp down the aggressive nature of the inliner in cases like gaussian convolution or complicated blends, and will hopefully satisfy Pinpoint. No change visible in Nanobench (which doesn't test any of these sorts of patterns, but certainly inlines things): http://screen/AwD5hkgkEfjVx4g Change-Id: Ie5e32898245ac854adb9ddd52d87001df6a67125 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337676 Commit-Queue: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Auto-Submit: John Stiles <johnstiles@google.com>
2020-11-23 19:48:06 +00:00
OpDecorate %261 RelaxedPrecision
Eliminate inliner temporary variables for top-level-exit functions. When we determine that a function only contains a single return statement and it is at the top level (i.e. not inside any scopes), there is no need to create a temporary variable and store the result expression into a variable. Instead, we can directly replace the function-call expression with the return-statement's expression. Unlike my previous solution, this does not require variable declarations to be rewritten. The no-scopes limitation makes it slightly less effective in theory, but in practice we still get almost all of the benefit. The no-scope limitation bites us on structures like @if (true) { return x; } else { return y; } Which will optimize away the if, but leave the scope: { return x; } However, this is not a big deal; the biggest wins are single-line helper functions like `guarded_divide` and `unpremul` which retain the full benefit. Change-Id: I7fbb725e65db021b9795c04c816819669815578f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345167 Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
2020-12-17 19:38:56 +00:00
OpDecorate %262 RelaxedPrecision
OpDecorate %263 RelaxedPrecision
Deduplicate vector constants in SPIR-V output. Many of our shaders generate the same vector constant dozens of times, e.g. Gaussian blur uses float4(1) repeatedly. This change avoids re-emitting redundant vector constants. Change-Id: I22a71cd8b2783fb997f52d485b49031f64ca6d96 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/350701 Auto-Submit: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2021-01-06 18:33:31 +00:00
OpDecorate %265 RelaxedPrecision
Enable SPIR-V disassembly output from skslc. We now have SPIR-V golden outputs for `blend` and `shared` tests. This exposes a handful of SPIR-V limitations for us to address. Change-Id: Ie5278889b8a61432403d06231b17765885bee0ac Bug: skia:10694 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337182 Commit-Queue: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2020-11-20 21:28:50 +00:00
OpDecorate %266 RelaxedPrecision
Avoid inlining functions that are called repeatedly. Previously, we'd gauge suitability for inlining by counting the nodes in a function; past a certain limit, the function was considered "too big." Now, we also incorporate the number of times that function is called. So if a function is called three times, and its size is 20 nodes, it would be considered to have an inlining cost of 60 (3 * 20) instead of 20. This should tamp down the aggressive nature of the inliner in cases like gaussian convolution or complicated blends, and will hopefully satisfy Pinpoint. No change visible in Nanobench (which doesn't test any of these sorts of patterns, but certainly inlines things): http://screen/AwD5hkgkEfjVx4g Change-Id: Ie5e32898245ac854adb9ddd52d87001df6a67125 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337676 Commit-Queue: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Auto-Submit: John Stiles <johnstiles@google.com>
2020-11-23 19:48:06 +00:00
OpDecorate %267 RelaxedPrecision
Deduplicate vector constants in SPIR-V output. Many of our shaders generate the same vector constant dozens of times, e.g. Gaussian blur uses float4(1) repeatedly. This change avoids re-emitting redundant vector constants. Change-Id: I22a71cd8b2783fb997f52d485b49031f64ca6d96 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/350701 Auto-Submit: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2021-01-06 18:33:31 +00:00
OpDecorate %271 RelaxedPrecision
OpDecorate %273 RelaxedPrecision
OpDecorate %275 RelaxedPrecision
Revert "Simplify _blend_set_color_saturation, removing an instruction." This reverts commit ed289e777cfa41c059b94e64e0c749fe47db563b. Reason for revert: causing strange artifacts, only on Adreno Original change's description: > Simplify _blend_set_color_saturation, removing an instruction. > > This tightens up our intrinsics slightly; after inlining, it eliminates > one scratch variable. (We no longer need to copy `sda` into `hueColor` > as hueColor is now unchanged.) > > Change-Id: Iece5ba2fe11cde54481704a1787114a2c2a66d9b > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/336599 > Commit-Queue: John Stiles <johnstiles@google.com> > Commit-Queue: Brian Osman <brianosman@google.com> > Auto-Submit: John Stiles <johnstiles@google.com> > Reviewed-by: Brian Osman <brianosman@google.com> TBR=brianosman@google.com,johnstiles@google.com Change-Id: Ica506467b0a4e03d0cbe482034acfa2d9f8d2c16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337560 Reviewed-by: John Stiles <johnstiles@google.com>
2020-11-23 15:55:00 +00:00
OpDecorate %276 RelaxedPrecision
Avoid inlining functions that are called repeatedly. Previously, we'd gauge suitability for inlining by counting the nodes in a function; past a certain limit, the function was considered "too big." Now, we also incorporate the number of times that function is called. So if a function is called three times, and its size is 20 nodes, it would be considered to have an inlining cost of 60 (3 * 20) instead of 20. This should tamp down the aggressive nature of the inliner in cases like gaussian convolution or complicated blends, and will hopefully satisfy Pinpoint. No change visible in Nanobench (which doesn't test any of these sorts of patterns, but certainly inlines things): http://screen/AwD5hkgkEfjVx4g Change-Id: Ie5e32898245ac854adb9ddd52d87001df6a67125 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337676 Commit-Queue: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Auto-Submit: John Stiles <johnstiles@google.com>
2020-11-23 19:48:06 +00:00
OpDecorate %277 RelaxedPrecision
Enable SPIR-V disassembly output from skslc. We now have SPIR-V golden outputs for `blend` and `shared` tests. This exposes a handful of SPIR-V limitations for us to address. Change-Id: Ie5278889b8a61432403d06231b17765885bee0ac Bug: skia:10694 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337182 Commit-Queue: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2020-11-20 21:28:50 +00:00
%float = OpTypeFloat 32
%v4float = OpTypeVector %float 4
%_ptr_Output_v4float = OpTypePointer Output %v4float
%sk_FragColor = OpVariable %_ptr_Output_v4float Output
%bool = OpTypeBool
%_ptr_Input_bool = OpTypePointer Input %bool
%sk_Clockwise = OpVariable %_ptr_Input_bool Input
%_ptr_Input_v4float = OpTypePointer Input %v4float
%src = OpVariable %_ptr_Input_v4float Input
%dst = OpVariable %_ptr_Input_v4float Input
%v3float = OpTypeVector %float 3
%_ptr_Function_v3float = OpTypePointer Function %v3float
Avoid inlining functions that are called repeatedly. Previously, we'd gauge suitability for inlining by counting the nodes in a function; past a certain limit, the function was considered "too big." Now, we also incorporate the number of times that function is called. So if a function is called three times, and its size is 20 nodes, it would be considered to have an inlining cost of 60 (3 * 20) instead of 20. This should tamp down the aggressive nature of the inliner in cases like gaussian convolution or complicated blends, and will hopefully satisfy Pinpoint. No change visible in Nanobench (which doesn't test any of these sorts of patterns, but certainly inlines things): http://screen/AwD5hkgkEfjVx4g Change-Id: Ie5e32898245ac854adb9ddd52d87001df6a67125 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337676 Commit-Queue: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Auto-Submit: John Stiles <johnstiles@google.com>
2020-11-23 19:48:06 +00:00
%_ptr_Function_float = OpTypePointer Function %float
%15 = OpTypeFunction %v3float %_ptr_Function_v3float %_ptr_Function_float
Enable SPIR-V disassembly output from skslc. We now have SPIR-V golden outputs for `blend` and `shared` tests. This exposes a handful of SPIR-V limitations for us to address. Change-Id: Ie5278889b8a61432403d06231b17765885bee0ac Bug: skia:10694 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337182 Commit-Queue: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2020-11-20 21:28:50 +00:00
%float_0 = OpConstant %float 0
Avoid inlining functions that are called repeatedly. Previously, we'd gauge suitability for inlining by counting the nodes in a function; past a certain limit, the function was considered "too big." Now, we also incorporate the number of times that function is called. So if a function is called three times, and its size is 20 nodes, it would be considered to have an inlining cost of 60 (3 * 20) instead of 20. This should tamp down the aggressive nature of the inliner in cases like gaussian convolution or complicated blends, and will hopefully satisfy Pinpoint. No change visible in Nanobench (which doesn't test any of these sorts of patterns, but certainly inlines things): http://screen/AwD5hkgkEfjVx4g Change-Id: Ie5e32898245ac854adb9ddd52d87001df6a67125 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337676 Commit-Queue: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Auto-Submit: John Stiles <johnstiles@google.com>
2020-11-23 19:48:06 +00:00
%46 = OpConstantComposite %v3float %float_0 %float_0 %float_0
%void = OpTypeVoid
%49 = OpTypeFunction %void
Enable SPIR-V disassembly output from skslc. We now have SPIR-V golden outputs for `blend` and `shared` tests. This exposes a handful of SPIR-V limitations for us to address. Change-Id: Ie5278889b8a61432403d06231b17765885bee0ac Bug: skia:10694 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337182 Commit-Queue: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2020-11-20 21:28:50 +00:00
%float_0_300000012 = OpConstant %float 0.300000012
%float_0_589999974 = OpConstant %float 0.589999974
%float_0_109999999 = OpConstant %float 0.109999999
Deduplicate vector constants in SPIR-V output. Many of our shaders generate the same vector constant dozens of times, e.g. Gaussian blur uses float4(1) repeatedly. This change avoids re-emitting redundant vector constants. Change-Id: I22a71cd8b2783fb997f52d485b49031f64ca6d96 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/350701 Auto-Submit: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2021-01-06 18:33:31 +00:00
%173 = OpConstantComposite %v3float %float_0_300000012 %float_0_589999974 %float_0_109999999
Enable SPIR-V disassembly output from skslc. We now have SPIR-V golden outputs for `blend` and `shared` tests. This exposes a handful of SPIR-V limitations for us to address. Change-Id: Ie5278889b8a61432403d06231b17765885bee0ac Bug: skia:10694 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337182 Commit-Queue: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2020-11-20 21:28:50 +00:00
%false = OpConstantFalse %bool
%float_1 = OpConstant %float 1
Avoid inlining functions that are called repeatedly. Previously, we'd gauge suitability for inlining by counting the nodes in a function; past a certain limit, the function was considered "too big." Now, we also incorporate the number of times that function is called. So if a function is called three times, and its size is 20 nodes, it would be considered to have an inlining cost of 60 (3 * 20) instead of 20. This should tamp down the aggressive nature of the inliner in cases like gaussian convolution or complicated blends, and will hopefully satisfy Pinpoint. No change visible in Nanobench (which doesn't test any of these sorts of patterns, but certainly inlines things): http://screen/AwD5hkgkEfjVx4g Change-Id: Ie5e32898245ac854adb9ddd52d87001df6a67125 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337676 Commit-Queue: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Auto-Submit: John Stiles <johnstiles@google.com>
2020-11-23 19:48:06 +00:00
%_blend_set_color_saturation_helper = OpFunction %v3float None %15
%18 = OpFunctionParameter %_ptr_Function_v3float
%19 = OpFunctionParameter %_ptr_Function_float
%20 = OpLabel
%26 = OpVariable %_ptr_Function_v3float Function
%21 = OpLoad %v3float %18
%22 = OpCompositeExtract %float %21 0
%23 = OpLoad %v3float %18
%24 = OpCompositeExtract %float %23 2
%25 = OpFOrdLessThan %bool %22 %24
OpSelectionMerge %29 None
OpBranchConditional %25 %27 %28
%27 = OpLabel
%31 = OpLoad %float %19
%32 = OpLoad %v3float %18
%33 = OpCompositeExtract %float %32 1
%34 = OpLoad %v3float %18
%35 = OpCompositeExtract %float %34 0
%36 = OpFSub %float %33 %35
%37 = OpFMul %float %31 %36
%38 = OpLoad %v3float %18
%39 = OpCompositeExtract %float %38 2
%40 = OpLoad %v3float %18
%41 = OpCompositeExtract %float %40 0
%42 = OpFSub %float %39 %41
%43 = OpFDiv %float %37 %42
%44 = OpLoad %float %19
%45 = OpCompositeConstruct %v3float %float_0 %43 %44
OpStore %26 %45
OpBranch %29
%28 = OpLabel
OpStore %26 %46
OpBranch %29
%29 = OpLabel
%47 = OpLoad %v3float %26
OpReturnValue %47
OpFunctionEnd
%main = OpFunction %void None %49
%50 = OpLabel
Enable SPIR-V disassembly output from skslc. We now have SPIR-V golden outputs for `blend` and `shared` tests. This exposes a handful of SPIR-V limitations for us to address. Change-Id: Ie5278889b8a61432403d06231b17765885bee0ac Bug: skia:10694 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337182 Commit-Queue: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2020-11-20 21:28:50 +00:00
%_1_alpha = OpVariable %_ptr_Function_float Function
%_2_sda = OpVariable %_ptr_Function_v3float Function
%_3_dsa = OpVariable %_ptr_Function_v3float Function
%_4_blend_set_color_saturation = OpVariable %_ptr_Function_v3float Function
Eliminate inliner temporary variables for top-level-exit functions. When we determine that a function only contains a single return statement and it is at the top level (i.e. not inside any scopes), there is no need to create a temporary variable and store the result expression into a variable. Instead, we can directly replace the function-call expression with the return-statement's expression. Unlike my previous solution, this does not require variable declarations to be rewritten. The no-scopes limitation makes it slightly less effective in theory, but in practice we still get almost all of the benefit. The no-scope limitation bites us on structures like @if (true) { return x; } else { return y; } Which will optimize away the if, but leave the scope: { return x; } However, this is not a big deal; the biggest wins are single-line helper functions like `guarded_divide` and `unpremul` which retain the full benefit. Change-Id: I7fbb725e65db021b9795c04c816819669815578f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345167 Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
2020-12-17 19:38:56 +00:00
%_5_sat = OpVariable %_ptr_Function_float Function
%105 = OpVariable %_ptr_Function_v3float Function
%107 = OpVariable %_ptr_Function_float Function
%119 = OpVariable %_ptr_Function_v3float Function
%121 = OpVariable %_ptr_Function_float Function
%126 = OpVariable %_ptr_Function_v3float Function
%128 = OpVariable %_ptr_Function_float Function
%141 = OpVariable %_ptr_Function_v3float Function
%143 = OpVariable %_ptr_Function_float Function
%156 = OpVariable %_ptr_Function_v3float Function
%158 = OpVariable %_ptr_Function_float Function
%163 = OpVariable %_ptr_Function_v3float Function
%165 = OpVariable %_ptr_Function_float Function
%_7_lum = OpVariable %_ptr_Function_float Function
%_8_result = OpVariable %_ptr_Function_v3float Function
%_9_minComp = OpVariable %_ptr_Function_float Function
%_10_maxComp = OpVariable %_ptr_Function_float Function
Deduplicate vector constants in SPIR-V output. Many of our shaders generate the same vector constant dozens of times, e.g. Gaussian blur uses float4(1) repeatedly. This change avoids re-emitting redundant vector constants. Change-Id: I22a71cd8b2783fb997f52d485b49031f64ca6d96 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/350701 Auto-Submit: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2021-01-06 18:33:31 +00:00
%236 = OpVariable %_ptr_Function_v3float Function
Eliminate inliner temporary variables for top-level-exit functions. When we determine that a function only contains a single return statement and it is at the top level (i.e. not inside any scopes), there is no need to create a temporary variable and store the result expression into a variable. Instead, we can directly replace the function-call expression with the return-statement's expression. Unlike my previous solution, this does not require variable declarations to be rewritten. The no-scopes limitation makes it slightly less effective in theory, but in practice we still get almost all of the benefit. The no-scope limitation bites us on structures like @if (true) { return x; } else { return y; } Which will optimize away the if, but leave the scope: { return x; } However, this is not a big deal; the biggest wins are single-line helper functions like `guarded_divide` and `unpremul` which retain the full benefit. Change-Id: I7fbb725e65db021b9795c04c816819669815578f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345167 Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
2020-12-17 19:38:56 +00:00
%52 = OpLoad %v4float %dst
%53 = OpCompositeExtract %float %52 3
%54 = OpLoad %v4float %src
Revert "Declare all inlined variables at the topmost scope possible." This reverts commit e8e4aca955bc87732ada3dd42ec60f6b1a37443e. Reason for revert: can break ES2 for-loop rules Original change's description: > Declare all inlined variables at the topmost scope possible. > > By itself, this is uninteresting and even perhaps slightly > counterproductive (as it separates vardecl from its initializer, > increasing LOC). However, this enables a followup CL > (http://review.skia.org/344665) which allows single-return functions to > be inlined without the creation of a temporary variable at all. This > applies to the majority of fragment processors in a typical Ganesh > hierarchy. This change will greatly reduce the number of inliner-created > temporary copies when compiling a typical tree of FPs. > > Change-Id: I03423a13cf35050637dabace4a32973a08a4ed0a > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/344764 > Reviewed-by: Brian Osman <brianosman@google.com> > Commit-Queue: John Stiles <johnstiles@google.com> TBR=brianosman@google.com,ethannicholas@google.com,johnstiles@google.com Change-Id: Ica01d6906bcb9cef1f49d22dda714fc9cbfa3885 No-Presubmit: true No-Tree-Checks: true No-Try: true Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345121 Reviewed-by: John Stiles <johnstiles@google.com> Commit-Queue: John Stiles <johnstiles@google.com>
2020-12-16 18:25:14 +00:00
%55 = OpCompositeExtract %float %54 3
Eliminate inliner temporary variables for top-level-exit functions. When we determine that a function only contains a single return statement and it is at the top level (i.e. not inside any scopes), there is no need to create a temporary variable and store the result expression into a variable. Instead, we can directly replace the function-call expression with the return-statement's expression. Unlike my previous solution, this does not require variable declarations to be rewritten. The no-scopes limitation makes it slightly less effective in theory, but in practice we still get almost all of the benefit. The no-scope limitation bites us on structures like @if (true) { return x; } else { return y; } Which will optimize away the if, but leave the scope: { return x; } However, this is not a big deal; the biggest wins are single-line helper functions like `guarded_divide` and `unpremul` which retain the full benefit. Change-Id: I7fbb725e65db021b9795c04c816819669815578f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345167 Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
2020-12-17 19:38:56 +00:00
%56 = OpFMul %float %53 %55
OpStore %_1_alpha %56
%58 = OpLoad %v4float %src
%59 = OpVectorShuffle %v3float %58 %58 0 1 2
%60 = OpLoad %v4float %dst
%61 = OpCompositeExtract %float %60 3
%62 = OpVectorTimesScalar %v3float %59 %61
OpStore %_2_sda %62
%64 = OpLoad %v4float %dst
%65 = OpVectorShuffle %v3float %64 %64 0 1 2
%66 = OpLoad %v4float %src
%67 = OpCompositeExtract %float %66 3
%68 = OpVectorTimesScalar %v3float %65 %67
OpStore %_3_dsa %68
%73 = OpLoad %v3float %_2_sda
%74 = OpCompositeExtract %float %73 0
Revert "Declare all inlined variables at the topmost scope possible." This reverts commit e8e4aca955bc87732ada3dd42ec60f6b1a37443e. Reason for revert: can break ES2 for-loop rules Original change's description: > Declare all inlined variables at the topmost scope possible. > > By itself, this is uninteresting and even perhaps slightly > counterproductive (as it separates vardecl from its initializer, > increasing LOC). However, this enables a followup CL > (http://review.skia.org/344665) which allows single-return functions to > be inlined without the creation of a temporary variable at all. This > applies to the majority of fragment processors in a typical Ganesh > hierarchy. This change will greatly reduce the number of inliner-created > temporary copies when compiling a typical tree of FPs. > > Change-Id: I03423a13cf35050637dabace4a32973a08a4ed0a > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/344764 > Reviewed-by: Brian Osman <brianosman@google.com> > Commit-Queue: John Stiles <johnstiles@google.com> TBR=brianosman@google.com,ethannicholas@google.com,johnstiles@google.com Change-Id: Ica01d6906bcb9cef1f49d22dda714fc9cbfa3885 No-Presubmit: true No-Tree-Checks: true No-Try: true Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345121 Reviewed-by: John Stiles <johnstiles@google.com> Commit-Queue: John Stiles <johnstiles@google.com>
2020-12-16 18:25:14 +00:00
%75 = OpLoad %v3float %_2_sda
Eliminate inliner temporary variables for top-level-exit functions. When we determine that a function only contains a single return statement and it is at the top level (i.e. not inside any scopes), there is no need to create a temporary variable and store the result expression into a variable. Instead, we can directly replace the function-call expression with the return-statement's expression. Unlike my previous solution, this does not require variable declarations to be rewritten. The no-scopes limitation makes it slightly less effective in theory, but in practice we still get almost all of the benefit. The no-scope limitation bites us on structures like @if (true) { return x; } else { return y; } Which will optimize away the if, but leave the scope: { return x; } However, this is not a big deal; the biggest wins are single-line helper functions like `guarded_divide` and `unpremul` which retain the full benefit. Change-Id: I7fbb725e65db021b9795c04c816819669815578f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345167 Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
2020-12-17 19:38:56 +00:00
%76 = OpCompositeExtract %float %75 1
%72 = OpExtInst %float %1 FMax %74 %76
Revert "Declare all inlined variables at the topmost scope possible." This reverts commit e8e4aca955bc87732ada3dd42ec60f6b1a37443e. Reason for revert: can break ES2 for-loop rules Original change's description: > Declare all inlined variables at the topmost scope possible. > > By itself, this is uninteresting and even perhaps slightly > counterproductive (as it separates vardecl from its initializer, > increasing LOC). However, this enables a followup CL > (http://review.skia.org/344665) which allows single-return functions to > be inlined without the creation of a temporary variable at all. This > applies to the majority of fragment processors in a typical Ganesh > hierarchy. This change will greatly reduce the number of inliner-created > temporary copies when compiling a typical tree of FPs. > > Change-Id: I03423a13cf35050637dabace4a32973a08a4ed0a > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/344764 > Reviewed-by: Brian Osman <brianosman@google.com> > Commit-Queue: John Stiles <johnstiles@google.com> TBR=brianosman@google.com,ethannicholas@google.com,johnstiles@google.com Change-Id: Ica01d6906bcb9cef1f49d22dda714fc9cbfa3885 No-Presubmit: true No-Tree-Checks: true No-Try: true Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345121 Reviewed-by: John Stiles <johnstiles@google.com> Commit-Queue: John Stiles <johnstiles@google.com>
2020-12-16 18:25:14 +00:00
%77 = OpLoad %v3float %_2_sda
Eliminate inliner temporary variables for top-level-exit functions. When we determine that a function only contains a single return statement and it is at the top level (i.e. not inside any scopes), there is no need to create a temporary variable and store the result expression into a variable. Instead, we can directly replace the function-call expression with the return-statement's expression. Unlike my previous solution, this does not require variable declarations to be rewritten. The no-scopes limitation makes it slightly less effective in theory, but in practice we still get almost all of the benefit. The no-scope limitation bites us on structures like @if (true) { return x; } else { return y; } Which will optimize away the if, but leave the scope: { return x; } However, this is not a big deal; the biggest wins are single-line helper functions like `guarded_divide` and `unpremul` which retain the full benefit. Change-Id: I7fbb725e65db021b9795c04c816819669815578f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345167 Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
2020-12-17 19:38:56 +00:00
%78 = OpCompositeExtract %float %77 2
%71 = OpExtInst %float %1 FMax %72 %78
%81 = OpLoad %v3float %_2_sda
%82 = OpCompositeExtract %float %81 0
Revert "Declare all inlined variables at the topmost scope possible." This reverts commit e8e4aca955bc87732ada3dd42ec60f6b1a37443e. Reason for revert: can break ES2 for-loop rules Original change's description: > Declare all inlined variables at the topmost scope possible. > > By itself, this is uninteresting and even perhaps slightly > counterproductive (as it separates vardecl from its initializer, > increasing LOC). However, this enables a followup CL > (http://review.skia.org/344665) which allows single-return functions to > be inlined without the creation of a temporary variable at all. This > applies to the majority of fragment processors in a typical Ganesh > hierarchy. This change will greatly reduce the number of inliner-created > temporary copies when compiling a typical tree of FPs. > > Change-Id: I03423a13cf35050637dabace4a32973a08a4ed0a > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/344764 > Reviewed-by: Brian Osman <brianosman@google.com> > Commit-Queue: John Stiles <johnstiles@google.com> TBR=brianosman@google.com,ethannicholas@google.com,johnstiles@google.com Change-Id: Ica01d6906bcb9cef1f49d22dda714fc9cbfa3885 No-Presubmit: true No-Tree-Checks: true No-Try: true Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345121 Reviewed-by: John Stiles <johnstiles@google.com> Commit-Queue: John Stiles <johnstiles@google.com>
2020-12-16 18:25:14 +00:00
%83 = OpLoad %v3float %_2_sda
Eliminate inliner temporary variables for top-level-exit functions. When we determine that a function only contains a single return statement and it is at the top level (i.e. not inside any scopes), there is no need to create a temporary variable and store the result expression into a variable. Instead, we can directly replace the function-call expression with the return-statement's expression. Unlike my previous solution, this does not require variable declarations to be rewritten. The no-scopes limitation makes it slightly less effective in theory, but in practice we still get almost all of the benefit. The no-scope limitation bites us on structures like @if (true) { return x; } else { return y; } Which will optimize away the if, but leave the scope: { return x; } However, this is not a big deal; the biggest wins are single-line helper functions like `guarded_divide` and `unpremul` which retain the full benefit. Change-Id: I7fbb725e65db021b9795c04c816819669815578f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345167 Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
2020-12-17 19:38:56 +00:00
%84 = OpCompositeExtract %float %83 1
%80 = OpExtInst %float %1 FMin %82 %84
Revert "Declare all inlined variables at the topmost scope possible." This reverts commit e8e4aca955bc87732ada3dd42ec60f6b1a37443e. Reason for revert: can break ES2 for-loop rules Original change's description: > Declare all inlined variables at the topmost scope possible. > > By itself, this is uninteresting and even perhaps slightly > counterproductive (as it separates vardecl from its initializer, > increasing LOC). However, this enables a followup CL > (http://review.skia.org/344665) which allows single-return functions to > be inlined without the creation of a temporary variable at all. This > applies to the majority of fragment processors in a typical Ganesh > hierarchy. This change will greatly reduce the number of inliner-created > temporary copies when compiling a typical tree of FPs. > > Change-Id: I03423a13cf35050637dabace4a32973a08a4ed0a > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/344764 > Reviewed-by: Brian Osman <brianosman@google.com> > Commit-Queue: John Stiles <johnstiles@google.com> TBR=brianosman@google.com,ethannicholas@google.com,johnstiles@google.com Change-Id: Ica01d6906bcb9cef1f49d22dda714fc9cbfa3885 No-Presubmit: true No-Tree-Checks: true No-Try: true Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345121 Reviewed-by: John Stiles <johnstiles@google.com> Commit-Queue: John Stiles <johnstiles@google.com>
2020-12-16 18:25:14 +00:00
%85 = OpLoad %v3float %_2_sda
Eliminate inliner temporary variables for top-level-exit functions. When we determine that a function only contains a single return statement and it is at the top level (i.e. not inside any scopes), there is no need to create a temporary variable and store the result expression into a variable. Instead, we can directly replace the function-call expression with the return-statement's expression. Unlike my previous solution, this does not require variable declarations to be rewritten. The no-scopes limitation makes it slightly less effective in theory, but in practice we still get almost all of the benefit. The no-scope limitation bites us on structures like @if (true) { return x; } else { return y; } Which will optimize away the if, but leave the scope: { return x; } However, this is not a big deal; the biggest wins are single-line helper functions like `guarded_divide` and `unpremul` which retain the full benefit. Change-Id: I7fbb725e65db021b9795c04c816819669815578f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345167 Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
2020-12-17 19:38:56 +00:00
%86 = OpCompositeExtract %float %85 2
%79 = OpExtInst %float %1 FMin %80 %86
%87 = OpFSub %float %71 %79
OpStore %_5_sat %87
%88 = OpLoad %v3float %_3_dsa
%89 = OpCompositeExtract %float %88 0
%90 = OpLoad %v3float %_3_dsa
%91 = OpCompositeExtract %float %90 1
%92 = OpFOrdLessThanEqual %bool %89 %91
OpSelectionMerge %95 None
OpBranchConditional %92 %93 %94
%93 = OpLabel
%96 = OpLoad %v3float %_3_dsa
%97 = OpCompositeExtract %float %96 1
%98 = OpLoad %v3float %_3_dsa
%99 = OpCompositeExtract %float %98 2
%100 = OpFOrdLessThanEqual %bool %97 %99
OpSelectionMerge %103 None
OpBranchConditional %100 %101 %102
%101 = OpLabel
%104 = OpLoad %v3float %_3_dsa
OpStore %105 %104
%106 = OpLoad %float %_5_sat
OpStore %107 %106
%108 = OpFunctionCall %v3float %_blend_set_color_saturation_helper %105 %107
OpStore %_4_blend_set_color_saturation %108
OpBranch %103
%102 = OpLabel
%109 = OpLoad %v3float %_3_dsa
%110 = OpCompositeExtract %float %109 0
%111 = OpLoad %v3float %_3_dsa
%112 = OpCompositeExtract %float %111 2
%113 = OpFOrdLessThanEqual %bool %110 %112
OpSelectionMerge %116 None
OpBranchConditional %113 %114 %115
%114 = OpLabel
%117 = OpLoad %v3float %_3_dsa
%118 = OpVectorShuffle %v3float %117 %117 0 2 1
OpStore %119 %118
%120 = OpLoad %float %_5_sat
OpStore %121 %120
%122 = OpFunctionCall %v3float %_blend_set_color_saturation_helper %119 %121
%123 = OpVectorShuffle %v3float %122 %122 0 2 1
OpStore %_4_blend_set_color_saturation %123
OpBranch %116
%115 = OpLabel
%124 = OpLoad %v3float %_3_dsa
%125 = OpVectorShuffle %v3float %124 %124 2 0 1
OpStore %126 %125
%127 = OpLoad %float %_5_sat
OpStore %128 %127
%129 = OpFunctionCall %v3float %_blend_set_color_saturation_helper %126 %128
%130 = OpVectorShuffle %v3float %129 %129 1 2 0
OpStore %_4_blend_set_color_saturation %130
OpBranch %116
%116 = OpLabel
OpBranch %103
%103 = OpLabel
OpBranch %95
%94 = OpLabel
%131 = OpLoad %v3float %_3_dsa
%132 = OpCompositeExtract %float %131 0
%133 = OpLoad %v3float %_3_dsa
%134 = OpCompositeExtract %float %133 2
%135 = OpFOrdLessThanEqual %bool %132 %134
OpSelectionMerge %138 None
OpBranchConditional %135 %136 %137
%136 = OpLabel
%139 = OpLoad %v3float %_3_dsa
%140 = OpVectorShuffle %v3float %139 %139 1 0 2
OpStore %141 %140
%142 = OpLoad %float %_5_sat
OpStore %143 %142
%144 = OpFunctionCall %v3float %_blend_set_color_saturation_helper %141 %143
%145 = OpVectorShuffle %v3float %144 %144 1 0 2
OpStore %_4_blend_set_color_saturation %145
OpBranch %138
%137 = OpLabel
%146 = OpLoad %v3float %_3_dsa
%147 = OpCompositeExtract %float %146 1
%148 = OpLoad %v3float %_3_dsa
%149 = OpCompositeExtract %float %148 2
%150 = OpFOrdLessThanEqual %bool %147 %149
OpSelectionMerge %153 None
OpBranchConditional %150 %151 %152
%151 = OpLabel
%154 = OpLoad %v3float %_3_dsa
%155 = OpVectorShuffle %v3float %154 %154 1 2 0
OpStore %156 %155
%157 = OpLoad %float %_5_sat
OpStore %158 %157
%159 = OpFunctionCall %v3float %_blend_set_color_saturation_helper %156 %158
%160 = OpVectorShuffle %v3float %159 %159 2 0 1
OpStore %_4_blend_set_color_saturation %160
OpBranch %153
%152 = OpLabel
%161 = OpLoad %v3float %_3_dsa
%162 = OpVectorShuffle %v3float %161 %161 2 1 0
OpStore %163 %162
%164 = OpLoad %float %_5_sat
OpStore %165 %164
%166 = OpFunctionCall %v3float %_blend_set_color_saturation_helper %163 %165
%167 = OpVectorShuffle %v3float %166 %166 2 1 0
OpStore %_4_blend_set_color_saturation %167
OpBranch %153
%153 = OpLabel
OpBranch %138
%138 = OpLabel
OpBranch %95
%95 = OpLabel
%174 = OpLoad %v3float %_3_dsa
Deduplicate vector constants in SPIR-V output. Many of our shaders generate the same vector constant dozens of times, e.g. Gaussian blur uses float4(1) repeatedly. This change avoids re-emitting redundant vector constants. Change-Id: I22a71cd8b2783fb997f52d485b49031f64ca6d96 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/350701 Auto-Submit: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2021-01-06 18:33:31 +00:00
%169 = OpDot %float %173 %174
Eliminate inliner temporary variables for top-level-exit functions. When we determine that a function only contains a single return statement and it is at the top level (i.e. not inside any scopes), there is no need to create a temporary variable and store the result expression into a variable. Instead, we can directly replace the function-call expression with the return-statement's expression. Unlike my previous solution, this does not require variable declarations to be rewritten. The no-scopes limitation makes it slightly less effective in theory, but in practice we still get almost all of the benefit. The no-scope limitation bites us on structures like @if (true) { return x; } else { return y; } Which will optimize away the if, but leave the scope: { return x; } However, this is not a big deal; the biggest wins are single-line helper functions like `guarded_divide` and `unpremul` which retain the full benefit. Change-Id: I7fbb725e65db021b9795c04c816819669815578f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345167 Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
2020-12-17 19:38:56 +00:00
OpStore %_7_lum %169
%176 = OpLoad %float %_7_lum
Deduplicate vector constants in SPIR-V output. Many of our shaders generate the same vector constant dozens of times, e.g. Gaussian blur uses float4(1) repeatedly. This change avoids re-emitting redundant vector constants. Change-Id: I22a71cd8b2783fb997f52d485b49031f64ca6d96 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/350701 Auto-Submit: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2021-01-06 18:33:31 +00:00
%178 = OpLoad %v3float %_4_blend_set_color_saturation
%177 = OpDot %float %173 %178
%179 = OpFSub %float %176 %177
%180 = OpLoad %v3float %_4_blend_set_color_saturation
%181 = OpCompositeConstruct %v3float %179 %179 %179
%182 = OpFAdd %v3float %181 %180
OpStore %_8_result %182
%186 = OpLoad %v3float %_8_result
%187 = OpCompositeExtract %float %186 0
%188 = OpLoad %v3float %_8_result
%189 = OpCompositeExtract %float %188 1
%185 = OpExtInst %float %1 FMin %187 %189
%190 = OpLoad %v3float %_8_result
%191 = OpCompositeExtract %float %190 2
%184 = OpExtInst %float %1 FMin %185 %191
OpStore %_9_minComp %184
%195 = OpLoad %v3float %_8_result
%196 = OpCompositeExtract %float %195 0
%197 = OpLoad %v3float %_8_result
%198 = OpCompositeExtract %float %197 1
%194 = OpExtInst %float %1 FMax %196 %198
%199 = OpLoad %v3float %_8_result
%200 = OpCompositeExtract %float %199 2
%193 = OpExtInst %float %1 FMax %194 %200
OpStore %_10_maxComp %193
%202 = OpLoad %float %_9_minComp
%203 = OpFOrdLessThan %bool %202 %float_0
OpSelectionMerge %205 None
OpBranchConditional %203 %204 %205
%204 = OpLabel
%206 = OpLoad %float %_7_lum
%207 = OpLoad %float %_9_minComp
%208 = OpFOrdNotEqual %bool %206 %207
OpBranch %205
Eliminate inliner temporary variables for top-level-exit functions. When we determine that a function only contains a single return statement and it is at the top level (i.e. not inside any scopes), there is no need to create a temporary variable and store the result expression into a variable. Instead, we can directly replace the function-call expression with the return-statement's expression. Unlike my previous solution, this does not require variable declarations to be rewritten. The no-scopes limitation makes it slightly less effective in theory, but in practice we still get almost all of the benefit. The no-scope limitation bites us on structures like @if (true) { return x; } else { return y; } Which will optimize away the if, but leave the scope: { return x; } However, this is not a big deal; the biggest wins are single-line helper functions like `guarded_divide` and `unpremul` which retain the full benefit. Change-Id: I7fbb725e65db021b9795c04c816819669815578f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345167 Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
2020-12-17 19:38:56 +00:00
%205 = OpLabel
Deduplicate vector constants in SPIR-V output. Many of our shaders generate the same vector constant dozens of times, e.g. Gaussian blur uses float4(1) repeatedly. This change avoids re-emitting redundant vector constants. Change-Id: I22a71cd8b2783fb997f52d485b49031f64ca6d96 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/350701 Auto-Submit: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2021-01-06 18:33:31 +00:00
%209 = OpPhi %bool %false %95 %208 %204
OpSelectionMerge %211 None
OpBranchConditional %209 %210 %211
%210 = OpLabel
%212 = OpLoad %float %_7_lum
%213 = OpLoad %v3float %_8_result
%214 = OpLoad %float %_7_lum
%215 = OpCompositeConstruct %v3float %214 %214 %214
%216 = OpFSub %v3float %213 %215
%217 = OpLoad %float %_7_lum
%218 = OpVectorTimesScalar %v3float %216 %217
%219 = OpLoad %float %_7_lum
%220 = OpLoad %float %_9_minComp
%221 = OpFSub %float %219 %220
%223 = OpFDiv %float %float_1 %221
%224 = OpVectorTimesScalar %v3float %218 %223
%225 = OpCompositeConstruct %v3float %212 %212 %212
%226 = OpFAdd %v3float %225 %224
OpStore %_8_result %226
OpBranch %211
Eliminate inliner temporary variables for top-level-exit functions. When we determine that a function only contains a single return statement and it is at the top level (i.e. not inside any scopes), there is no need to create a temporary variable and store the result expression into a variable. Instead, we can directly replace the function-call expression with the return-statement's expression. Unlike my previous solution, this does not require variable declarations to be rewritten. The no-scopes limitation makes it slightly less effective in theory, but in practice we still get almost all of the benefit. The no-scope limitation bites us on structures like @if (true) { return x; } else { return y; } Which will optimize away the if, but leave the scope: { return x; } However, this is not a big deal; the biggest wins are single-line helper functions like `guarded_divide` and `unpremul` which retain the full benefit. Change-Id: I7fbb725e65db021b9795c04c816819669815578f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345167 Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
2020-12-17 19:38:56 +00:00
%211 = OpLabel
Deduplicate vector constants in SPIR-V output. Many of our shaders generate the same vector constant dozens of times, e.g. Gaussian blur uses float4(1) repeatedly. This change avoids re-emitting redundant vector constants. Change-Id: I22a71cd8b2783fb997f52d485b49031f64ca6d96 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/350701 Auto-Submit: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2021-01-06 18:33:31 +00:00
%227 = OpLoad %float %_10_maxComp
%228 = OpLoad %float %_1_alpha
%229 = OpFOrdGreaterThan %bool %227 %228
OpSelectionMerge %231 None
OpBranchConditional %229 %230 %231
%230 = OpLabel
%232 = OpLoad %float %_10_maxComp
%233 = OpLoad %float %_7_lum
%234 = OpFOrdNotEqual %bool %232 %233
OpBranch %231
Eliminate inliner temporary variables for top-level-exit functions. When we determine that a function only contains a single return statement and it is at the top level (i.e. not inside any scopes), there is no need to create a temporary variable and store the result expression into a variable. Instead, we can directly replace the function-call expression with the return-statement's expression. Unlike my previous solution, this does not require variable declarations to be rewritten. The no-scopes limitation makes it slightly less effective in theory, but in practice we still get almost all of the benefit. The no-scope limitation bites us on structures like @if (true) { return x; } else { return y; } Which will optimize away the if, but leave the scope: { return x; } However, this is not a big deal; the biggest wins are single-line helper functions like `guarded_divide` and `unpremul` which retain the full benefit. Change-Id: I7fbb725e65db021b9795c04c816819669815578f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345167 Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
2020-12-17 19:38:56 +00:00
%231 = OpLabel
Deduplicate vector constants in SPIR-V output. Many of our shaders generate the same vector constant dozens of times, e.g. Gaussian blur uses float4(1) repeatedly. This change avoids re-emitting redundant vector constants. Change-Id: I22a71cd8b2783fb997f52d485b49031f64ca6d96 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/350701 Auto-Submit: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2021-01-06 18:33:31 +00:00
%235 = OpPhi %bool %false %211 %234 %230
OpSelectionMerge %239 None
OpBranchConditional %235 %237 %238
%237 = OpLabel
%240 = OpLoad %float %_7_lum
%241 = OpLoad %v3float %_8_result
%242 = OpLoad %float %_7_lum
%243 = OpCompositeConstruct %v3float %242 %242 %242
%244 = OpFSub %v3float %241 %243
%245 = OpLoad %float %_1_alpha
%246 = OpLoad %float %_7_lum
%247 = OpFSub %float %245 %246
%248 = OpVectorTimesScalar %v3float %244 %247
%249 = OpLoad %float %_10_maxComp
%250 = OpLoad %float %_7_lum
%251 = OpFSub %float %249 %250
%252 = OpFDiv %float %float_1 %251
%253 = OpVectorTimesScalar %v3float %248 %252
%254 = OpCompositeConstruct %v3float %240 %240 %240
%255 = OpFAdd %v3float %254 %253
OpStore %236 %255
OpBranch %239
Eliminate inliner temporary variables for top-level-exit functions. When we determine that a function only contains a single return statement and it is at the top level (i.e. not inside any scopes), there is no need to create a temporary variable and store the result expression into a variable. Instead, we can directly replace the function-call expression with the return-statement's expression. Unlike my previous solution, this does not require variable declarations to be rewritten. The no-scopes limitation makes it slightly less effective in theory, but in practice we still get almost all of the benefit. The no-scope limitation bites us on structures like @if (true) { return x; } else { return y; } Which will optimize away the if, but leave the scope: { return x; } However, this is not a big deal; the biggest wins are single-line helper functions like `guarded_divide` and `unpremul` which retain the full benefit. Change-Id: I7fbb725e65db021b9795c04c816819669815578f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345167 Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
2020-12-17 19:38:56 +00:00
%238 = OpLabel
Deduplicate vector constants in SPIR-V output. Many of our shaders generate the same vector constant dozens of times, e.g. Gaussian blur uses float4(1) repeatedly. This change avoids re-emitting redundant vector constants. Change-Id: I22a71cd8b2783fb997f52d485b49031f64ca6d96 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/350701 Auto-Submit: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2021-01-06 18:33:31 +00:00
%256 = OpLoad %v3float %_8_result
OpStore %236 %256
OpBranch %239
Eliminate inliner temporary variables for top-level-exit functions. When we determine that a function only contains a single return statement and it is at the top level (i.e. not inside any scopes), there is no need to create a temporary variable and store the result expression into a variable. Instead, we can directly replace the function-call expression with the return-statement's expression. Unlike my previous solution, this does not require variable declarations to be rewritten. The no-scopes limitation makes it slightly less effective in theory, but in practice we still get almost all of the benefit. The no-scope limitation bites us on structures like @if (true) { return x; } else { return y; } Which will optimize away the if, but leave the scope: { return x; } However, this is not a big deal; the biggest wins are single-line helper functions like `guarded_divide` and `unpremul` which retain the full benefit. Change-Id: I7fbb725e65db021b9795c04c816819669815578f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/345167 Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
2020-12-17 19:38:56 +00:00
%239 = OpLabel
Deduplicate vector constants in SPIR-V output. Many of our shaders generate the same vector constant dozens of times, e.g. Gaussian blur uses float4(1) repeatedly. This change avoids re-emitting redundant vector constants. Change-Id: I22a71cd8b2783fb997f52d485b49031f64ca6d96 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/350701 Auto-Submit: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2021-01-06 18:33:31 +00:00
%257 = OpLoad %v3float %236
%258 = OpLoad %v4float %dst
%259 = OpVectorShuffle %v3float %258 %258 0 1 2
%260 = OpFAdd %v3float %257 %259
%261 = OpLoad %v3float %_3_dsa
%262 = OpFSub %v3float %260 %261
%263 = OpLoad %v4float %src
%264 = OpVectorShuffle %v3float %263 %263 0 1 2
%265 = OpFAdd %v3float %262 %264
%266 = OpLoad %v3float %_2_sda
%267 = OpFSub %v3float %265 %266
%268 = OpCompositeExtract %float %267 0
%269 = OpCompositeExtract %float %267 1
%270 = OpCompositeExtract %float %267 2
%271 = OpLoad %v4float %src
%272 = OpCompositeExtract %float %271 3
%273 = OpLoad %v4float %dst
%274 = OpCompositeExtract %float %273 3
%275 = OpFAdd %float %272 %274
%276 = OpLoad %float %_1_alpha
%277 = OpFSub %float %275 %276
%278 = OpCompositeConstruct %v4float %268 %269 %270 %277
OpStore %sk_FragColor %278
Enable SPIR-V disassembly output from skslc. We now have SPIR-V golden outputs for `blend` and `shared` tests. This exposes a handful of SPIR-V limitations for us to address. Change-Id: Ie5278889b8a61432403d06231b17765885bee0ac Bug: skia:10694 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/337182 Commit-Queue: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2020-11-20 21:28:50 +00:00
OpReturn
OpFunctionEnd
Reference in New Issue Copy Permalink