skia2/resources/sksl/inliner/InlinerAvoidsVariableNameOverlap.sksl

inline half2 InlineB(half2 tmp)
{
    half2 reusedName = tmp - 1;
    return reusedName;
}

inline half2 InlineA()
{
    half2 reusedName = half2(1, 2);
    return InlineB(reusedName);
}

half4 main()
{
    return InlineA().xyxy;
}
Demonstrate name reuse error in inliner. The following conditions lead to the error: - A pair of nested functions, both of which must be inlined. - Both inlined functions create a variable with the same name. - The outer function passes its variable to the inner function. - The initialization of the inner variable uses the value from the outer variable. - The inner function does not mutate the variable, use it as an out- parameter, or otherwise cause it to receive a temporary copy. When all these conditions are met, both variable declarations are inlined as-is without performing any name salting, because it's seemingly safe to do so. The name overlap issue is not considered in the safety checks. Inlined variable declarations are not subject to name salting but they should be; I suspect other adversarial examples could be crafted as well where unhandled name overlap leads to errors. Change-Id: Ia754bee8e45c8a5c7548436594bbf04abc7a8396 Bug: skia:10722 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/316945 Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Auto-Submit: John Stiles <johnstiles@google.com> 2020-09-14 22:23:54 +00:00			`inline half2 InlineB(half2 tmp)`
			`{`
Run SkSL inliner tests as part of dm. Previously, these tests were never actually executed, only read during code review. They are now properly tested for correctness whenever dm is run. Non-ES2 compliant statements (do/while/switch) are unfortunately excluded here, as they are not compatible with Runtime Effects yet. Change-Id: I965c782baad6f8dd3961a400ae791fb2c1f844d3 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/389296 Auto-Submit: John Stiles <johnstiles@google.com> Commit-Queue: Ethan Nicholas <ethannicholas@google.com> Reviewed-by: Ethan Nicholas <ethannicholas@google.com> 2021-03-25 21:04:36 +00:00			`half2 reusedName = tmp - 1;`
Demonstrate name reuse error in inliner. The following conditions lead to the error: - A pair of nested functions, both of which must be inlined. - Both inlined functions create a variable with the same name. - The outer function passes its variable to the inner function. - The initialization of the inner variable uses the value from the outer variable. - The inner function does not mutate the variable, use it as an out- parameter, or otherwise cause it to receive a temporary copy. When all these conditions are met, both variable declarations are inlined as-is without performing any name salting, because it's seemingly safe to do so. The name overlap issue is not considered in the safety checks. Inlined variable declarations are not subject to name salting but they should be; I suspect other adversarial examples could be crafted as well where unhandled name overlap leads to errors. Change-Id: Ia754bee8e45c8a5c7548436594bbf04abc7a8396 Bug: skia:10722 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/316945 Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Auto-Submit: John Stiles <johnstiles@google.com> 2020-09-14 22:23:54 +00:00			`return reusedName;`
			`}`
Migrate SkSL inliner tests to golden files. Our lack of proper caps-bits controls in skslc affects the outcome of one test: "InlinerWrapsEarlyReturnsWithDoWhileBlock" does not actually emit the do-while block because the standalone caps bits don't enable do-while support. This will be fixed in a followup CL that adds caps-bit support to our tests. A few tests were renamed for consistency, a few were simplified slightly and one test was removed because it was simply redundant (there was a second test that covered the exact same ground as `ForWithReturnInsideCannotBeInlined`). Change-Id: I2e3b97cb3aea331b6d806bdb865aa78c35c7a6b9 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/316997 Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: John Stiles <johnstiles@google.com> 2020-09-15 14:10:43 +00:00
Demonstrate name reuse error in inliner. The following conditions lead to the error: - A pair of nested functions, both of which must be inlined. - Both inlined functions create a variable with the same name. - The outer function passes its variable to the inner function. - The initialization of the inner variable uses the value from the outer variable. - The inner function does not mutate the variable, use it as an out- parameter, or otherwise cause it to receive a temporary copy. When all these conditions are met, both variable declarations are inlined as-is without performing any name salting, because it's seemingly safe to do so. The name overlap issue is not considered in the safety checks. Inlined variable declarations are not subject to name salting but they should be; I suspect other adversarial examples could be crafted as well where unhandled name overlap leads to errors. Change-Id: Ia754bee8e45c8a5c7548436594bbf04abc7a8396 Bug: skia:10722 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/316945 Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Auto-Submit: John Stiles <johnstiles@google.com> 2020-09-14 22:23:54 +00:00			`inline half2 InlineA()`
			`{`
