wine/vkd3d
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/vkd3d.git synced 2024-11-21 16:46:41 -08:00
Code Issues Packages Projects Releases Wiki Activity
52a831ba0d
vkd3d/tests/hlsl/function-return.shader_test

312 lines
4.4 KiB
Plaintext
Raw Normal View History

tests: Add some tests for early return from user-defined functions.
2021-09-11 13:48:02 -07:00
% Test early return from a user-defined function.
vkd3d-shader/hlsl: Inline function calls.
2021-09-11 14:56:04 -07:00
[pixel shader]
tests: Add some tests for early return from user-defined functions.
2021-09-11 13:48:02 -07:00
float func(out float o)
{
o = 0.1;
return 0.2;
o = 0.3;
return 0.4;
}
void func2(out float o)
{
o = 0.5;
return;
o = 0.6;
}
float4 main() : sv_target
{
float4 ret;
ret.z = 0.7;
ret.x = func(ret.y);
func2(ret.w);
ret.z = 0.8;
return ret;
}
[test]
vkd3d-shader/hlsl: Inline function calls.
2021-09-11 14:56:04 -07:00
draw quad
tests: Add some tests for early return from user-defined functions.
2021-09-11 13:48:02 -07:00
probe all rgba (0.2, 0.1, 0.8, 0.5);
tests: Use the vulkan runner to run SM1 compilation tests. At the current moment this is a little odd because for SM1 [test] directives are skipped, and the [shader] directives are not executed by the shader_runner_vulkan.c:compile_shader() but by the general shader_runner.c:compile_shader(). So in principle it is a little weird that we go through the vulkan runner. But fret not, because in the future we plan to make the parser agnostic to the language of the tests, so we will get rid of the general shader_runner.c:compile_shader() function and instead call a runner->compile_shader() function, defined for each runner. Granted, most of these may call a generic implementation that uses native compiler in Windows, and vkd3d-shader on Linux, but it would be more conceptually correct.
2023-11-15 12:41:33 -08:00
[pixel shader todo(sm<4)]
tests: Add some tests for early return from user-defined functions.
2021-09-11 13:48:02 -07:00
uniform float f;
float func(out float o)
{
o = 0.1;
if (f < 0.3)
{
return 0.2;
o = 0.3;
}
else if (f < 0.7)
{
o = 0.4;
return 0.5;
}
o = 0.6;
return 0.7;
}
float func2(out float o)
{
o = 0.1;
if (f < 0.5)
{
o = 0.2;
}
else
{
o = 0.4;
return 0.3;
}
return 0.5;
}
float4 main() : sv_target
{
float4 ret;
ret.x = func(ret.y);
ret.z = func2(ret.w);
ret += 0.1;
return ret;
}
[test]
uniform 0 float 0.1
vkd3d-shader/ir: Introduce a simple control flow graph structurizer. The structurizer is implemented along the lines of what is usually called the "structured program theorem": the control flow is completely virtualized by mean of an additional TEMP register which stores the block index which is currently running. The whole program is then converted to a huge switch construction enclosed in a loop, executing at each iteration the appropriate block and updating the register depending on block jump instruction. The algorithm's generality is also its major weakness: it accepts any input program, even if its CFG is not reducible, but the output program lacks any useful convergence information. It satisfies the letter of the SPIR-V requirements, but it is expected that it will be very inefficient to run on a GPU (unless a downstream compiler is able to devirtualize the control flow and do a proper convergence analysis pass). The algorithm is however very simple, and good enough to at least pass tests, enabling further development. A better alternative is expected to be upstreamed incrementally. Side note: the structured program theorem is often called the Böhm-Jacopini theorem; Böhm and Jacopini did indeed prove a variation of it, but their algorithm is different from what is commontly attributed to them and implemented here, so I opted for not using their name.
2024-01-16 14:56:43 -08:00
todo(sm<4) draw quad
tests: Add some tests for early return from user-defined functions.
2021-09-11 13:48:02 -07:00
probe all rgba (0.3, 0.2, 0.6, 0.3) 1
uniform 0 float 0.4
vkd3d-shader/ir: Introduce a simple control flow graph structurizer. The structurizer is implemented along the lines of what is usually called the "structured program theorem": the control flow is completely virtualized by mean of an additional TEMP register which stores the block index which is currently running. The whole program is then converted to a huge switch construction enclosed in a loop, executing at each iteration the appropriate block and updating the register depending on block jump instruction. The algorithm's generality is also its major weakness: it accepts any input program, even if its CFG is not reducible, but the output program lacks any useful convergence information. It satisfies the letter of the SPIR-V requirements, but it is expected that it will be very inefficient to run on a GPU (unless a downstream compiler is able to devirtualize the control flow and do a proper convergence analysis pass). The algorithm is however very simple, and good enough to at least pass tests, enabling further development. A better alternative is expected to be upstreamed incrementally. Side note: the structured program theorem is often called the Böhm-Jacopini theorem; Böhm and Jacopini did indeed prove a variation of it, but their algorithm is different from what is commontly attributed to them and implemented here, so I opted for not using their name.
2024-01-16 14:56:43 -08:00
todo(sm<4) draw quad
tests: Add some tests for early return from user-defined functions.
2021-09-11 13:48:02 -07:00
probe all rgba (0.6, 0.5, 0.6, 0.3) 1
uniform 0 float 0.6
vkd3d-shader/ir: Introduce a simple control flow graph structurizer. The structurizer is implemented along the lines of what is usually called the "structured program theorem": the control flow is completely virtualized by mean of an additional TEMP register which stores the block index which is currently running. The whole program is then converted to a huge switch construction enclosed in a loop, executing at each iteration the appropriate block and updating the register depending on block jump instruction. The algorithm's generality is also its major weakness: it accepts any input program, even if its CFG is not reducible, but the output program lacks any useful convergence information. It satisfies the letter of the SPIR-V requirements, but it is expected that it will be very inefficient to run on a GPU (unless a downstream compiler is able to devirtualize the control flow and do a proper convergence analysis pass). The algorithm is however very simple, and good enough to at least pass tests, enabling further development. A better alternative is expected to be upstreamed incrementally. Side note: the structured program theorem is often called the Böhm-Jacopini theorem; Böhm and Jacopini did indeed prove a variation of it, but their algorithm is different from what is commontly attributed to them and implemented here, so I opted for not using their name.
2024-01-16 14:56:43 -08:00
todo(sm<4) draw quad
tests: Add some tests for early return from user-defined functions.
2021-09-11 13:48:02 -07:00
probe all rgba (0.6, 0.5, 0.4, 0.5) 1
uniform 0 float 0.8
vkd3d-shader/ir: Introduce a simple control flow graph structurizer. The structurizer is implemented along the lines of what is usually called the "structured program theorem": the control flow is completely virtualized by mean of an additional TEMP register which stores the block index which is currently running. The whole program is then converted to a huge switch construction enclosed in a loop, executing at each iteration the appropriate block and updating the register depending on block jump instruction. The algorithm's generality is also its major weakness: it accepts any input program, even if its CFG is not reducible, but the output program lacks any useful convergence information. It satisfies the letter of the SPIR-V requirements, but it is expected that it will be very inefficient to run on a GPU (unless a downstream compiler is able to devirtualize the control flow and do a proper convergence analysis pass). The algorithm is however very simple, and good enough to at least pass tests, enabling further development. A better alternative is expected to be upstreamed incrementally. Side note: the structured program theorem is often called the Böhm-Jacopini theorem; Böhm and Jacopini did indeed prove a variation of it, but their algorithm is different from what is commontly attributed to them and implemented here, so I opted for not using their name.
2024-01-16 14:56:43 -08:00
todo(sm<4) draw quad
tests: Add some tests for early return from user-defined functions.
2021-09-11 13:48:02 -07:00
probe all rgba (0.8, 0.7, 0.4, 0.5) 1
tests: Use the vulkan runner to run SM1 compilation tests. At the current moment this is a little odd because for SM1 [test] directives are skipped, and the [shader] directives are not executed by the shader_runner_vulkan.c:compile_shader() but by the general shader_runner.c:compile_shader(). So in principle it is a little weird that we go through the vulkan runner. But fret not, because in the future we plan to make the parser agnostic to the language of the tests, so we will get rid of the general shader_runner.c:compile_shader() function and instead call a runner->compile_shader() function, defined for each runner. Granted, most of these may call a generic implementation that uses native compiler in Windows, and vkd3d-shader on Linux, but it would be more conceptually correct.
2023-11-15 12:41:33 -08:00
[pixel shader todo(sm<4)]
tests: Add some tests for early return from user-defined functions.
2021-09-11 13:48:02 -07:00
uniform float f;
float func(out float o)
{
o = 0.1;
if (f < 0.3)
{
return 0.2;
}
o += 0.3;
if (f < 0.7)
{
return 0.5;
}
o += 0.5;
return 1.0;
}
float func2(out float o)
{
o = 0.1;
if (f < 0.7)
{
if (f < 0.3)
return 0.2;
o += 0.3;
}
o += 0.5;
return 1.0;
}
float4 main() : sv_target
{
float4 ret;
ret.x = func(ret.y);
ret.z = func2(ret.w);
return ret;
}
[test]
uniform 0 float 0.1
vkd3d-shader/ir: Introduce a simple control flow graph structurizer. The structurizer is implemented along the lines of what is usually called the "structured program theorem": the control flow is completely virtualized by mean of an additional TEMP register which stores the block index which is currently running. The whole program is then converted to a huge switch construction enclosed in a loop, executing at each iteration the appropriate block and updating the register depending on block jump instruction. The algorithm's generality is also its major weakness: it accepts any input program, even if its CFG is not reducible, but the output program lacks any useful convergence information. It satisfies the letter of the SPIR-V requirements, but it is expected that it will be very inefficient to run on a GPU (unless a downstream compiler is able to devirtualize the control flow and do a proper convergence analysis pass). The algorithm is however very simple, and good enough to at least pass tests, enabling further development. A better alternative is expected to be upstreamed incrementally. Side note: the structured program theorem is often called the Böhm-Jacopini theorem; Böhm and Jacopini did indeed prove a variation of it, but their algorithm is different from what is commontly attributed to them and implemented here, so I opted for not using their name.
2024-01-16 14:56:43 -08:00
todo(sm<4) draw quad
tests: Add some tests for early return from user-defined functions.
2021-09-11 13:48:02 -07:00
probe all rgba (0.2, 0.1, 0.2, 0.1) 1
uniform 0 float 0.5
vkd3d-shader/ir: Introduce a simple control flow graph structurizer. The structurizer is implemented along the lines of what is usually called the "structured program theorem": the control flow is completely virtualized by mean of an additional TEMP register which stores the block index which is currently running. The whole program is then converted to a huge switch construction enclosed in a loop, executing at each iteration the appropriate block and updating the register depending on block jump instruction. The algorithm's generality is also its major weakness: it accepts any input program, even if its CFG is not reducible, but the output program lacks any useful convergence information. It satisfies the letter of the SPIR-V requirements, but it is expected that it will be very inefficient to run on a GPU (unless a downstream compiler is able to devirtualize the control flow and do a proper convergence analysis pass). The algorithm is however very simple, and good enough to at least pass tests, enabling further development. A better alternative is expected to be upstreamed incrementally. Side note: the structured program theorem is often called the Böhm-Jacopini theorem; Böhm and Jacopini did indeed prove a variation of it, but their algorithm is different from what is commontly attributed to them and implemented here, so I opted for not using their name.
2024-01-16 14:56:43 -08:00
todo(sm<4) draw quad
tests: Add some tests for early return from user-defined functions.
2021-09-11 13:48:02 -07:00
probe all rgba (0.5, 0.4, 1.0, 0.9) 1
uniform 0 float 0.9
vkd3d-shader/ir: Introduce a simple control flow graph structurizer. The structurizer is implemented along the lines of what is usually called the "structured program theorem": the control flow is completely virtualized by mean of an additional TEMP register which stores the block index which is currently running. The whole program is then converted to a huge switch construction enclosed in a loop, executing at each iteration the appropriate block and updating the register depending on block jump instruction. The algorithm's generality is also its major weakness: it accepts any input program, even if its CFG is not reducible, but the output program lacks any useful convergence information. It satisfies the letter of the SPIR-V requirements, but it is expected that it will be very inefficient to run on a GPU (unless a downstream compiler is able to devirtualize the control flow and do a proper convergence analysis pass). The algorithm is however very simple, and good enough to at least pass tests, enabling further development. A better alternative is expected to be upstreamed incrementally. Side note: the structured program theorem is often called the Böhm-Jacopini theorem; Böhm and Jacopini did indeed prove a variation of it, but their algorithm is different from what is commontly attributed to them and implemented here, so I opted for not using their name.
2024-01-16 14:56:43 -08:00
todo(sm<4) draw quad
tests: Add some tests for early return from user-defined functions.
2021-09-11 13:48:02 -07:00
probe all rgba (1.0, 0.9, 1.0, 0.6) 1
tests: Use the vulkan runner to run SM1 compilation tests. At the current moment this is a little odd because for SM1 [test] directives are skipped, and the [shader] directives are not executed by the shader_runner_vulkan.c:compile_shader() but by the general shader_runner.c:compile_shader(). So in principle it is a little weird that we go through the vulkan runner. But fret not, because in the future we plan to make the parser agnostic to the language of the tests, so we will get rid of the general shader_runner.c:compile_shader() function and instead call a runner->compile_shader() function, defined for each runner. Granted, most of these may call a generic implementation that uses native compiler in Windows, and vkd3d-shader on Linux, but it would be more conceptually correct.
2023-11-15 12:41:33 -08:00
[pixel shader todo(sm<4)]
tests: Add some tests for early return from user-defined functions.
2021-09-11 13:48:02 -07:00
float func(out float o)
{
o = 0.1;
for (;;)
{
o *= 2;
return 0.3;
o *= 3;
}
o = 0;
return 0.4;
}
float func2(out float o)
{
o = 0.1;
for (;;)
{
if (o > 0.5)
return 0.2;
o *= 2;
}
o = 0;
return 0.3;
}
float4 main() : sv_target
{
float4 ret;
ret.x = func(ret.y);
ret.z = func2(ret.w);
ret += 0.1;
return ret;
}
[test]
tests: Use the vulkan runner to run SM1 compilation tests. At the current moment this is a little odd because for SM1 [test] directives are skipped, and the [shader] directives are not executed by the shader_runner_vulkan.c:compile_shader() but by the general shader_runner.c:compile_shader(). So in principle it is a little weird that we go through the vulkan runner. But fret not, because in the future we plan to make the parser agnostic to the language of the tests, so we will get rid of the general shader_runner.c:compile_shader() function and instead call a runner->compile_shader() function, defined for each runner. Granted, most of these may call a generic implementation that uses native compiler in Windows, and vkd3d-shader on Linux, but it would be more conceptually correct.
2023-11-15 12:41:33 -08:00
todo(sm<4) draw quad
tests: Add some tests for early return from user-defined functions.
2021-09-11 13:48:02 -07:00
probe all rgba (0.4, 0.3, 0.3, 0.9) 1
tests: Use the vulkan runner to run SM1 compilation tests. At the current moment this is a little odd because for SM1 [test] directives are skipped, and the [shader] directives are not executed by the shader_runner_vulkan.c:compile_shader() but by the general shader_runner.c:compile_shader(). So in principle it is a little weird that we go through the vulkan runner. But fret not, because in the future we plan to make the parser agnostic to the language of the tests, so we will get rid of the general shader_runner.c:compile_shader() function and instead call a runner->compile_shader() function, defined for each runner. Granted, most of these may call a generic implementation that uses native compiler in Windows, and vkd3d-shader on Linux, but it would be more conceptually correct.
2023-11-15 12:41:33 -08:00
[pixel shader todo(sm<4)]
tests: Add some tests for early return from user-defined functions.
2021-09-11 13:48:02 -07:00
uniform float f;
float func(out float o)
{
int i;
o = 0.1;
for (i = 0; i < 4; ++i)
{
if (o > f)
return 0.2;
o *= 2;
}
o = 0;
return 0.3;
}
float func2(out float o)
{
if (f < 0.5)
{
o = 0.1;
for (;;)
{
o *= 2;
return 0.2;
}
o *= 3;
return 0.3;
}
else
{
o = 0.4;
}
o = 0.5;
return 0.6;
}
float4 main() : sv_target
{
float4 ret;
ret.x = func(ret.y);
ret.z = func2(ret.w);
ret += 0.1;
return ret;
}
[test]
uniform 0 float 0.0
vkd3d-shader/ir: Introduce a simple control flow graph structurizer. The structurizer is implemented along the lines of what is usually called the "structured program theorem": the control flow is completely virtualized by mean of an additional TEMP register which stores the block index which is currently running. The whole program is then converted to a huge switch construction enclosed in a loop, executing at each iteration the appropriate block and updating the register depending on block jump instruction. The algorithm's generality is also its major weakness: it accepts any input program, even if its CFG is not reducible, but the output program lacks any useful convergence information. It satisfies the letter of the SPIR-V requirements, but it is expected that it will be very inefficient to run on a GPU (unless a downstream compiler is able to devirtualize the control flow and do a proper convergence analysis pass). The algorithm is however very simple, and good enough to at least pass tests, enabling further development. A better alternative is expected to be upstreamed incrementally. Side note: the structured program theorem is often called the Böhm-Jacopini theorem; Böhm and Jacopini did indeed prove a variation of it, but their algorithm is different from what is commontly attributed to them and implemented here, so I opted for not using their name.
2024-01-16 14:56:43 -08:00
todo(sm<4) draw quad
tests: Add some tests for early return from user-defined functions.
2021-09-11 13:48:02 -07:00
probe all rgba (0.3, 0.2, 0.3, 0.3) 1
uniform 0 float 0.1
vkd3d-shader/ir: Introduce a simple control flow graph structurizer. The structurizer is implemented along the lines of what is usually called the "structured program theorem": the control flow is completely virtualized by mean of an additional TEMP register which stores the block index which is currently running. The whole program is then converted to a huge switch construction enclosed in a loop, executing at each iteration the appropriate block and updating the register depending on block jump instruction. The algorithm's generality is also its major weakness: it accepts any input program, even if its CFG is not reducible, but the output program lacks any useful convergence information. It satisfies the letter of the SPIR-V requirements, but it is expected that it will be very inefficient to run on a GPU (unless a downstream compiler is able to devirtualize the control flow and do a proper convergence analysis pass). The algorithm is however very simple, and good enough to at least pass tests, enabling further development. A better alternative is expected to be upstreamed incrementally. Side note: the structured program theorem is often called the Böhm-Jacopini theorem; Böhm and Jacopini did indeed prove a variation of it, but their algorithm is different from what is commontly attributed to them and implemented here, so I opted for not using their name.
2024-01-16 14:56:43 -08:00
todo(sm<4) draw quad
tests: Add some tests for early return from user-defined functions.
2021-09-11 13:48:02 -07:00
probe all rgba (0.3, 0.3, 0.3, 0.3) 1
uniform 0 float 0.3
vkd3d-shader/ir: Introduce a simple control flow graph structurizer. The structurizer is implemented along the lines of what is usually called the "structured program theorem": the control flow is completely virtualized by mean of an additional TEMP register which stores the block index which is currently running. The whole program is then converted to a huge switch construction enclosed in a loop, executing at each iteration the appropriate block and updating the register depending on block jump instruction. The algorithm's generality is also its major weakness: it accepts any input program, even if its CFG is not reducible, but the output program lacks any useful convergence information. It satisfies the letter of the SPIR-V requirements, but it is expected that it will be very inefficient to run on a GPU (unless a downstream compiler is able to devirtualize the control flow and do a proper convergence analysis pass). The algorithm is however very simple, and good enough to at least pass tests, enabling further development. A better alternative is expected to be upstreamed incrementally. Side note: the structured program theorem is often called the Böhm-Jacopini theorem; Böhm and Jacopini did indeed prove a variation of it, but their algorithm is different from what is commontly attributed to them and implemented here, so I opted for not using their name.
2024-01-16 14:56:43 -08:00
todo(sm<4) draw quad
tests: Add some tests for early return from user-defined functions.
2021-09-11 13:48:02 -07:00
probe all rgba (0.3, 0.5, 0.3, 0.3) 1
uniform 0 float 0.7
vkd3d-shader/ir: Introduce a simple control flow graph structurizer. The structurizer is implemented along the lines of what is usually called the "structured program theorem": the control flow is completely virtualized by mean of an additional TEMP register which stores the block index which is currently running. The whole program is then converted to a huge switch construction enclosed in a loop, executing at each iteration the appropriate block and updating the register depending on block jump instruction. The algorithm's generality is also its major weakness: it accepts any input program, even if its CFG is not reducible, but the output program lacks any useful convergence information. It satisfies the letter of the SPIR-V requirements, but it is expected that it will be very inefficient to run on a GPU (unless a downstream compiler is able to devirtualize the control flow and do a proper convergence analysis pass). The algorithm is however very simple, and good enough to at least pass tests, enabling further development. A better alternative is expected to be upstreamed incrementally. Side note: the structured program theorem is often called the Böhm-Jacopini theorem; Böhm and Jacopini did indeed prove a variation of it, but their algorithm is different from what is commontly attributed to them and implemented here, so I opted for not using their name.
2024-01-16 14:56:43 -08:00
todo(sm<4) draw quad
tests: Add some tests for early return from user-defined functions.
2021-09-11 13:48:02 -07:00
probe all rgba (0.3, 0.9, 0.7, 0.6) 1
uniform 0 float 0.9
vkd3d-shader/ir: Introduce a simple control flow graph structurizer. The structurizer is implemented along the lines of what is usually called the "structured program theorem": the control flow is completely virtualized by mean of an additional TEMP register which stores the block index which is currently running. The whole program is then converted to a huge switch construction enclosed in a loop, executing at each iteration the appropriate block and updating the register depending on block jump instruction. The algorithm's generality is also its major weakness: it accepts any input program, even if its CFG is not reducible, but the output program lacks any useful convergence information. It satisfies the letter of the SPIR-V requirements, but it is expected that it will be very inefficient to run on a GPU (unless a downstream compiler is able to devirtualize the control flow and do a proper convergence analysis pass). The algorithm is however very simple, and good enough to at least pass tests, enabling further development. A better alternative is expected to be upstreamed incrementally. Side note: the structured program theorem is often called the Böhm-Jacopini theorem; Böhm and Jacopini did indeed prove a variation of it, but their algorithm is different from what is commontly attributed to them and implemented here, so I opted for not using their name.
2024-01-16 14:56:43 -08:00
todo(sm<4) draw quad
tests: Add some tests for early return from user-defined functions.
2021-09-11 13:48:02 -07:00
probe all rgba (0.4, 0.1, 0.7, 0.6) 1
tests: Use the vulkan runner to run SM1 compilation tests. At the current moment this is a little odd because for SM1 [test] directives are skipped, and the [shader] directives are not executed by the shader_runner_vulkan.c:compile_shader() but by the general shader_runner.c:compile_shader(). So in principle it is a little weird that we go through the vulkan runner. But fret not, because in the future we plan to make the parser agnostic to the language of the tests, so we will get rid of the general shader_runner.c:compile_shader() function and instead call a runner->compile_shader() function, defined for each runner. Granted, most of these may call a generic implementation that uses native compiler in Windows, and vkd3d-shader on Linux, but it would be more conceptually correct.
2023-11-15 12:41:33 -08:00
[pixel shader todo(sm<4)]
tests: Add some tests for early return from user-defined functions.
2021-09-11 13:48:02 -07:00
uniform float4 f[3];
float func(out float o)
{
int i, j;
o = 0.1;
for (i = 0; i < 3; ++i)
{
for (j = 0; j < 3; ++j)
{
if (o > f[j].x)
return 0.2;
}
o *= 2;
}
o = 0;
return 0.3;
}
float4 main() : sv_target
{
float4 ret;
ret.x = func(ret.y);
ret.zw = 0.5;
ret += 0.1;
return ret;
}
[test]
uniform 0 float4 0.3 0.0 0.0 0.0
uniform 4 float4 0.0 0.0 0.0 0.0
uniform 8 float4 0.1 0.0 0.0 0.0
vkd3d-shader/ir: Introduce a simple control flow graph structurizer. The structurizer is implemented along the lines of what is usually called the "structured program theorem": the control flow is completely virtualized by mean of an additional TEMP register which stores the block index which is currently running. The whole program is then converted to a huge switch construction enclosed in a loop, executing at each iteration the appropriate block and updating the register depending on block jump instruction. The algorithm's generality is also its major weakness: it accepts any input program, even if its CFG is not reducible, but the output program lacks any useful convergence information. It satisfies the letter of the SPIR-V requirements, but it is expected that it will be very inefficient to run on a GPU (unless a downstream compiler is able to devirtualize the control flow and do a proper convergence analysis pass). The algorithm is however very simple, and good enough to at least pass tests, enabling further development. A better alternative is expected to be upstreamed incrementally. Side note: the structured program theorem is often called the Böhm-Jacopini theorem; Böhm and Jacopini did indeed prove a variation of it, but their algorithm is different from what is commontly attributed to them and implemented here, so I opted for not using their name.
2024-01-16 14:56:43 -08:00
todo(sm<4) draw quad
probe all rgba (0.3, 0.2, 0.6, 0.6) 1
tests: Add some tests for early return from user-defined functions.
2021-09-11 13:48:02 -07:00
uniform 4 float4 0.35 0.0 0.0 0.0
vkd3d-shader/ir: Introduce a simple control flow graph structurizer. The structurizer is implemented along the lines of what is usually called the "structured program theorem": the control flow is completely virtualized by mean of an additional TEMP register which stores the block index which is currently running. The whole program is then converted to a huge switch construction enclosed in a loop, executing at each iteration the appropriate block and updating the register depending on block jump instruction. The algorithm's generality is also its major weakness: it accepts any input program, even if its CFG is not reducible, but the output program lacks any useful convergence information. It satisfies the letter of the SPIR-V requirements, but it is expected that it will be very inefficient to run on a GPU (unless a downstream compiler is able to devirtualize the control flow and do a proper convergence analysis pass). The algorithm is however very simple, and good enough to at least pass tests, enabling further development. A better alternative is expected to be upstreamed incrementally. Side note: the structured program theorem is often called the Böhm-Jacopini theorem; Böhm and Jacopini did indeed prove a variation of it, but their algorithm is different from what is commontly attributed to them and implemented here, so I opted for not using their name.
2024-01-16 14:56:43 -08:00
todo(sm<4) draw quad
probe all rgba (0.3, 0.3, 0.6, 0.6) 1
tests: Add some tests for early return from user-defined functions.
2021-09-11 13:48:02 -07:00
uniform 8 float4 0.5 0.0 0.0 0.0
vkd3d-shader/ir: Introduce a simple control flow graph structurizer. The structurizer is implemented along the lines of what is usually called the "structured program theorem": the control flow is completely virtualized by mean of an additional TEMP register which stores the block index which is currently running. The whole program is then converted to a huge switch construction enclosed in a loop, executing at each iteration the appropriate block and updating the register depending on block jump instruction. The algorithm's generality is also its major weakness: it accepts any input program, even if its CFG is not reducible, but the output program lacks any useful convergence information. It satisfies the letter of the SPIR-V requirements, but it is expected that it will be very inefficient to run on a GPU (unless a downstream compiler is able to devirtualize the control flow and do a proper convergence analysis pass). The algorithm is however very simple, and good enough to at least pass tests, enabling further development. A better alternative is expected to be upstreamed incrementally. Side note: the structured program theorem is often called the Böhm-Jacopini theorem; Böhm and Jacopini did indeed prove a variation of it, but their algorithm is different from what is commontly attributed to them and implemented here, so I opted for not using their name.
2024-01-16 14:56:43 -08:00
todo(sm<4) draw quad
probe all rgba (0.3, 0.5, 0.6, 0.6) 1
tests: Add some tests for early return from user-defined functions.
2021-09-11 13:48:02 -07:00
uniform 0 float4 1.0 0.0 0.0 0.0
vkd3d-shader/ir: Introduce a simple control flow graph structurizer. The structurizer is implemented along the lines of what is usually called the "structured program theorem": the control flow is completely virtualized by mean of an additional TEMP register which stores the block index which is currently running. The whole program is then converted to a huge switch construction enclosed in a loop, executing at each iteration the appropriate block and updating the register depending on block jump instruction. The algorithm's generality is also its major weakness: it accepts any input program, even if its CFG is not reducible, but the output program lacks any useful convergence information. It satisfies the letter of the SPIR-V requirements, but it is expected that it will be very inefficient to run on a GPU (unless a downstream compiler is able to devirtualize the control flow and do a proper convergence analysis pass). The algorithm is however very simple, and good enough to at least pass tests, enabling further development. A better alternative is expected to be upstreamed incrementally. Side note: the structured program theorem is often called the Böhm-Jacopini theorem; Böhm and Jacopini did indeed prove a variation of it, but their algorithm is different from what is commontly attributed to them and implemented here, so I opted for not using their name.
2024-01-16 14:56:43 -08:00
todo(sm<4) draw quad
probe all rgba (0.3, 0.5, 0.6, 0.6) 1
tests: Add some tests for early return from user-defined functions.
2021-09-11 13:48:02 -07:00
uniform 4 float4 2.0 0.0 0.0 0.0
vkd3d-shader/ir: Introduce a simple control flow graph structurizer. The structurizer is implemented along the lines of what is usually called the "structured program theorem": the control flow is completely virtualized by mean of an additional TEMP register which stores the block index which is currently running. The whole program is then converted to a huge switch construction enclosed in a loop, executing at each iteration the appropriate block and updating the register depending on block jump instruction. The algorithm's generality is also its major weakness: it accepts any input program, even if its CFG is not reducible, but the output program lacks any useful convergence information. It satisfies the letter of the SPIR-V requirements, but it is expected that it will be very inefficient to run on a GPU (unless a downstream compiler is able to devirtualize the control flow and do a proper convergence analysis pass). The algorithm is however very simple, and good enough to at least pass tests, enabling further development. A better alternative is expected to be upstreamed incrementally. Side note: the structured program theorem is often called the Böhm-Jacopini theorem; Böhm and Jacopini did indeed prove a variation of it, but their algorithm is different from what is commontly attributed to them and implemented here, so I opted for not using their name.
2024-01-16 14:56:43 -08:00
todo(sm<4) draw quad
probe all rgba (0.4, 0.1, 0.6, 0.6) 1
Reference in New Issue Copy Permalink