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

497 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"
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
OpName %_19_n "_19_n"
OpName %_20_d "_20_d"
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"
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
OpName %_6_blend_set_color_luminance "_6_blend_set_color_luminance"
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 %_7_lum "_7_lum"
OpName %_8_result "_8_result"
OpName %_9_minComp "_9_minComp"
OpName %_10_maxComp "_10_maxComp"
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
OpName %_11_d "_11_d"
OpName %_12_n "_12_n"
OpName %_13_d "_13_d"
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
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
OpDecorate %30 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 %31 RelaxedPrecision
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
OpDecorate %33 RelaxedPrecision
OpDecorate %35 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 %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 %38 RelaxedPrecision
OpDecorate %40 RelaxedPrecision
OpDecorate %42 RelaxedPrecision
OpDecorate %44 RelaxedPrecision
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
OpDecorate %45 RelaxedPrecision
OpDecorate %46 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
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
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
OpDecorate %62 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
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
OpDecorate %68 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
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
OpDecorate %79 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
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
OpDecorate %89 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 %90 RelaxedPrecision
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
OpDecorate %92 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 %98 RelaxedPrecision
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
OpDecorate %100 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 %106 RelaxedPrecision
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
OpDecorate %108 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 %111 RelaxedPrecision
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
OpDecorate %113 RelaxedPrecision
OpDecorate %119 RelaxedPrecision
OpDecorate %122 RelaxedPrecision
OpDecorate %126 RelaxedPrecision
OpDecorate %129 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
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
OpDecorate %135 RelaxedPrecision
OpDecorate %141 RelaxedPrecision
OpDecorate %144 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
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
OpDecorate %150 RelaxedPrecision
OpDecorate %156 RelaxedPrecision
OpDecorate %159 RelaxedPrecision
OpDecorate %163 RelaxedPrecision
OpDecorate %166 RelaxedPrecision
OpDecorate %177 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
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
OpDecorate %181 RelaxedPrecision
OpDecorate %182 RelaxedPrecision
OpDecorate %183 RelaxedPrecision
OpDecorate %189 RelaxedPrecision
OpDecorate %191 RelaxedPrecision
OpDecorate %193 RelaxedPrecision
OpDecorate %198 RelaxedPrecision
OpDecorate %200 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 %202 RelaxedPrecision
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
OpDecorate %205 RelaxedPrecision
OpDecorate %209 RelaxedPrecision
OpDecorate %210 RelaxedPrecision
OpDecorate %216 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
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
OpDecorate %218 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 %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
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
OpDecorate %224 RelaxedPrecision
OpDecorate %225 RelaxedPrecision
OpDecorate %226 RelaxedPrecision
OpDecorate %230 RelaxedPrecision
OpDecorate %231 RelaxedPrecision
OpDecorate %235 RelaxedPrecision
OpDecorate %236 RelaxedPrecision
OpDecorate %243 RelaxedPrecision
OpDecorate %244 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 %247 RelaxedPrecision
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
OpDecorate %248 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
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
OpDecorate %252 RelaxedPrecision
OpDecorate %253 RelaxedPrecision
OpDecorate %254 RelaxedPrecision
OpDecorate %255 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 %263 RelaxedPrecision
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
OpDecorate %264 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
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
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
OpDecorate %268 RelaxedPrecision
OpDecorate %269 RelaxedPrecision
OpDecorate %270 RelaxedPrecision
OpDecorate %272 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 %273 RelaxedPrecision
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
OpDecorate %274 RelaxedPrecision
OpDecorate %278 RelaxedPrecision
OpDecorate %280 RelaxedPrecision
OpDecorate %282 RelaxedPrecision
OpDecorate %283 RelaxedPrecision
OpDecorate %284 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
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
%49 = OpConstantComposite %v3float %float_0 %float_0 %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
%void = OpTypeVoid
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
%51 = 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
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
%176 = 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
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
%_19_n = OpVariable %_ptr_Function_float Function
%_20_d = OpVariable %_ptr_Function_float Function
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
%21 = OpLoad %v3float %18
%22 = OpCompositeExtract %float %21 0
%23 = OpLoad %v3float %18
%24 = OpCompositeExtract %float %23 2
%25 = OpFOrdLessThan %bool %22 %24
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
OpSelectionMerge %28 None
OpBranchConditional %25 %26 %27
%26 = OpLabel
%30 = OpLoad %float %19
%31 = OpLoad %v3float %18
%32 = OpCompositeExtract %float %31 1
%33 = OpLoad %v3float %18
%34 = OpCompositeExtract %float %33 0
%35 = OpFSub %float %32 %34
%36 = OpFMul %float %30 %35
OpStore %_19_n %36
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
%38 = OpLoad %v3float %18
%39 = OpCompositeExtract %float %38 2
%40 = OpLoad %v3float %18
%41 = OpCompositeExtract %float %40 0
%42 = OpFSub %float %39 %41
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
OpStore %_20_d %42
%44 = OpLoad %float %_19_n
%45 = OpLoad %float %_20_d
%46 = OpFDiv %float %44 %45
%47 = OpLoad %float %19
%48 = OpCompositeConstruct %v3float %float_0 %46 %47
OpReturnValue %48
%27 = OpLabel
OpReturnValue %49
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
%28 = OpLabel
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
OpUnreachable
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
OpFunctionEnd
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
%main = OpFunction %void None %51
%52 = 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
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
%107 = OpVariable %_ptr_Function_v3float Function
%109 = OpVariable %_ptr_Function_float Function
%121 = OpVariable %_ptr_Function_v3float Function
%123 = OpVariable %_ptr_Function_float Function
%128 = OpVariable %_ptr_Function_v3float Function
%130 = OpVariable %_ptr_Function_float Function
%143 = OpVariable %_ptr_Function_v3float Function
%145 = OpVariable %_ptr_Function_float Function
%158 = OpVariable %_ptr_Function_v3float Function
%160 = OpVariable %_ptr_Function_float Function
%165 = OpVariable %_ptr_Function_v3float Function
%167 = OpVariable %_ptr_Function_float Function
%_6_blend_set_color_luminance = 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
%_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
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
%_11_d = OpVariable %_ptr_Function_float Function
%_12_n = OpVariable %_ptr_Function_v3float Function
%_13_d = OpVariable %_ptr_Function_float Function
%54 = OpLoad %v4float %dst
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
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
%56 = OpLoad %v4float %src
%57 = OpCompositeExtract %float %56 3
%58 = OpFMul %float %55 %57
OpStore %_1_alpha %58
%60 = OpLoad %v4float %src
%61 = OpVectorShuffle %v3float %60 %60 0 1 2
%62 = OpLoad %v4float %dst
%63 = OpCompositeExtract %float %62 3
%64 = OpVectorTimesScalar %v3float %61 %63
OpStore %_2_sda %64
%66 = OpLoad %v4float %dst
%67 = OpVectorShuffle %v3float %66 %66 0 1 2
%68 = OpLoad %v4float %src
%69 = OpCompositeExtract %float %68 3
%70 = OpVectorTimesScalar %v3float %67 %69
OpStore %_3_dsa %70
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 %_3_dsa
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
%76 = OpCompositeExtract %float %75 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
%77 = OpLoad %v3float %_3_dsa
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
%78 = OpCompositeExtract %float %77 1
%74 = OpExtInst %float %1 FMax %76 %78
%79 = OpLoad %v3float %_3_dsa
%80 = OpCompositeExtract %float %79 2
%73 = OpExtInst %float %1 FMax %74 %80
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 %_3_dsa
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
%84 = OpCompositeExtract %float %83 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
%85 = OpLoad %v3float %_3_dsa
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
%86 = OpCompositeExtract %float %85 1
%82 = OpExtInst %float %1 FMin %84 %86
%87 = OpLoad %v3float %_3_dsa
%88 = OpCompositeExtract %float %87 2
%81 = OpExtInst %float %1 FMin %82 %88
%89 = OpFSub %float %73 %81
OpStore %_5_sat %89
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
%90 = OpLoad %v3float %_2_sda
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
%91 = OpCompositeExtract %float %90 0
%92 = OpLoad %v3float %_2_sda
%93 = OpCompositeExtract %float %92 1
%94 = OpFOrdLessThanEqual %bool %91 %93
OpSelectionMerge %97 None
OpBranchConditional %94 %95 %96
%95 = OpLabel
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
%98 = OpLoad %v3float %_2_sda
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
%99 = OpCompositeExtract %float %98 1
%100 = OpLoad %v3float %_2_sda
%101 = OpCompositeExtract %float %100 2
%102 = OpFOrdLessThanEqual %bool %99 %101
OpSelectionMerge %105 None
OpBranchConditional %102 %103 %104
%103 = OpLabel
%106 = 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
OpStore %107 %106
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
%108 = OpLoad %float %_5_sat
OpStore %109 %108
%110 = OpFunctionCall %v3float %_blend_set_color_saturation_helper %107 %109
OpStore %_4_blend_set_color_saturation %110
OpBranch %105
%104 = OpLabel
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
%111 = OpLoad %v3float %_2_sda
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
%112 = OpCompositeExtract %float %111 0
%113 = OpLoad %v3float %_2_sda
%114 = OpCompositeExtract %float %113 2
%115 = OpFOrdLessThanEqual %bool %112 %114
OpSelectionMerge %118 None
OpBranchConditional %115 %116 %117
%116 = OpLabel
%119 = OpLoad %v3float %_2_sda
%120 = OpVectorShuffle %v3float %119 %119 0 2 1
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 %121 %120
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
%122 = OpLoad %float %_5_sat
OpStore %123 %122
%124 = OpFunctionCall %v3float %_blend_set_color_saturation_helper %121 %123
%125 = OpVectorShuffle %v3float %124 %124 0 2 1
OpStore %_4_blend_set_color_saturation %125
OpBranch %118
%117 = OpLabel
%126 = OpLoad %v3float %_2_sda
%127 = OpVectorShuffle %v3float %126 %126 2 0 1
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 %128 %127
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
%129 = OpLoad %float %_5_sat
OpStore %130 %129
%131 = OpFunctionCall %v3float %_blend_set_color_saturation_helper %128 %130
%132 = OpVectorShuffle %v3float %131 %131 1 2 0
OpStore %_4_blend_set_color_saturation %132
OpBranch %118
%118 = OpLabel
OpBranch %105
%105 = OpLabel
OpBranch %97
%96 = OpLabel
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
%133 = OpLoad %v3float %_2_sda
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
%134 = OpCompositeExtract %float %133 0
%135 = OpLoad %v3float %_2_sda
%136 = OpCompositeExtract %float %135 2
%137 = OpFOrdLessThanEqual %bool %134 %136
OpSelectionMerge %140 None
OpBranchConditional %137 %138 %139
%138 = OpLabel
%141 = OpLoad %v3float %_2_sda
%142 = OpVectorShuffle %v3float %141 %141 1 0 2
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 %143 %142
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
%144 = OpLoad %float %_5_sat
OpStore %145 %144
%146 = OpFunctionCall %v3float %_blend_set_color_saturation_helper %143 %145
%147 = OpVectorShuffle %v3float %146 %146 1 0 2
OpStore %_4_blend_set_color_saturation %147
OpBranch %140
%139 = OpLabel
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
%148 = OpLoad %v3float %_2_sda
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
%149 = OpCompositeExtract %float %148 1
%150 = OpLoad %v3float %_2_sda
%151 = OpCompositeExtract %float %150 2
%152 = OpFOrdLessThanEqual %bool %149 %151
OpSelectionMerge %155 None
OpBranchConditional %152 %153 %154
%153 = OpLabel
%156 = OpLoad %v3float %_2_sda
%157 = OpVectorShuffle %v3float %156 %156 1 2 0
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 %158 %157
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
%159 = OpLoad %float %_5_sat
OpStore %160 %159
%161 = OpFunctionCall %v3float %_blend_set_color_saturation_helper %158 %160
%162 = OpVectorShuffle %v3float %161 %161 2 0 1
OpStore %_4_blend_set_color_saturation %162
OpBranch %155
%154 = OpLabel
%163 = OpLoad %v3float %_2_sda
%164 = OpVectorShuffle %v3float %163 %163 2 1 0
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 %165 %164
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
%166 = OpLoad %float %_5_sat
OpStore %167 %166
%168 = OpFunctionCall %v3float %_blend_set_color_saturation_helper %165 %167
%169 = OpVectorShuffle %v3float %168 %168 2 1 0
OpStore %_4_blend_set_color_saturation %169
OpBranch %155
%155 = OpLabel
OpBranch %140
%140 = OpLabel
OpBranch %97
%97 = OpLabel
%177 = OpLoad %v3float %_3_dsa
%172 = OpDot %float %176 %177
OpStore %_7_lum %172
%179 = OpLoad %float %_7_lum
%181 = OpLoad %v3float %_4_blend_set_color_saturation
%180 = OpDot %float %176 %181
%182 = OpFSub %float %179 %180
%183 = OpLoad %v3float %_4_blend_set_color_saturation
%184 = OpCompositeConstruct %v3float %182 %182 %182
%185 = OpFAdd %v3float %184 %183
OpStore %_8_result %185
%189 = OpLoad %v3float %_8_result
%190 = OpCompositeExtract %float %189 0
%191 = OpLoad %v3float %_8_result
%192 = OpCompositeExtract %float %191 1
%188 = OpExtInst %float %1 FMin %190 %192
%193 = OpLoad %v3float %_8_result
%194 = OpCompositeExtract %float %193 2
%187 = OpExtInst %float %1 FMin %188 %194
OpStore %_9_minComp %187
%198 = OpLoad %v3float %_8_result
%199 = OpCompositeExtract %float %198 0
%200 = OpLoad %v3float %_8_result
%201 = OpCompositeExtract %float %200 1
%197 = OpExtInst %float %1 FMax %199 %201
%202 = OpLoad %v3float %_8_result
%203 = OpCompositeExtract %float %202 2
%196 = OpExtInst %float %1 FMax %197 %203
OpStore %_10_maxComp %196
%205 = OpLoad %float %_9_minComp
%206 = OpFOrdLessThan %bool %205 %float_0
OpSelectionMerge %208 None
OpBranchConditional %206 %207 %208
%207 = OpLabel
%209 = OpLoad %float %_7_lum
%210 = OpLoad %float %_9_minComp
%211 = OpFOrdNotEqual %bool %209 %210
OpBranch %208
%208 = OpLabel
%212 = OpPhi %bool %false %97 %211 %207
OpSelectionMerge %214 None
OpBranchConditional %212 %213 %214
%213 = OpLabel
%216 = OpLoad %float %_7_lum
%217 = OpLoad %float %_9_minComp
%218 = OpFSub %float %216 %217
OpStore %_11_d %218
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
%219 = OpLoad %float %_7_lum
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
%220 = OpLoad %v3float %_8_result
%221 = OpLoad %float %_7_lum
%222 = OpCompositeConstruct %v3float %221 %221 %221
%223 = OpFSub %v3float %220 %222
%224 = OpLoad %float %_7_lum
%225 = OpLoad %float %_11_d
%226 = OpFDiv %float %224 %225
%227 = OpVectorTimesScalar %v3float %223 %226
%228 = OpCompositeConstruct %v3float %219 %219 %219
%229 = OpFAdd %v3float %228 %227
OpStore %_8_result %229
OpBranch %214
%214 = OpLabel
%230 = OpLoad %float %_10_maxComp
%231 = OpLoad %float %_1_alpha
%232 = OpFOrdGreaterThan %bool %230 %231
OpSelectionMerge %234 None
OpBranchConditional %232 %233 %234
%233 = OpLabel
%235 = OpLoad %float %_10_maxComp
%236 = OpLoad %float %_7_lum
%237 = OpFOrdNotEqual %bool %235 %236
OpBranch %234
%234 = OpLabel
%238 = OpPhi %bool %false %214 %237 %233
OpSelectionMerge %241 None
OpBranchConditional %238 %239 %240
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
Use guarded_divide in more blend functions Fixes another instance of anglebug.com/2098 with advanced blend functions. Change-Id: I91863723d8b4c33ab2f5a527fe0374e8947bba16 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368813 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-02-10 17:03:42 +00:00
%243 = OpLoad %v3float %_8_result
%244 = OpLoad %float %_7_lum
%245 = OpCompositeConstruct %v3float %244 %244 %244
%246 = OpFSub %v3float %243 %245
%247 = OpLoad %float %_1_alpha
%248 = OpLoad %float %_7_lum
%249 = OpFSub %float %247 %248
%250 = OpVectorTimesScalar %v3float %246 %249
OpStore %_12_n %250
%252 = OpLoad %float %_10_maxComp
%253 = OpLoad %float %_7_lum
%254 = OpFSub %float %252 %253
OpStore %_13_d %254
%255 = OpLoad %float %_7_lum
%256 = OpLoad %v3float %_12_n
%257 = OpLoad %float %_13_d
%259 = OpFDiv %float %float_1 %257
%260 = OpVectorTimesScalar %v3float %256 %259
%261 = OpCompositeConstruct %v3float %255 %255 %255
%262 = OpFAdd %v3float %261 %260
OpStore %_6_blend_set_color_luminance %262
OpBranch %241
%240 = OpLabel
%263 = OpLoad %v3float %_8_result
OpStore %_6_blend_set_color_luminance %263
OpBranch %241
%241 = OpLabel
%264 = OpLoad %v3float %_6_blend_set_color_luminance
%265 = OpLoad %v4float %dst
%266 = OpVectorShuffle %v3float %265 %265 0 1 2
%267 = OpFAdd %v3float %264 %266
%268 = OpLoad %v3float %_3_dsa
%269 = OpFSub %v3float %267 %268
%270 = OpLoad %v4float %src
%271 = OpVectorShuffle %v3float %270 %270 0 1 2
%272 = OpFAdd %v3float %269 %271
%273 = OpLoad %v3float %_2_sda
%274 = OpFSub %v3float %272 %273
%275 = OpCompositeExtract %float %274 0
%276 = OpCompositeExtract %float %274 1
%277 = OpCompositeExtract %float %274 2
%278 = OpLoad %v4float %src
%279 = OpCompositeExtract %float %278 3
%280 = OpLoad %v4float %dst
%281 = OpCompositeExtract %float %280 3
%282 = OpFAdd %float %279 %281
%283 = OpLoad %float %_1_alpha
%284 = OpFSub %float %282 %283
%285 = OpCompositeConstruct %v4float %275 %276 %277 %284
OpStore %sk_FragColor %285
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