Run SkSL inliner tests as part of dm. Previously, these tests were never actually executed, only read during code review. They are now properly tested for correctness whenever dm is run. Non-ES2 compliant statements (do/while/switch) are unfortunately excluded here, as they are not compatible with Runtime Effects yet. Change-Id: I965c782baad6f8dd3961a400ae791fb2c1f844d3 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/389296 Auto-Submit: John Stiles <johnstiles@google.com> Commit-Queue: Ethan Nicholas <ethannicholas@google.com> Reviewed-by: Ethan Nicholas <ethannicholas@google.com> 2021-03-25 21:04:36 +00:00			`half2 reusedName = half2(1, 2);`
Demonstrate name reuse error in inliner. The following conditions lead to the error: - A pair of nested functions, both of which must be inlined. - Both inlined functions create a variable with the same name. - The outer function passes its variable to the inner function. - The initialization of the inner variable uses the value from the outer variable. - The inner function does not mutate the variable, use it as an out- parameter, or otherwise cause it to receive a temporary copy. When all these conditions are met, both variable declarations are inlined as-is without performing any name salting, because it's seemingly safe to do so. The name overlap issue is not considered in the safety checks. Inlined variable declarations are not subject to name salting but they should be; I suspect other adversarial examples could be crafted as well where unhandled name overlap leads to errors. Change-Id: Ia754bee8e45c8a5c7548436594bbf04abc7a8396 Bug: skia:10722 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/316945 Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Auto-Submit: John Stiles <johnstiles@google.com> 2020-09-14 22:23:54 +00:00			`return InlineB(reusedName);`
			`}`
Migrate SkSL inliner tests to golden files. Our lack of proper caps-bits controls in skslc affects the outcome of one test: "InlinerWrapsEarlyReturnsWithDoWhileBlock" does not actually emit the do-while block because the standalone caps bits don't enable do-while support. This will be fixed in a followup CL that adds caps-bit support to our tests. A few tests were renamed for consistency, a few were simplified slightly and one test was removed because it was simply redundant (there was a second test that covered the exact same ground as `ForWithReturnInsideCannotBeInlined`). Change-Id: I2e3b97cb3aea331b6d806bdb865aa78c35c7a6b9 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/316997 Auto-Submit: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: John Stiles <johnstiles@google.com> 2020-09-15 14:10:43 +00:00
Demonstrate name reuse error in inliner. The following conditions lead to the error: - A pair of nested functions, both of which must be inlined. - Both inlined functions create a variable with the same name. - The outer function passes its variable to the inner function. - The initialization of the inner variable uses the value from the outer variable. - The inner function does not mutate the variable, use it as an out- parameter, or otherwise cause it to receive a temporary copy. When all these conditions are met, both variable declarations are inlined as-is without performing any name salting, because it's seemingly safe to do so. The name overlap issue is not considered in the safety checks. Inlined variable declarations are not subject to name salting but they should be; I suspect other adversarial examples could be crafted as well where unhandled name overlap leads to errors. Change-Id: Ia754bee8e45c8a5c7548436594bbf04abc7a8396 Bug: skia:10722 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/316945 Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: Brian Osman <brianosman@google.com> Auto-Submit: John Stiles <johnstiles@google.com> 2020-09-14 22:23:54 +00:00			`half4 main()`
			`{`
			`return InlineA().xyxy;`
			`}`