AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
2f13b32f79
skia2/tests/sksl/shared/InoutParameters.asm.frag

136 lines
4.6 KiB
GLSL
Raw Normal View History

Fix up test SkSLInlineWithInoutArgument. The test has been moved to shared/, since it's a valid test, but it is no longer related to inlining, as the inliner no longer attempts to inline functions with inouts at all. Also, one function here (outParameterIgnore) actually invoked undefined behavior and has been removed. According to the GLSL ES2 docs: "If a function does not write to an out parameter, the value of the actual parameter is undefined when the function returns." SkVM leaves the value unchanged, so SKSL_TEST_CPU would pass, but a GPU might clear it (and in fact, my GPU does). Change-Id: I77c77ed1354bc980344ec5c406992bd62015f5e5 Bug: skia:11919 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/499752 Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com>
2022-01-25 20:54:24 +00:00
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %_entrypoint_v "_entrypoint" %sk_FragColor %sk_Clockwise
OpExecutionMode %_entrypoint_v OriginUpperLeft
OpName %sk_FragColor "sk_FragColor"
OpName %sk_Clockwise "sk_Clockwise"
OpName %_UniformBuffer "_UniformBuffer"
OpMemberName %_UniformBuffer 0 "colorGreen"
OpName %_entrypoint_v "_entrypoint_v"
OpName %outParameterWrite_vh4 "outParameterWrite_vh4"
OpName %outParameterWriteIndirect_vh4 "outParameterWriteIndirect_vh4"
OpName %inoutParameterWrite_vh4 "inoutParameterWrite_vh4"
OpName %inoutParameterWriteIndirect_vh4 "inoutParameterWriteIndirect_vh4"
OpName %main "main"
OpName %c "c"
OpDecorate %sk_FragColor RelaxedPrecision
OpDecorate %sk_FragColor Location 0
OpDecorate %sk_FragColor Index 0
OpDecorate %sk_Clockwise BuiltIn FrontFacing
OpMemberDecorate %_UniformBuffer 0 Offset 0
OpMemberDecorate %_UniformBuffer 0 RelaxedPrecision
OpDecorate %_UniformBuffer Block
OpDecorate %14 Binding 0
OpDecorate %14 DescriptorSet 0
OpDecorate %35 RelaxedPrecision
Update out-param semantics in SPIR-V. Removed a special case from `writeFunctionCallArgument` which avoided using a scratch variable for out params; now we always use the scratch variable and copy it back to the original variable at the end. Change-Id: I0e446a3fde6d19554943384210bd911f6f9c8cfa Bug: skia:11052, skia:11919, skia:12858 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/501836 Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2022-01-28 20:09:20 +00:00
OpDecorate %38 RelaxedPrecision
OpDecorate %40 RelaxedPrecision
Fix up test SkSLInlineWithInoutArgument. The test has been moved to shared/, since it's a valid test, but it is no longer related to inlining, as the inliner no longer attempts to inline functions with inouts at all. Also, one function here (outParameterIgnore) actually invoked undefined behavior and has been removed. According to the GLSL ES2 docs: "If a function does not write to an out parameter, the value of the actual parameter is undefined when the function returns." SkVM leaves the value unchanged, so SKSL_TEST_CPU would pass, but a GPU might clear it (and in fact, my GPU does). Change-Id: I77c77ed1354bc980344ec5c406992bd62015f5e5 Bug: skia:11919 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/499752 Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com>
2022-01-25 20:54:24 +00:00
OpDecorate %43 RelaxedPrecision
Update out-param semantics in SPIR-V. Removed a special case from `writeFunctionCallArgument` which avoided using a scratch variable for out params; now we always use the scratch variable and copy it back to the original variable at the end. Change-Id: I0e446a3fde6d19554943384210bd911f6f9c8cfa Bug: skia:11052, skia:11919, skia:12858 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/501836 Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2022-01-28 20:09:20 +00:00
OpDecorate %44 RelaxedPrecision
OpDecorate %45 RelaxedPrecision
OpDecorate %48 RelaxedPrecision
OpDecorate %49 RelaxedPrecision
OpDecorate %51 RelaxedPrecision
Fix up test SkSLInlineWithInoutArgument. The test has been moved to shared/, since it's a valid test, but it is no longer related to inlining, as the inliner no longer attempts to inline functions with inouts at all. Also, one function here (outParameterIgnore) actually invoked undefined behavior and has been removed. According to the GLSL ES2 docs: "If a function does not write to an out parameter, the value of the actual parameter is undefined when the function returns." SkVM leaves the value unchanged, so SKSL_TEST_CPU would pass, but a GPU might clear it (and in fact, my GPU does). Change-Id: I77c77ed1354bc980344ec5c406992bd62015f5e5 Bug: skia:11919 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/499752 Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com>
2022-01-25 20:54:24 +00:00
OpDecorate %c RelaxedPrecision
OpDecorate %56 RelaxedPrecision
Update out-param semantics in SPIR-V. Removed a special case from `writeFunctionCallArgument` which avoided using a scratch variable for out params; now we always use the scratch variable and copy it back to the original variable at the end. Change-Id: I0e446a3fde6d19554943384210bd911f6f9c8cfa Bug: skia:11052, skia:11919, skia:12858 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/501836 Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2022-01-28 20:09:20 +00:00
OpDecorate %58 RelaxedPrecision
OpDecorate %59 RelaxedPrecision
OpDecorate %61 RelaxedPrecision
OpDecorate %62 RelaxedPrecision
Eliminate redundant loads following stores. We now have two functions `writeOpLoad` and `writeOpStore` which are in charge of writing SpvOpLoad and SpvOpStore instructions. `writeOpStore` also keeps track of pointer stores in a "store cache." Subsequent loads from that same pointer will be found in the cache and will return the value stored in that pointer instead. Such a cache definitely cannot work in the face of control flow, so we make the following concessions: - `pruneReachableOps` is now `pruneConditionalOps`. Any pointers that are altered inside a potentially-unreachable block are cleared from the cache entirely. - The entire store cache is cleared at all OpLabels within a loop. The cache also cannot work in the presence of swizzled stores, so we make another significant concession: - The entire store cache is cleared whenever we store into a non-memory pointer (e.g., assigning into a swizzled LValue, such as `foo.xz`). Despite these significant limitations, this manages to dramatically shrink many real-world examples. Change-Id: I0981a0cf7b45b064e153e9ada271494c8e00cad5 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/530054 Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com>
2022-04-18 14:57:14 +00:00
OpDecorate %64 RelaxedPrecision
Update out-param semantics in SPIR-V. Removed a special case from `writeFunctionCallArgument` which avoided using a scratch variable for out params; now we always use the scratch variable and copy it back to the original variable at the end. Change-Id: I0e446a3fde6d19554943384210bd911f6f9c8cfa Bug: skia:11052, skia:11919, skia:12858 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/501836 Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2022-01-28 20:09:20 +00:00
OpDecorate %65 RelaxedPrecision
OpDecorate %67 RelaxedPrecision
Fix up test SkSLInlineWithInoutArgument. The test has been moved to shared/, since it's a valid test, but it is no longer related to inlining, as the inliner no longer attempts to inline functions with inouts at all. Also, one function here (outParameterIgnore) actually invoked undefined behavior and has been removed. According to the GLSL ES2 docs: "If a function does not write to an out parameter, the value of the actual parameter is undefined when the function returns." SkVM leaves the value unchanged, so SKSL_TEST_CPU would pass, but a GPU might clear it (and in fact, my GPU does). Change-Id: I77c77ed1354bc980344ec5c406992bd62015f5e5 Bug: skia:11919 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/499752 Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com>
2022-01-25 20:54:24 +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
%_UniformBuffer = OpTypeStruct %v4float
%_ptr_Uniform__UniformBuffer = OpTypePointer Uniform %_UniformBuffer
%14 = OpVariable %_ptr_Uniform__UniformBuffer Uniform
%void = OpTypeVoid
%19 = OpTypeFunction %void
%float_0 = OpConstant %float 0
Replace scalar/vector ID caches with op cache. The output changes here are almost entirely a wash, because we already had support for caching scalars and vectors. Almost all changes are just inconsequential reorderings of IDs, and the removal of RelaxedPrecision decorators on constants (which were not meaningful). Change-Id: I45340c4a240cb504b7c4a934b3db178d2f39ec99 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/528709 Reviewed-by: Arman Uguray <armansito@google.com> Commit-Queue: John Stiles <johnstiles@google.com>
2022-04-12 21:02:43 +00:00
%v2float = OpTypeVector %float 2
Fix up test SkSLInlineWithInoutArgument. The test has been moved to shared/, since it's a valid test, but it is no longer related to inlining, as the inliner no longer attempts to inline functions with inouts at all. Also, one function here (outParameterIgnore) actually invoked undefined behavior and has been removed. According to the GLSL ES2 docs: "If a function does not write to an out parameter, the value of the actual parameter is undefined when the function returns." SkVM leaves the value unchanged, so SKSL_TEST_CPU would pass, but a GPU might clear it (and in fact, my GPU does). Change-Id: I77c77ed1354bc980344ec5c406992bd62015f5e5 Bug: skia:11919 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/499752 Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com>
2022-01-25 20:54:24 +00:00
%23 = OpConstantComposite %v2float %float_0 %float_0
%_ptr_Function_v2float = OpTypePointer Function %v2float
%_ptr_Function_v4float = OpTypePointer Function %v4float
Use op cache for pointer and function types. Previously, we stringized the types and put them into fTypeMap. Using the op cache is a simpler mechanism that should work equally well. Output diffs are almost all ID reorderings. In a few cases we managed to deduplicate function types that stringize differently but come out the same in SPIR-V (e.g. no float/half distinction). Change-Id: If7de5b2dafa12d05c3c2c497a243e9e3908dfee7 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/529805 Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2022-04-13 18:37:36 +00:00
%28 = OpTypeFunction %void %_ptr_Function_v4float
Fix up test SkSLInlineWithInoutArgument. The test has been moved to shared/, since it's a valid test, but it is no longer related to inlining, as the inliner no longer attempts to inline functions with inouts at all. Also, one function here (outParameterIgnore) actually invoked undefined behavior and has been removed. According to the GLSL ES2 docs: "If a function does not write to an out parameter, the value of the actual parameter is undefined when the function returns." SkVM leaves the value unchanged, so SKSL_TEST_CPU would pass, but a GPU might clear it (and in fact, my GPU does). Change-Id: I77c77ed1354bc980344ec5c406992bd62015f5e5 Bug: skia:11919 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/499752 Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com>
2022-01-25 20:54:24 +00:00
%_ptr_Uniform_v4float = OpTypePointer Uniform %v4float
%int = OpTypeInt 32 1
%int_0 = OpConstant %int 0
Update out-param semantics in SPIR-V. Removed a special case from `writeFunctionCallArgument` which avoided using a scratch variable for out params; now we always use the scratch variable and copy it back to the original variable at the end. Change-Id: I0e446a3fde6d19554943384210bd911f6f9c8cfa Bug: skia:11052, skia:11919, skia:12858 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/501836 Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2022-01-28 20:09:20 +00:00
%52 = OpTypeFunction %v4float %_ptr_Function_v2float
Fix up test SkSLInlineWithInoutArgument. The test has been moved to shared/, since it's a valid test, but it is no longer related to inlining, as the inliner no longer attempts to inline functions with inouts at all. Also, one function here (outParameterIgnore) actually invoked undefined behavior and has been removed. According to the GLSL ES2 docs: "If a function does not write to an out parameter, the value of the actual parameter is undefined when the function returns." SkVM leaves the value unchanged, so SKSL_TEST_CPU would pass, but a GPU might clear it (and in fact, my GPU does). Change-Id: I77c77ed1354bc980344ec5c406992bd62015f5e5 Bug: skia:11919 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/499752 Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com>
2022-01-25 20:54:24 +00:00
%false = OpConstantFalse %bool
%_entrypoint_v = OpFunction %void None %19
%20 = OpLabel
%24 = OpVariable %_ptr_Function_v2float Function
OpStore %24 %23
%26 = OpFunctionCall %v4float %main %24
OpStore %sk_FragColor %26
OpReturn
OpFunctionEnd
Use op cache for pointer and function types. Previously, we stringized the types and put them into fTypeMap. Using the op cache is a simpler mechanism that should work equally well. Output diffs are almost all ID reorderings. In a few cases we managed to deduplicate function types that stringize differently but come out the same in SPIR-V (e.g. no float/half distinction). Change-Id: If7de5b2dafa12d05c3c2c497a243e9e3908dfee7 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/529805 Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2022-04-13 18:37:36 +00:00
%outParameterWrite_vh4 = OpFunction %void None %28
Fix up test SkSLInlineWithInoutArgument. The test has been moved to shared/, since it's a valid test, but it is no longer related to inlining, as the inliner no longer attempts to inline functions with inouts at all. Also, one function here (outParameterIgnore) actually invoked undefined behavior and has been removed. According to the GLSL ES2 docs: "If a function does not write to an out parameter, the value of the actual parameter is undefined when the function returns." SkVM leaves the value unchanged, so SKSL_TEST_CPU would pass, but a GPU might clear it (and in fact, my GPU does). Change-Id: I77c77ed1354bc980344ec5c406992bd62015f5e5 Bug: skia:11919 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/499752 Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com>
2022-01-25 20:54:24 +00:00
%29 = OpFunctionParameter %_ptr_Function_v4float
%30 = OpLabel
%31 = OpAccessChain %_ptr_Uniform_v4float %14 %int_0
%35 = OpLoad %v4float %31
OpStore %29 %35
OpReturn
OpFunctionEnd
Use op cache for pointer and function types. Previously, we stringized the types and put them into fTypeMap. Using the op cache is a simpler mechanism that should work equally well. Output diffs are almost all ID reorderings. In a few cases we managed to deduplicate function types that stringize differently but come out the same in SPIR-V (e.g. no float/half distinction). Change-Id: If7de5b2dafa12d05c3c2c497a243e9e3908dfee7 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/529805 Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2022-04-13 18:37:36 +00:00
%outParameterWriteIndirect_vh4 = OpFunction %void None %28
Fix up test SkSLInlineWithInoutArgument. The test has been moved to shared/, since it's a valid test, but it is no longer related to inlining, as the inliner no longer attempts to inline functions with inouts at all. Also, one function here (outParameterIgnore) actually invoked undefined behavior and has been removed. According to the GLSL ES2 docs: "If a function does not write to an out parameter, the value of the actual parameter is undefined when the function returns." SkVM leaves the value unchanged, so SKSL_TEST_CPU would pass, but a GPU might clear it (and in fact, my GPU does). Change-Id: I77c77ed1354bc980344ec5c406992bd62015f5e5 Bug: skia:11919 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/499752 Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com>
2022-01-25 20:54:24 +00:00
%36 = OpFunctionParameter %_ptr_Function_v4float
%37 = OpLabel
Update out-param semantics in SPIR-V. Removed a special case from `writeFunctionCallArgument` which avoided using a scratch variable for out params; now we always use the scratch variable and copy it back to the original variable at the end. Change-Id: I0e446a3fde6d19554943384210bd911f6f9c8cfa Bug: skia:11052, skia:11919, skia:12858 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/501836 Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2022-01-28 20:09:20 +00:00
%38 = OpVariable %_ptr_Function_v4float Function
%39 = OpFunctionCall %void %outParameterWrite_vh4 %38
%40 = OpLoad %v4float %38
OpStore %36 %40
Fix up test SkSLInlineWithInoutArgument. The test has been moved to shared/, since it's a valid test, but it is no longer related to inlining, as the inliner no longer attempts to inline functions with inouts at all. Also, one function here (outParameterIgnore) actually invoked undefined behavior and has been removed. According to the GLSL ES2 docs: "If a function does not write to an out parameter, the value of the actual parameter is undefined when the function returns." SkVM leaves the value unchanged, so SKSL_TEST_CPU would pass, but a GPU might clear it (and in fact, my GPU does). Change-Id: I77c77ed1354bc980344ec5c406992bd62015f5e5 Bug: skia:11919 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/499752 Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com>
2022-01-25 20:54:24 +00:00
OpReturn
OpFunctionEnd
Use op cache for pointer and function types. Previously, we stringized the types and put them into fTypeMap. Using the op cache is a simpler mechanism that should work equally well. Output diffs are almost all ID reorderings. In a few cases we managed to deduplicate function types that stringize differently but come out the same in SPIR-V (e.g. no float/half distinction). Change-Id: If7de5b2dafa12d05c3c2c497a243e9e3908dfee7 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/529805 Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2022-04-13 18:37:36 +00:00
%inoutParameterWrite_vh4 = OpFunction %void None %28
Update out-param semantics in SPIR-V. Removed a special case from `writeFunctionCallArgument` which avoided using a scratch variable for out params; now we always use the scratch variable and copy it back to the original variable at the end. Change-Id: I0e446a3fde6d19554943384210bd911f6f9c8cfa Bug: skia:11052, skia:11919, skia:12858 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/501836 Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2022-01-28 20:09:20 +00:00
%41 = OpFunctionParameter %_ptr_Function_v4float
%42 = OpLabel
%43 = OpLoad %v4float %41
%44 = OpLoad %v4float %41
%45 = OpFMul %v4float %43 %44
OpStore %41 %45
Fix up test SkSLInlineWithInoutArgument. The test has been moved to shared/, since it's a valid test, but it is no longer related to inlining, as the inliner no longer attempts to inline functions with inouts at all. Also, one function here (outParameterIgnore) actually invoked undefined behavior and has been removed. According to the GLSL ES2 docs: "If a function does not write to an out parameter, the value of the actual parameter is undefined when the function returns." SkVM leaves the value unchanged, so SKSL_TEST_CPU would pass, but a GPU might clear it (and in fact, my GPU does). Change-Id: I77c77ed1354bc980344ec5c406992bd62015f5e5 Bug: skia:11919 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/499752 Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com>
2022-01-25 20:54:24 +00:00
OpReturn
OpFunctionEnd
Use op cache for pointer and function types. Previously, we stringized the types and put them into fTypeMap. Using the op cache is a simpler mechanism that should work equally well. Output diffs are almost all ID reorderings. In a few cases we managed to deduplicate function types that stringize differently but come out the same in SPIR-V (e.g. no float/half distinction). Change-Id: If7de5b2dafa12d05c3c2c497a243e9e3908dfee7 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/529805 Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2022-04-13 18:37:36 +00:00
%inoutParameterWriteIndirect_vh4 = OpFunction %void None %28
Update out-param semantics in SPIR-V. Removed a special case from `writeFunctionCallArgument` which avoided using a scratch variable for out params; now we always use the scratch variable and copy it back to the original variable at the end. Change-Id: I0e446a3fde6d19554943384210bd911f6f9c8cfa Bug: skia:11052, skia:11919, skia:12858 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/501836 Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2022-01-28 20:09:20 +00:00
%46 = OpFunctionParameter %_ptr_Function_v4float
%47 = OpLabel
%49 = OpVariable %_ptr_Function_v4float Function
%48 = OpLoad %v4float %46
OpStore %49 %48
%50 = OpFunctionCall %void %inoutParameterWrite_vh4 %49
%51 = OpLoad %v4float %49
OpStore %46 %51
Fix up test SkSLInlineWithInoutArgument. The test has been moved to shared/, since it's a valid test, but it is no longer related to inlining, as the inliner no longer attempts to inline functions with inouts at all. Also, one function here (outParameterIgnore) actually invoked undefined behavior and has been removed. According to the GLSL ES2 docs: "If a function does not write to an out parameter, the value of the actual parameter is undefined when the function returns." SkVM leaves the value unchanged, so SKSL_TEST_CPU would pass, but a GPU might clear it (and in fact, my GPU does). Change-Id: I77c77ed1354bc980344ec5c406992bd62015f5e5 Bug: skia:11919 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/499752 Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com>
2022-01-25 20:54:24 +00:00
OpReturn
OpFunctionEnd
Update out-param semantics in SPIR-V. Removed a special case from `writeFunctionCallArgument` which avoided using a scratch variable for out params; now we always use the scratch variable and copy it back to the original variable at the end. Change-Id: I0e446a3fde6d19554943384210bd911f6f9c8cfa Bug: skia:11052, skia:11919, skia:12858 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/501836 Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2022-01-28 20:09:20 +00:00
%main = OpFunction %v4float None %52
%53 = OpFunctionParameter %_ptr_Function_v2float
%54 = OpLabel
Fix up test SkSLInlineWithInoutArgument. The test has been moved to shared/, since it's a valid test, but it is no longer related to inlining, as the inliner no longer attempts to inline functions with inouts at all. Also, one function here (outParameterIgnore) actually invoked undefined behavior and has been removed. According to the GLSL ES2 docs: "If a function does not write to an out parameter, the value of the actual parameter is undefined when the function returns." SkVM leaves the value unchanged, so SKSL_TEST_CPU would pass, but a GPU might clear it (and in fact, my GPU does). Change-Id: I77c77ed1354bc980344ec5c406992bd62015f5e5 Bug: skia:11919 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/499752 Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com>
2022-01-25 20:54:24 +00:00
%c = OpVariable %_ptr_Function_v4float Function
Update out-param semantics in SPIR-V. Removed a special case from `writeFunctionCallArgument` which avoided using a scratch variable for out params; now we always use the scratch variable and copy it back to the original variable at the end. Change-Id: I0e446a3fde6d19554943384210bd911f6f9c8cfa Bug: skia:11052, skia:11919, skia:12858 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/501836 Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2022-01-28 20:09:20 +00:00
%56 = OpVariable %_ptr_Function_v4float Function
%59 = OpVariable %_ptr_Function_v4float Function
Eliminate redundant loads following stores. We now have two functions `writeOpLoad` and `writeOpStore` which are in charge of writing SpvOpLoad and SpvOpStore instructions. `writeOpStore` also keeps track of pointer stores in a "store cache." Subsequent loads from that same pointer will be found in the cache and will return the value stored in that pointer instead. Such a cache definitely cannot work in the face of control flow, so we make the following concessions: - `pruneReachableOps` is now `pruneConditionalOps`. Any pointers that are altered inside a potentially-unreachable block are cleared from the cache entirely. - The entire store cache is cleared at all OpLabels within a loop. The cache also cannot work in the presence of swizzled stores, so we make another significant concession: - The entire store cache is cleared whenever we store into a non-memory pointer (e.g., assigning into a swizzled LValue, such as `foo.xz`). Despite these significant limitations, this manages to dramatically shrink many real-world examples. Change-Id: I0981a0cf7b45b064e153e9ada271494c8e00cad5 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/530054 Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com>
2022-04-18 14:57:14 +00:00
%62 = OpVariable %_ptr_Function_v4float Function
%65 = OpVariable %_ptr_Function_v4float Function
Update out-param semantics in SPIR-V. Removed a special case from `writeFunctionCallArgument` which avoided using a scratch variable for out params; now we always use the scratch variable and copy it back to the original variable at the end. Change-Id: I0e446a3fde6d19554943384210bd911f6f9c8cfa Bug: skia:11052, skia:11919, skia:12858 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/501836 Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2022-01-28 20:09:20 +00:00
%57 = OpFunctionCall %void %outParameterWrite_vh4 %56
%58 = OpLoad %v4float %56
OpStore %c %58
%60 = OpFunctionCall %void %outParameterWriteIndirect_vh4 %59
%61 = OpLoad %v4float %59
OpStore %c %61
Eliminate redundant loads following stores. We now have two functions `writeOpLoad` and `writeOpStore` which are in charge of writing SpvOpLoad and SpvOpStore instructions. `writeOpStore` also keeps track of pointer stores in a "store cache." Subsequent loads from that same pointer will be found in the cache and will return the value stored in that pointer instead. Such a cache definitely cannot work in the face of control flow, so we make the following concessions: - `pruneReachableOps` is now `pruneConditionalOps`. Any pointers that are altered inside a potentially-unreachable block are cleared from the cache entirely. - The entire store cache is cleared at all OpLabels within a loop. The cache also cannot work in the presence of swizzled stores, so we make another significant concession: - The entire store cache is cleared whenever we store into a non-memory pointer (e.g., assigning into a swizzled LValue, such as `foo.xz`). Despite these significant limitations, this manages to dramatically shrink many real-world examples. Change-Id: I0981a0cf7b45b064e153e9ada271494c8e00cad5 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/530054 Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com>
2022-04-18 14:57:14 +00:00
OpStore %62 %61
%63 = OpFunctionCall %void %inoutParameterWrite_vh4 %62
%64 = OpLoad %v4float %62
OpStore %c %64
OpStore %65 %64
%66 = OpFunctionCall %void %inoutParameterWriteIndirect_vh4 %65
%67 = OpLoad %v4float %65
OpStore %c %67
OpReturnValue %67
Fix up test SkSLInlineWithInoutArgument. The test has been moved to shared/, since it's a valid test, but it is no longer related to inlining, as the inliner no longer attempts to inline functions with inouts at all. Also, one function here (outParameterIgnore) actually invoked undefined behavior and has been removed. According to the GLSL ES2 docs: "If a function does not write to an out parameter, the value of the actual parameter is undefined when the function returns." SkVM leaves the value unchanged, so SKSL_TEST_CPU would pass, but a GPU might clear it (and in fact, my GPU does). Change-Id: I77c77ed1354bc980344ec5c406992bd62015f5e5 Bug: skia:11919 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/499752 Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: John Stiles <johnstiles@google.com> Auto-Submit: John Stiles <johnstiles@google.com>
2022-01-25 20:54:24 +00:00
OpFunctionEnd
Reference in New Issue Copy Permalink