diff --git a/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/cov-two-loops-increment-integer-global-counter-break-square-threshold.amber b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/cov-two-loops-increment-integer-global-counter-break-square-threshold.amber new file mode 100644 index 00000000..afa9fe2e --- /dev/null +++ b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/cov-two-loops-increment-integer-global-counter-break-square-threshold.amber @@ -0,0 +1,296 @@ +#!amber + +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +# A test for a coverage-gap found by the GraphicsFuzz project. + +# Short description: A fragment shader that covers specific LLVM code paths + +# The test passes because the shader always writes red. + +SHADER vertex variant_vertex_shader PASSTHROUGH + +# variant_fragment_shader is derived from the following GLSL: +# #version 320 es +# #define _int_20 _GLF_uniform_int_values[0] +# #define _int_1 _GLF_uniform_int_values[1] +# #define _int_0 _GLF_uniform_int_values[2] +# #define _int_5 _GLF_uniform_int_values[3] +# #define _int_3 _GLF_uniform_int_values[4] +# #define _float_0_0 _GLF_uniform_float_values[0] +# +# precision highp float; +# precision highp int; +# +# // Contents of _GLF_uniform_float_values: 0.0 +# layout(set = 0, binding = 0) uniform buf0 +# { +# float _GLF_uniform_float_values[1]; +# }; +# +# // Contents of _GLF_uniform_int_values: [20, 1, 0, 5, 3] +# layout(set = 0, binding = 1) uniform buf1 +# { +# int _GLF_uniform_int_values[5]; +# }; +# +# const int _GLF_global_loop_bound = 10; +# int _GLF_global_loop_count = 0; +# +# layout(location = 0) out vec4 _GLF_color; +# +# void main() +# { +# int a = _int_1; +# +# for(int i = _int_0; i < _int_3; i++) +# { +# // Always true. +# if(gl_FragCoord.x > _float_0_0) +# { +# a++; +# } +# } +# +# while(_GLF_global_loop_count < _GLF_global_loop_bound) +# { +# _GLF_global_loop_count ++; +# +# // Breaks when a is five. +# if(a * a + _int_1 > _int_20) +# { +# break; +# } +# +# a++; +# } +# +# // Always true. +# if(a == _int_5) +# { +# _GLF_color = vec4(_int_1, _int_0, _int_0, _int_1); +# } +# else +# { +# _GLF_color = vec4(_int_0); +# } +# } +SHADER fragment variant_fragment_shader SPIRV-ASM TARGET_ENV spv1.0 +; SPIR-V +; Version: 1.0 +; Generator: Khronos Glslang Reference Front End; 10 +; Bound: 111 +; Schema: 0 + OpCapability Shader + %1 = OpExtInstImport "GLSL.std.450" + OpMemoryModel Logical GLSL450 + OpEntryPoint Fragment %4 "main" %40 %92 + OpExecutionMode %4 OriginUpperLeft + OpSource ESSL 320 + OpName %4 "main" + OpName %8 "_GLF_global_loop_count" + OpName %11 "a" + OpName %15 "buf1" + OpMemberName %15 0 "_GLF_uniform_int_values" + OpName %17 "" + OpName %22 "i" + OpName %40 "gl_FragCoord" + OpName %47 "buf0" + OpMemberName %47 0 "_GLF_uniform_float_values" + OpName %49 "" + OpName %92 "_GLF_color" + OpDecorate %14 ArrayStride 16 + OpMemberDecorate %15 0 Offset 0 + OpDecorate %15 Block + OpDecorate %17 DescriptorSet 0 + OpDecorate %17 Binding 1 + OpDecorate %40 BuiltIn FragCoord + OpDecorate %46 ArrayStride 16 + OpMemberDecorate %47 0 Offset 0 + OpDecorate %47 Block + OpDecorate %49 DescriptorSet 0 + OpDecorate %49 Binding 0 + OpDecorate %92 Location 0 + %2 = OpTypeVoid + %3 = OpTypeFunction %2 + %6 = OpTypeInt 32 1 + %7 = OpTypePointer Private %6 + %8 = OpVariable %7 Private + %9 = OpConstant %6 0 + %10 = OpTypePointer Function %6 + %12 = OpTypeInt 32 0 + %13 = OpConstant %12 5 + %14 = OpTypeArray %6 %13 + %15 = OpTypeStruct %14 + %16 = OpTypePointer Uniform %15 + %17 = OpVariable %16 Uniform + %18 = OpConstant %6 1 + %19 = OpTypePointer Uniform %6 + %23 = OpConstant %6 2 + %32 = OpConstant %6 4 + %35 = OpTypeBool + %37 = OpTypeFloat 32 + %38 = OpTypeVector %37 4 + %39 = OpTypePointer Input %38 + %40 = OpVariable %39 Input + %41 = OpConstant %12 0 + %42 = OpTypePointer Input %37 + %45 = OpConstant %12 1 + %46 = OpTypeArray %37 %45 + %47 = OpTypeStruct %46 + %48 = OpTypePointer Uniform %47 + %49 = OpVariable %48 Uniform + %50 = OpTypePointer Uniform %37 + %66 = OpConstant %6 10 + %85 = OpConstant %6 3 + %91 = OpTypePointer Output %38 + %92 = OpVariable %91 Output + %4 = OpFunction %2 None %3 + %5 = OpLabel + %11 = OpVariable %10 Function + %22 = OpVariable %10 Function + OpStore %8 %9 + %20 = OpAccessChain %19 %17 %9 %18 + %21 = OpLoad %6 %20 + OpStore %11 %21 + %24 = OpAccessChain %19 %17 %9 %23 + %25 = OpLoad %6 %24 + OpStore %22 %25 + OpBranch %26 + %26 = OpLabel + OpLoopMerge %28 %29 None + OpBranch %30 + %30 = OpLabel + %31 = OpLoad %6 %22 + %33 = OpAccessChain %19 %17 %9 %32 + %34 = OpLoad %6 %33 + %36 = OpSLessThan %35 %31 %34 + OpBranchConditional %36 %27 %28 + %27 = OpLabel + %43 = OpAccessChain %42 %40 %41 + %44 = OpLoad %37 %43 + %51 = OpAccessChain %50 %49 %9 %9 + %52 = OpLoad %37 %51 + %53 = OpFOrdGreaterThan %35 %44 %52 + OpSelectionMerge %55 None + OpBranchConditional %53 %54 %55 + %54 = OpLabel + %56 = OpLoad %6 %11 + %57 = OpIAdd %6 %56 %18 + OpStore %11 %57 + OpBranch %55 + %55 = OpLabel + OpBranch %29 + %29 = OpLabel + %58 = OpLoad %6 %22 + %59 = OpIAdd %6 %58 %18 + OpStore %22 %59 + OpBranch %26 + %28 = OpLabel + OpBranch %60 + %60 = OpLabel + OpLoopMerge %62 %63 None + OpBranch %64 + %64 = OpLabel + %65 = OpLoad %6 %8 + %67 = OpSLessThan %35 %65 %66 + OpBranchConditional %67 %61 %62 + %61 = OpLabel + %68 = OpLoad %6 %8 + %69 = OpIAdd %6 %68 %18 + OpStore %8 %69 + %70 = OpLoad %6 %11 + %71 = OpLoad %6 %11 + %72 = OpIMul %6 %70 %71 + %73 = OpAccessChain %19 %17 %9 %18 + %74 = OpLoad %6 %73 + %75 = OpIAdd %6 %72 %74 + %76 = OpAccessChain %19 %17 %9 %9 + %77 = OpLoad %6 %76 + %78 = OpSGreaterThan %35 %75 %77 + OpSelectionMerge %80 None + OpBranchConditional %78 %79 %80 + %79 = OpLabel + OpBranch %62 + %80 = OpLabel + %82 = OpLoad %6 %11 + %83 = OpIAdd %6 %82 %18 + OpStore %11 %83 + OpBranch %63 + %63 = OpLabel + OpBranch %60 + %62 = OpLabel + %84 = OpLoad %6 %11 + %86 = OpAccessChain %19 %17 %9 %85 + %87 = OpLoad %6 %86 + %88 = OpIEqual %35 %84 %87 + OpSelectionMerge %90 None + OpBranchConditional %88 %89 %106 + %89 = OpLabel + %93 = OpAccessChain %19 %17 %9 %18 + %94 = OpLoad %6 %93 + %95 = OpConvertSToF %37 %94 + %96 = OpAccessChain %19 %17 %9 %23 + %97 = OpLoad %6 %96 + %98 = OpConvertSToF %37 %97 + %99 = OpAccessChain %19 %17 %9 %23 + %100 = OpLoad %6 %99 + %101 = OpConvertSToF %37 %100 + %102 = OpAccessChain %19 %17 %9 %18 + %103 = OpLoad %6 %102 + %104 = OpConvertSToF %37 %103 + %105 = OpCompositeConstruct %38 %95 %98 %101 %104 + OpStore %92 %105 + OpBranch %90 + %106 = OpLabel + %107 = OpAccessChain %19 %17 %9 %23 + %108 = OpLoad %6 %107 + %109 = OpConvertSToF %37 %108 + %110 = OpCompositeConstruct %38 %109 %109 %109 %109 + OpStore %92 %110 + OpBranch %90 + %90 = OpLabel + OpReturn + OpFunctionEnd +END + +# uniforms for variant + +# _GLF_uniform_int_values +BUFFER variant__GLF_uniform_int_values DATA_TYPE int32[] STD140 DATA + 20 1 0 5 3 +END +# _GLF_uniform_float_values +BUFFER variant__GLF_uniform_float_values DATA_TYPE float[] STD140 DATA + 0.0 +END + +BUFFER variant_framebuffer FORMAT B8G8R8A8_UNORM + +PIPELINE graphics variant_pipeline + ATTACH variant_vertex_shader + ATTACH variant_fragment_shader + FRAMEBUFFER_SIZE 256 256 + BIND BUFFER variant_framebuffer AS color LOCATION 0 + BIND BUFFER variant__GLF_uniform_int_values AS uniform DESCRIPTOR_SET 0 BINDING 1 + BIND BUFFER variant__GLF_uniform_float_values AS uniform DESCRIPTOR_SET 0 BINDING 0 +END +CLEAR_COLOR variant_pipeline 0 0 0 255 + +CLEAR variant_pipeline +RUN variant_pipeline DRAW_RECT POS 0 0 SIZE 256 256 + +EXPECT variant_framebuffer IDX 0 0 SIZE 256 256 EQ_RGBA 255 0 0 255 diff --git a/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/generate_cts_test.py b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/generate_cts_test.py new file mode 100755 index 00000000..558d08b4 --- /dev/null +++ b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/generate_cts_test.py @@ -0,0 +1,57 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- + +# Copyright 2021 The GraphicsFuzz Project Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Generate a CTS test. + +This module/script is copied next to a specific test in your repository of bugs +to generate an Amber script test suitable for adding to the CTS. +In particular, the Amber script test is suitable for use with |add_amber_tests_to_cts.py|. +""" + +import sys +from pathlib import Path + +from gfauto import tool, util + + +def main() -> None: + + # Checklist: + # - check output_amber + # - check short_description + # - check comment_text + # - check copyright_year + # - check extra_commands + + bug_dir = util.norm_path(Path(__file__).absolute()).parent + + tool.glsl_shader_job_crash_to_amber_script_for_google_cts( + source_dir=bug_dir / "reduced_manual", + output_amber=bug_dir / "cov-two-loops-increment-integer-global-counter-break-square-threshold.amber", + work_dir=bug_dir / "work", + # One sentence, 58 characters max., no period, no line breaks. + short_description="A fragment shader that covers specific LLVM code paths", + comment_text="""The test passes because the shader always writes red.""", + copyright_year="2022", + extra_commands=tool.AMBER_COMMAND_EXPECT_RED, + is_coverage_gap=True, + ) + + +if __name__ == "__main__": + main() + sys.exit(0) diff --git a/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduced_2/_reference/shader.frag b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduced_2/_reference/shader.frag new file mode 100644 index 00000000..b170a9fa --- /dev/null +++ b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduced_2/_reference/shader.frag @@ -0,0 +1,206 @@ +#version 320 es +precision highp float; + +layout(location = 0) out vec4 _GLF_color; + +layout(set = 0, binding = 0) uniform buf0 { + float one; +}; +layout(set = 0, binding = 1) uniform buf1 { + vec2 resolution; +}; +mat2 m22; + +mat2x3 m23; + +mat2x4 m24; + +mat3x2 m32; + +mat3 m33; + +mat3x4 m34; + +mat4x2 m42; + +mat4x3 m43; + +mat4 m44; + +void main() +{ + for(int c = 0; c < 2; c ++) + { + for(int r = 0; r < 2; r ++) + { + m22[c][r] = one; + } + } + ; + for(int c = 0; c < 2; c ++) + { + for(int r = 0; r < 3; r ++) + { + m23[c][r] = one; + } + } + ; + for(int c = 0; c < 2; c ++) + { + for(int r = 0; r < 4; r ++) + { + m24[c][r] = one; + } + } + ; + for(int c = 0; c < 3; c ++) + { + for(int r = 0; r < 2; r ++) + { + m32[c][r] = one; + } + } + ; + for(int c = 0; c < 3; c ++) + { + for(int r = 0; r < 3; r ++) + { + m33[c][r] = one; + } + } + ; + for(int c = 0; c < 3; c ++) + { + for(int r = 0; r < 4; r ++) + { + m34[c][r] = one; + } + } + ; + for(int c = 0; c < 4; c ++) + { + for(int r = 0; r < 2; r ++) + { + m42[c][r] = one; + } + } + ; + for(int c = 0; c < 4; c ++) + { + for(int r = 0; r < 3; r ++) + { + m43[c][r] = one; + } + } + ; + for(int c = 0; c < 4; c ++) + { + for(int r = 0; r < 4; r ++) + { + m44[c][r] = one; + } + } + ; + float sums[9]; + sums[0] = 0.0; + for(int c = 0; c < 2; c ++) + { + for(int r = 0; r < 2; r ++) + { + sums[0] += m22[c][r]; + } + } + sums[0] /= 16.0; + ; + sums[1] = 0.0; + for(int c = 0; c < 2; c ++) + { + for(int r = 0; r < 3; r ++) + { + sums[1] += m23[c][r]; + } + } + sums[1] /= 16.0; + ; + sums[2] = 0.0; + for(int c = 0; c < 2; c ++) + { + for(int r = 0; r < 4; r ++) + { + sums[2] += m24[c][r]; + } + } + sums[2] /= 16.0; + ; + sums[3] = 0.0; + for(int c = 0; c < 3; c ++) + { + for(int r = 0; r < 2; r ++) + { + sums[3] += m32[c][r]; + } + } + sums[3] /= 16.0; + ; + sums[4] = 0.0; + for(int c = 0; c < 3; c ++) + { + for(int r = 0; r < 3; r ++) + { + sums[4] += m33[c][r]; + } + } + sums[4] /= 16.0; + ; + sums[5] = 0.0; + for(int c = 0; c < 3; c ++) + { + for(int r = 0; r < 4; r ++) + { + sums[5] += m34[c][r]; + } + } + sums[5] /= 16.0; + ; + sums[6] = 0.0; + for(int c = 0; c < 4; c ++) + { + for(int r = 0; r < 2; r ++) + { + sums[6] += m42[c][r]; + } + } + sums[6] /= 16.0; + ; + sums[7] = 0.0; + for(int c = 0; c < 4; c ++) + { + for(int r = 0; r < 3; r ++) + { + sums[7] += m43[c][r]; + } + } + sums[7] /= 16.0; + ; + sums[8] = 0.0; + for(int c = 0; c < 4; c ++) + { + for(int r = 0; r < 4; r ++) + { + sums[8] += m44[c][r]; + } + } + sums[8] /= 16.0; + ; + int region_x = int(gl_FragCoord.x / (resolution.x / 3.0)); + int region_y = int(gl_FragCoord.y / (resolution.x / 3.0)); + int overall_region = region_y * 3 + region_x; + if(overall_region > 0 && overall_region < 9) + { + _GLF_color = vec4(vec3(sums[overall_region]), 1.0); + } + else + { + _GLF_color = vec4(vec3(0.0), 1.0); + } +} diff --git a/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduced_2/_reference/shader.json b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduced_2/_reference/shader.json new file mode 100644 index 00000000..ef3502b5 --- /dev/null +++ b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduced_2/_reference/shader.json @@ -0,0 +1,17 @@ +{ + "one": { + "func": "glUniform1f", + "args": [ + 1.0 + ], + "binding": 0 + }, + "resolution": { + "func": "glUniform2f", + "args": [ + 256.0, + 256.0 + ], + "binding": 1 + } +} diff --git a/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduced_2/test.json b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduced_2/test.json new file mode 100644 index 00000000..83ecad07 --- /dev/null +++ b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduced_2/test.json @@ -0,0 +1,70 @@ +{ + "binaries": [ + { + "name": "glslangValidator", + "path": "", + "tags": [ + "Debug" + ], + "version": "c0bcfaf3bae917c57bca49897eb7430cdf256c70" + }, + { + "name": "spirv-dis", + "path": "", + "tags": [ + "Debug" + ], + "version": "a0370efd589be33d5d9a85cfde2f85841b3755af" + }, + { + "name": "spirv-val", + "path": "", + "tags": [ + "Debug" + ], + "version": "a0370efd589be33d5d9a85cfde2f85841b3755af" + }, + { + "name": "amber", + "path": "", + "tags": [ + "Debug" + ], + "version": "cc1dec6104f5e0e656d8439296265a19393628df" + }, + { + "name": "amber_apk", + "path": "", + "tags": [ + "Debug" + ], + "version": "cc1dec6104f5e0e656d8439296265a19393628df" + }, + { + "name": "amber_apk_test", + "path": "", + "tags": [ + "Debug" + ], + "version": "cc1dec6104f5e0e656d8439296265a19393628df" + } + ], + "common_spirv_args": [], + "crash_regex_override": "", + "crash_signature": "llvmOptionalllvmScalarEvolutionLoopInvariantPredic", + "derived_from": "matrices_many_loops", + "device": { + "binaries": [], + "device_properties": " apiVersion: 1.2.145\n driverVersion: 83898368\n vendorID: 32902\n deviceID: 16024\n deviceType: integrated gpu\n deviceName: Intel(R) UHD Graphics 630 (CFL GT2)\n driverName: Intel open-source Mesa driver\n driverInfo: Mesa 20.3.0-rc1 (git-f44896c12a)\n minSubgroupSize: 8\n maxSubgroupSize: 32\n maxComputeWorkgroupSubgroups: 56\n requiredSubgroupSizeStages: comp\n", + "host": { + "custom_launcher": [] + }, + "ignored_crash_signatures": [], + "name": "host" + }, + "expected_status": "CRASH", + "glsl": { + "spirv_opt_args": [] + }, + "skip_validation": false +} \ No newline at end of file diff --git a/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduced_2/variant/shader.frag b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduced_2/variant/shader.frag new file mode 100644 index 00000000..f50e3864 --- /dev/null +++ b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduced_2/variant/shader.frag @@ -0,0 +1,36 @@ +#version 320 es + +precision highp float; + +precision highp int; + +const int _GLF_global_loop_bound = 100; + +int _GLF_global_loop_count = 0; + +int GLF_dead7index = 1; + +precision highp int; + +precision highp float; + +void main() +{ + for(int c = 0; (c < 1) && (_GLF_global_loop_count < _GLF_global_loop_bound); c ++) + { + _GLF_global_loop_count ++; + if(gl_FragCoord.x < 1.0) + { + GLF_dead7index ++; + } + } + for(int GLF_dead12k = 1; (true) && (_GLF_global_loop_count < _GLF_global_loop_bound); 1) + { + _GLF_global_loop_count ++; + if(GLF_dead7index * GLF_dead7index + 1 > 1) + { + break; + } + GLF_dead7index ++; + } +} diff --git a/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduced_2/variant/shader.json b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduced_2/variant/shader.json new file mode 100644 index 00000000..0967ef42 --- /dev/null +++ b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduced_2/variant/shader.json @@ -0,0 +1 @@ +{} diff --git a/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduced_manual/_reference/shader.frag b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduced_manual/_reference/shader.frag new file mode 100644 index 00000000..b170a9fa --- /dev/null +++ b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduced_manual/_reference/shader.frag @@ -0,0 +1,206 @@ +#version 320 es +precision highp float; + +layout(location = 0) out vec4 _GLF_color; + +layout(set = 0, binding = 0) uniform buf0 { + float one; +}; +layout(set = 0, binding = 1) uniform buf1 { + vec2 resolution; +}; +mat2 m22; + +mat2x3 m23; + +mat2x4 m24; + +mat3x2 m32; + +mat3 m33; + +mat3x4 m34; + +mat4x2 m42; + +mat4x3 m43; + +mat4 m44; + +void main() +{ + for(int c = 0; c < 2; c ++) + { + for(int r = 0; r < 2; r ++) + { + m22[c][r] = one; + } + } + ; + for(int c = 0; c < 2; c ++) + { + for(int r = 0; r < 3; r ++) + { + m23[c][r] = one; + } + } + ; + for(int c = 0; c < 2; c ++) + { + for(int r = 0; r < 4; r ++) + { + m24[c][r] = one; + } + } + ; + for(int c = 0; c < 3; c ++) + { + for(int r = 0; r < 2; r ++) + { + m32[c][r] = one; + } + } + ; + for(int c = 0; c < 3; c ++) + { + for(int r = 0; r < 3; r ++) + { + m33[c][r] = one; + } + } + ; + for(int c = 0; c < 3; c ++) + { + for(int r = 0; r < 4; r ++) + { + m34[c][r] = one; + } + } + ; + for(int c = 0; c < 4; c ++) + { + for(int r = 0; r < 2; r ++) + { + m42[c][r] = one; + } + } + ; + for(int c = 0; c < 4; c ++) + { + for(int r = 0; r < 3; r ++) + { + m43[c][r] = one; + } + } + ; + for(int c = 0; c < 4; c ++) + { + for(int r = 0; r < 4; r ++) + { + m44[c][r] = one; + } + } + ; + float sums[9]; + sums[0] = 0.0; + for(int c = 0; c < 2; c ++) + { + for(int r = 0; r < 2; r ++) + { + sums[0] += m22[c][r]; + } + } + sums[0] /= 16.0; + ; + sums[1] = 0.0; + for(int c = 0; c < 2; c ++) + { + for(int r = 0; r < 3; r ++) + { + sums[1] += m23[c][r]; + } + } + sums[1] /= 16.0; + ; + sums[2] = 0.0; + for(int c = 0; c < 2; c ++) + { + for(int r = 0; r < 4; r ++) + { + sums[2] += m24[c][r]; + } + } + sums[2] /= 16.0; + ; + sums[3] = 0.0; + for(int c = 0; c < 3; c ++) + { + for(int r = 0; r < 2; r ++) + { + sums[3] += m32[c][r]; + } + } + sums[3] /= 16.0; + ; + sums[4] = 0.0; + for(int c = 0; c < 3; c ++) + { + for(int r = 0; r < 3; r ++) + { + sums[4] += m33[c][r]; + } + } + sums[4] /= 16.0; + ; + sums[5] = 0.0; + for(int c = 0; c < 3; c ++) + { + for(int r = 0; r < 4; r ++) + { + sums[5] += m34[c][r]; + } + } + sums[5] /= 16.0; + ; + sums[6] = 0.0; + for(int c = 0; c < 4; c ++) + { + for(int r = 0; r < 2; r ++) + { + sums[6] += m42[c][r]; + } + } + sums[6] /= 16.0; + ; + sums[7] = 0.0; + for(int c = 0; c < 4; c ++) + { + for(int r = 0; r < 3; r ++) + { + sums[7] += m43[c][r]; + } + } + sums[7] /= 16.0; + ; + sums[8] = 0.0; + for(int c = 0; c < 4; c ++) + { + for(int r = 0; r < 4; r ++) + { + sums[8] += m44[c][r]; + } + } + sums[8] /= 16.0; + ; + int region_x = int(gl_FragCoord.x / (resolution.x / 3.0)); + int region_y = int(gl_FragCoord.y / (resolution.x / 3.0)); + int overall_region = region_y * 3 + region_x; + if(overall_region > 0 && overall_region < 9) + { + _GLF_color = vec4(vec3(sums[overall_region]), 1.0); + } + else + { + _GLF_color = vec4(vec3(0.0), 1.0); + } +} diff --git a/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduced_manual/_reference/shader.json b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduced_manual/_reference/shader.json new file mode 100644 index 00000000..ef3502b5 --- /dev/null +++ b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduced_manual/_reference/shader.json @@ -0,0 +1,17 @@ +{ + "one": { + "func": "glUniform1f", + "args": [ + 1.0 + ], + "binding": 0 + }, + "resolution": { + "func": "glUniform2f", + "args": [ + 256.0, + 256.0 + ], + "binding": 1 + } +} diff --git a/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduced_manual/test.json b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduced_manual/test.json new file mode 100644 index 00000000..cbfbac37 --- /dev/null +++ b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduced_manual/test.json @@ -0,0 +1,70 @@ +{ + "binaries": [ + { + "name": "glslangValidator", + "path": "", + "tags": [ + "Debug" + ], + "version": "c0bcfaf3bae917c57bca49897eb7430cdf256c70" + }, + { + "name": "spirv-dis", + "path": "", + "tags": [ + "Debug" + ], + "version": "a0370efd589be33d5d9a85cfde2f85841b3755af" + }, + { + "name": "spirv-val", + "path": "", + "tags": [ + "Debug" + ], + "version": "a0370efd589be33d5d9a85cfde2f85841b3755af" + }, + { + "name": "amber", + "path": "", + "tags": [ + "Debug" + ], + "version": "cc1dec6104f5e0e656d8439296265a19393628df" + }, + { + "name": "amber_apk", + "path": "", + "tags": [ + "Debug" + ], + "version": "cc1dec6104f5e0e656d8439296265a19393628df" + }, + { + "name": "amber_apk_test", + "path": "", + "tags": [ + "Debug" + ], + "version": "cc1dec6104f5e0e656d8439296265a19393628df" + } + ], + "common_spirv_args": [], + "crash_regex_override": ".*ScalarEvolution9808.*", + "crash_signature": "llvmOptionalllvmScalarEvolutionLoopInvariantPredic", + "derived_from": "matrices_many_loops", + "device": { + "binaries": [], + "device_properties": " apiVersion: 1.2.145\n driverVersion: 83898368\n vendorID: 32902\n deviceID: 16024\n deviceType: integrated gpu\n deviceName: Intel(R) UHD Graphics 630 (CFL GT2)\n driverName: Intel open-source Mesa driver\n driverInfo: Mesa 20.3.0-rc1 (git-f44896c12a)\n minSubgroupSize: 8\n maxSubgroupSize: 32\n maxComputeWorkgroupSubgroups: 56\n requiredSubgroupSizeStages: comp\n", + "host": { + "custom_launcher": [] + }, + "ignored_crash_signatures": [], + "name": "host" + }, + "expected_status": "CRASH", + "glsl": { + "spirv_opt_args": [] + }, + "skip_validation": false +} diff --git a/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduced_manual/variant/shader.frag b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduced_manual/variant/shader.frag new file mode 100644 index 00000000..85c11f06 --- /dev/null +++ b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduced_manual/variant/shader.frag @@ -0,0 +1,64 @@ +#version 320 es +#define _int_20 _GLF_uniform_int_values[0] +#define _int_1 _GLF_uniform_int_values[1] +#define _int_0 _GLF_uniform_int_values[2] +#define _int_5 _GLF_uniform_int_values[3] +#define _int_3 _GLF_uniform_int_values[4] +#define _float_0_0 _GLF_uniform_float_values[0] + +precision highp float; +precision highp int; + +// Contents of _GLF_uniform_float_values: 0.0 +layout(set = 0, binding = 0) uniform buf0 +{ + float _GLF_uniform_float_values[1]; +}; + +// Contents of _GLF_uniform_int_values: [20, 1, 0, 5, 3] +layout(set = 0, binding = 1) uniform buf1 +{ + int _GLF_uniform_int_values[5]; +}; + +const int _GLF_global_loop_bound = 10; +int _GLF_global_loop_count = 0; + +layout(location = 0) out vec4 _GLF_color; + +void main() +{ + int a = _int_1; + + for(int i = _int_0; i < _int_3; i++) + { + // Always true. + if(gl_FragCoord.x > _float_0_0) + { + a++; + } + } + + while(_GLF_global_loop_count < _GLF_global_loop_bound) + { + _GLF_global_loop_count ++; + + // Breaks when a is five. + if(a * a + _int_1 > _int_20) + { + break; + } + + a++; + } + + // Always true. + if(a == _int_5) + { + _GLF_color = vec4(_int_1, _int_0, _int_0, _int_1); + } + else + { + _GLF_color = vec4(_int_0); + } +} diff --git a/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduced_manual/variant/shader.json b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduced_manual/variant/shader.json new file mode 100644 index 00000000..e496cfa8 --- /dev/null +++ b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduced_manual/variant/shader.json @@ -0,0 +1,22 @@ +{ + "_GLF_uniform_int_values": { + "func": "glUniform1iv", + "args": [ + 20, + 1, + 0, + 5, + 3 + ], + "count": 0, + "binding": 1 + }, + "_GLF_uniform_float_values": { + "func": "glUniform1fv", + "args": [ + 0.0 + ], + "count": 0, + "binding": 0 + } +} diff --git a/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduction_output/1/source/_reference/shader.frag b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduction_output/1/source/_reference/shader.frag new file mode 100644 index 00000000..b170a9fa --- /dev/null +++ b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduction_output/1/source/_reference/shader.frag @@ -0,0 +1,206 @@ +#version 320 es +precision highp float; + +layout(location = 0) out vec4 _GLF_color; + +layout(set = 0, binding = 0) uniform buf0 { + float one; +}; +layout(set = 0, binding = 1) uniform buf1 { + vec2 resolution; +}; +mat2 m22; + +mat2x3 m23; + +mat2x4 m24; + +mat3x2 m32; + +mat3 m33; + +mat3x4 m34; + +mat4x2 m42; + +mat4x3 m43; + +mat4 m44; + +void main() +{ + for(int c = 0; c < 2; c ++) + { + for(int r = 0; r < 2; r ++) + { + m22[c][r] = one; + } + } + ; + for(int c = 0; c < 2; c ++) + { + for(int r = 0; r < 3; r ++) + { + m23[c][r] = one; + } + } + ; + for(int c = 0; c < 2; c ++) + { + for(int r = 0; r < 4; r ++) + { + m24[c][r] = one; + } + } + ; + for(int c = 0; c < 3; c ++) + { + for(int r = 0; r < 2; r ++) + { + m32[c][r] = one; + } + } + ; + for(int c = 0; c < 3; c ++) + { + for(int r = 0; r < 3; r ++) + { + m33[c][r] = one; + } + } + ; + for(int c = 0; c < 3; c ++) + { + for(int r = 0; r < 4; r ++) + { + m34[c][r] = one; + } + } + ; + for(int c = 0; c < 4; c ++) + { + for(int r = 0; r < 2; r ++) + { + m42[c][r] = one; + } + } + ; + for(int c = 0; c < 4; c ++) + { + for(int r = 0; r < 3; r ++) + { + m43[c][r] = one; + } + } + ; + for(int c = 0; c < 4; c ++) + { + for(int r = 0; r < 4; r ++) + { + m44[c][r] = one; + } + } + ; + float sums[9]; + sums[0] = 0.0; + for(int c = 0; c < 2; c ++) + { + for(int r = 0; r < 2; r ++) + { + sums[0] += m22[c][r]; + } + } + sums[0] /= 16.0; + ; + sums[1] = 0.0; + for(int c = 0; c < 2; c ++) + { + for(int r = 0; r < 3; r ++) + { + sums[1] += m23[c][r]; + } + } + sums[1] /= 16.0; + ; + sums[2] = 0.0; + for(int c = 0; c < 2; c ++) + { + for(int r = 0; r < 4; r ++) + { + sums[2] += m24[c][r]; + } + } + sums[2] /= 16.0; + ; + sums[3] = 0.0; + for(int c = 0; c < 3; c ++) + { + for(int r = 0; r < 2; r ++) + { + sums[3] += m32[c][r]; + } + } + sums[3] /= 16.0; + ; + sums[4] = 0.0; + for(int c = 0; c < 3; c ++) + { + for(int r = 0; r < 3; r ++) + { + sums[4] += m33[c][r]; + } + } + sums[4] /= 16.0; + ; + sums[5] = 0.0; + for(int c = 0; c < 3; c ++) + { + for(int r = 0; r < 4; r ++) + { + sums[5] += m34[c][r]; + } + } + sums[5] /= 16.0; + ; + sums[6] = 0.0; + for(int c = 0; c < 4; c ++) + { + for(int r = 0; r < 2; r ++) + { + sums[6] += m42[c][r]; + } + } + sums[6] /= 16.0; + ; + sums[7] = 0.0; + for(int c = 0; c < 4; c ++) + { + for(int r = 0; r < 3; r ++) + { + sums[7] += m43[c][r]; + } + } + sums[7] /= 16.0; + ; + sums[8] = 0.0; + for(int c = 0; c < 4; c ++) + { + for(int r = 0; r < 4; r ++) + { + sums[8] += m44[c][r]; + } + } + sums[8] /= 16.0; + ; + int region_x = int(gl_FragCoord.x / (resolution.x / 3.0)); + int region_y = int(gl_FragCoord.y / (resolution.x / 3.0)); + int overall_region = region_y * 3 + region_x; + if(overall_region > 0 && overall_region < 9) + { + _GLF_color = vec4(vec3(sums[overall_region]), 1.0); + } + else + { + _GLF_color = vec4(vec3(0.0), 1.0); + } +} diff --git a/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduction_output/1/source/_reference/shader.json b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduction_output/1/source/_reference/shader.json new file mode 100644 index 00000000..ef3502b5 --- /dev/null +++ b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduction_output/1/source/_reference/shader.json @@ -0,0 +1,17 @@ +{ + "one": { + "func": "glUniform1f", + "args": [ + 1.0 + ], + "binding": 0 + }, + "resolution": { + "func": "glUniform2f", + "args": [ + 256.0, + 256.0 + ], + "binding": 1 + } +} diff --git a/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduction_output/1/source/test.json b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduction_output/1/source/test.json new file mode 100644 index 00000000..cbfbac37 --- /dev/null +++ b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduction_output/1/source/test.json @@ -0,0 +1,70 @@ +{ + "binaries": [ + { + "name": "glslangValidator", + "path": "", + "tags": [ + "Debug" + ], + "version": "c0bcfaf3bae917c57bca49897eb7430cdf256c70" + }, + { + "name": "spirv-dis", + "path": "", + "tags": [ + "Debug" + ], + "version": "a0370efd589be33d5d9a85cfde2f85841b3755af" + }, + { + "name": "spirv-val", + "path": "", + "tags": [ + "Debug" + ], + "version": "a0370efd589be33d5d9a85cfde2f85841b3755af" + }, + { + "name": "amber", + "path": "", + "tags": [ + "Debug" + ], + "version": "cc1dec6104f5e0e656d8439296265a19393628df" + }, + { + "name": "amber_apk", + "path": "", + "tags": [ + "Debug" + ], + "version": "cc1dec6104f5e0e656d8439296265a19393628df" + }, + { + "name": "amber_apk_test", + "path": "", + "tags": [ + "Debug" + ], + "version": "cc1dec6104f5e0e656d8439296265a19393628df" + } + ], + "common_spirv_args": [], + "crash_regex_override": ".*ScalarEvolution9808.*", + "crash_signature": "llvmOptionalllvmScalarEvolutionLoopInvariantPredic", + "derived_from": "matrices_many_loops", + "device": { + "binaries": [], + "device_properties": " apiVersion: 1.2.145\n driverVersion: 83898368\n vendorID: 32902\n deviceID: 16024\n deviceType: integrated gpu\n deviceName: Intel(R) UHD Graphics 630 (CFL GT2)\n driverName: Intel open-source Mesa driver\n driverInfo: Mesa 20.3.0-rc1 (git-f44896c12a)\n minSubgroupSize: 8\n maxSubgroupSize: 32\n maxComputeWorkgroupSubgroups: 56\n requiredSubgroupSizeStages: comp\n", + "host": { + "custom_launcher": [] + }, + "ignored_crash_signatures": [], + "name": "host" + }, + "expected_status": "CRASH", + "glsl": { + "spirv_opt_args": [] + }, + "skip_validation": false +} diff --git a/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduction_output/1/source/variant/shader.frag b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduction_output/1/source/variant/shader.frag new file mode 100644 index 00000000..dc010dd2 --- /dev/null +++ b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduction_output/1/source/variant/shader.frag @@ -0,0 +1,54 @@ +#version 320 es +#define _int_20 _GLF_uniform_int_values[0] +#define _int_1 _GLF_uniform_int_values[1] +#define _int_0 _GLF_uniform_int_values[2] +#define _int_5 _GLF_uniform_int_values[3] +#define _int_3 _GLF_uniform_int_values[4] +#define _float_0_0 _GLF_uniform_float_values[0] + +precision highp float; + +precision highp int; + +// Contents of _GLF_uniform_float_values: 0.0 +layout(set = 0, binding = 0) uniform buf0 { + float _GLF_uniform_float_values[1]; +}; +// Contents of _GLF_uniform_int_values: [20, 1, 0, 5, 3] +layout(set = 0, binding = 1) uniform buf1 { + int _GLF_uniform_int_values[5]; +}; +const int _GLF_global_loop_bound = 10; + +int _GLF_global_loop_count = 0; + +layout(location = 0) out vec4 _GLF_color; + +void main() +{ + int a = _int_1; + for(int i = _int_0; i < _int_3; i ++) + { + if(gl_FragCoord.x > _float_0_0) + { + a ++; + } + } + while(_GLF_global_loop_count < _GLF_global_loop_bound) + { + _GLF_global_loop_count ++; + if(a * a + _int_1 > _int_20) + { + break; + } + a ++; + } + if(a == _int_5) + { + _GLF_color = vec4(_int_1, _int_0, _int_0, _int_1); + } + else + { + _GLF_color = vec4(_int_0); + } +} diff --git a/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduction_output/1/source/variant/shader.json b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduction_output/1/source/variant/shader.json new file mode 100644 index 00000000..e496cfa8 --- /dev/null +++ b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduction_output/1/source/variant/shader.json @@ -0,0 +1,22 @@ +{ + "_GLF_uniform_int_values": { + "func": "glUniform1iv", + "args": [ + 20, + 1, + 0, + 5, + 3 + ], + "count": 0, + "binding": 1 + }, + "_GLF_uniform_float_values": { + "func": "glUniform1fv", + "args": [ + 0.0 + ], + "count": 0, + "binding": 0 + } +} diff --git a/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduction_output/2/source/_reference/shader.frag b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduction_output/2/source/_reference/shader.frag new file mode 100644 index 00000000..b170a9fa --- /dev/null +++ b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduction_output/2/source/_reference/shader.frag @@ -0,0 +1,206 @@ +#version 320 es +precision highp float; + +layout(location = 0) out vec4 _GLF_color; + +layout(set = 0, binding = 0) uniform buf0 { + float one; +}; +layout(set = 0, binding = 1) uniform buf1 { + vec2 resolution; +}; +mat2 m22; + +mat2x3 m23; + +mat2x4 m24; + +mat3x2 m32; + +mat3 m33; + +mat3x4 m34; + +mat4x2 m42; + +mat4x3 m43; + +mat4 m44; + +void main() +{ + for(int c = 0; c < 2; c ++) + { + for(int r = 0; r < 2; r ++) + { + m22[c][r] = one; + } + } + ; + for(int c = 0; c < 2; c ++) + { + for(int r = 0; r < 3; r ++) + { + m23[c][r] = one; + } + } + ; + for(int c = 0; c < 2; c ++) + { + for(int r = 0; r < 4; r ++) + { + m24[c][r] = one; + } + } + ; + for(int c = 0; c < 3; c ++) + { + for(int r = 0; r < 2; r ++) + { + m32[c][r] = one; + } + } + ; + for(int c = 0; c < 3; c ++) + { + for(int r = 0; r < 3; r ++) + { + m33[c][r] = one; + } + } + ; + for(int c = 0; c < 3; c ++) + { + for(int r = 0; r < 4; r ++) + { + m34[c][r] = one; + } + } + ; + for(int c = 0; c < 4; c ++) + { + for(int r = 0; r < 2; r ++) + { + m42[c][r] = one; + } + } + ; + for(int c = 0; c < 4; c ++) + { + for(int r = 0; r < 3; r ++) + { + m43[c][r] = one; + } + } + ; + for(int c = 0; c < 4; c ++) + { + for(int r = 0; r < 4; r ++) + { + m44[c][r] = one; + } + } + ; + float sums[9]; + sums[0] = 0.0; + for(int c = 0; c < 2; c ++) + { + for(int r = 0; r < 2; r ++) + { + sums[0] += m22[c][r]; + } + } + sums[0] /= 16.0; + ; + sums[1] = 0.0; + for(int c = 0; c < 2; c ++) + { + for(int r = 0; r < 3; r ++) + { + sums[1] += m23[c][r]; + } + } + sums[1] /= 16.0; + ; + sums[2] = 0.0; + for(int c = 0; c < 2; c ++) + { + for(int r = 0; r < 4; r ++) + { + sums[2] += m24[c][r]; + } + } + sums[2] /= 16.0; + ; + sums[3] = 0.0; + for(int c = 0; c < 3; c ++) + { + for(int r = 0; r < 2; r ++) + { + sums[3] += m32[c][r]; + } + } + sums[3] /= 16.0; + ; + sums[4] = 0.0; + for(int c = 0; c < 3; c ++) + { + for(int r = 0; r < 3; r ++) + { + sums[4] += m33[c][r]; + } + } + sums[4] /= 16.0; + ; + sums[5] = 0.0; + for(int c = 0; c < 3; c ++) + { + for(int r = 0; r < 4; r ++) + { + sums[5] += m34[c][r]; + } + } + sums[5] /= 16.0; + ; + sums[6] = 0.0; + for(int c = 0; c < 4; c ++) + { + for(int r = 0; r < 2; r ++) + { + sums[6] += m42[c][r]; + } + } + sums[6] /= 16.0; + ; + sums[7] = 0.0; + for(int c = 0; c < 4; c ++) + { + for(int r = 0; r < 3; r ++) + { + sums[7] += m43[c][r]; + } + } + sums[7] /= 16.0; + ; + sums[8] = 0.0; + for(int c = 0; c < 4; c ++) + { + for(int r = 0; r < 4; r ++) + { + sums[8] += m44[c][r]; + } + } + sums[8] /= 16.0; + ; + int region_x = int(gl_FragCoord.x / (resolution.x / 3.0)); + int region_y = int(gl_FragCoord.y / (resolution.x / 3.0)); + int overall_region = region_y * 3 + region_x; + if(overall_region > 0 && overall_region < 9) + { + _GLF_color = vec4(vec3(sums[overall_region]), 1.0); + } + else + { + _GLF_color = vec4(vec3(0.0), 1.0); + } +} diff --git a/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduction_output/2/source/_reference/shader.json b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduction_output/2/source/_reference/shader.json new file mode 100644 index 00000000..ef3502b5 --- /dev/null +++ b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduction_output/2/source/_reference/shader.json @@ -0,0 +1,17 @@ +{ + "one": { + "func": "glUniform1f", + "args": [ + 1.0 + ], + "binding": 0 + }, + "resolution": { + "func": "glUniform2f", + "args": [ + 256.0, + 256.0 + ], + "binding": 1 + } +} diff --git a/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduction_output/2/source/test.json b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduction_output/2/source/test.json new file mode 100644 index 00000000..cbfbac37 --- /dev/null +++ b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduction_output/2/source/test.json @@ -0,0 +1,70 @@ +{ + "binaries": [ + { + "name": "glslangValidator", + "path": "", + "tags": [ + "Debug" + ], + "version": "c0bcfaf3bae917c57bca49897eb7430cdf256c70" + }, + { + "name": "spirv-dis", + "path": "", + "tags": [ + "Debug" + ], + "version": "a0370efd589be33d5d9a85cfde2f85841b3755af" + }, + { + "name": "spirv-val", + "path": "", + "tags": [ + "Debug" + ], + "version": "a0370efd589be33d5d9a85cfde2f85841b3755af" + }, + { + "name": "amber", + "path": "", + "tags": [ + "Debug" + ], + "version": "cc1dec6104f5e0e656d8439296265a19393628df" + }, + { + "name": "amber_apk", + "path": "", + "tags": [ + "Debug" + ], + "version": "cc1dec6104f5e0e656d8439296265a19393628df" + }, + { + "name": "amber_apk_test", + "path": "", + "tags": [ + "Debug" + ], + "version": "cc1dec6104f5e0e656d8439296265a19393628df" + } + ], + "common_spirv_args": [], + "crash_regex_override": ".*ScalarEvolution9808.*", + "crash_signature": "llvmOptionalllvmScalarEvolutionLoopInvariantPredic", + "derived_from": "matrices_many_loops", + "device": { + "binaries": [], + "device_properties": " apiVersion: 1.2.145\n driverVersion: 83898368\n vendorID: 32902\n deviceID: 16024\n deviceType: integrated gpu\n deviceName: Intel(R) UHD Graphics 630 (CFL GT2)\n driverName: Intel open-source Mesa driver\n driverInfo: Mesa 20.3.0-rc1 (git-f44896c12a)\n minSubgroupSize: 8\n maxSubgroupSize: 32\n maxComputeWorkgroupSubgroups: 56\n requiredSubgroupSizeStages: comp\n", + "host": { + "custom_launcher": [] + }, + "ignored_crash_signatures": [], + "name": "host" + }, + "expected_status": "CRASH", + "glsl": { + "spirv_opt_args": [] + }, + "skip_validation": false +} diff --git a/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduction_output/2/source/variant/shader.frag b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduction_output/2/source/variant/shader.frag new file mode 100644 index 00000000..dc010dd2 --- /dev/null +++ b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduction_output/2/source/variant/shader.frag @@ -0,0 +1,54 @@ +#version 320 es +#define _int_20 _GLF_uniform_int_values[0] +#define _int_1 _GLF_uniform_int_values[1] +#define _int_0 _GLF_uniform_int_values[2] +#define _int_5 _GLF_uniform_int_values[3] +#define _int_3 _GLF_uniform_int_values[4] +#define _float_0_0 _GLF_uniform_float_values[0] + +precision highp float; + +precision highp int; + +// Contents of _GLF_uniform_float_values: 0.0 +layout(set = 0, binding = 0) uniform buf0 { + float _GLF_uniform_float_values[1]; +}; +// Contents of _GLF_uniform_int_values: [20, 1, 0, 5, 3] +layout(set = 0, binding = 1) uniform buf1 { + int _GLF_uniform_int_values[5]; +}; +const int _GLF_global_loop_bound = 10; + +int _GLF_global_loop_count = 0; + +layout(location = 0) out vec4 _GLF_color; + +void main() +{ + int a = _int_1; + for(int i = _int_0; i < _int_3; i ++) + { + if(gl_FragCoord.x > _float_0_0) + { + a ++; + } + } + while(_GLF_global_loop_count < _GLF_global_loop_bound) + { + _GLF_global_loop_count ++; + if(a * a + _int_1 > _int_20) + { + break; + } + a ++; + } + if(a == _int_5) + { + _GLF_color = vec4(_int_1, _int_0, _int_0, _int_1); + } + else + { + _GLF_color = vec4(_int_0); + } +} diff --git a/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduction_output/2/source/variant/shader.json b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduction_output/2/source/variant/shader.json new file mode 100644 index 00000000..e496cfa8 --- /dev/null +++ b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduction_output/2/source/variant/shader.json @@ -0,0 +1,22 @@ +{ + "_GLF_uniform_int_values": { + "func": "glUniform1iv", + "args": [ + 20, + 1, + 0, + 5, + 3 + ], + "count": 0, + "binding": 1 + }, + "_GLF_uniform_float_values": { + "func": "glUniform1fv", + "args": [ + 0.0 + ], + "count": 0, + "binding": 0 + } +} diff --git a/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduction_output/best b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduction_output/best new file mode 120000 index 00000000..d8263ee9 --- /dev/null +++ b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/reduction_output/best @@ -0,0 +1 @@ +2 \ No newline at end of file diff --git a/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/settings.json b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/settings.json new file mode 100644 index 00000000..1232757f --- /dev/null +++ b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/settings.json @@ -0,0 +1,197 @@ +{ + "_comment": "https://github.com/google/graphicsfuzz/blob/master/gfauto/gfauto/settings.proto", + "common_spirv_args": [], + "custom_binaries": [], + "device_list": { + "active_device_names": [ + "host_preprocessor", + "swift_shader", + "host" + ], + "devices": [ + { + "binaries": [], + "device_properties": "", + "ignored_crash_signatures": [], + "name": "host_preprocessor", + "preprocess": {} + }, + { + "binaries": [ + { + "name": "swift_shader_icd", + "path": "", + "tags": [ + "Debug" + ], + "version": "8f075627d16bdd2a8d861e9d81df541f5cf68e2e" + } + ], + "device_properties": " apiVersion: 1.2.0\n driverVersion: 20971520\n vendorID: 6880\n deviceID: 49374\n deviceType: cpu\n deviceName: SwiftShader Device (LLVM 10.0.0)\n driverName: SwiftShader driver\n driverInfo: \n", + "ignored_crash_signatures": [], + "name": "swift_shader", + "swift_shader": {} + }, + { + "binaries": [], + "device_properties": " apiVersion: 1.2.174\n driverVersion: 8388792\n vendorID: 4098\n deviceID: 29471\n deviceType: discrete gpu\n deviceName: AMD Radeon RX 5700 XT\n driverName: AMD open-source driver\n driverInfo: \n minSubgroupSize: 32\n maxSubgroupSize: 64\n maxComputeWorkgroupSubgroups: 4294967295\n requiredSubgroupSizeStages: \n", + "host": { + "custom_launcher": [] + }, + "ignored_crash_signatures": [], + "name": "host" + }, + { + "binaries": [ + { + "name": "amdllpc", + "path": "", + "tags": [ + "Debug" + ], + "version": "f9a85a5a2cd20884bcfa7794f74aa3516d1892c1" + } + ], + "device_properties": "", + "ignored_crash_signatures": [], + "name": "amdllpc", + "shader_compiler": { + "args": [ + "-val=false", + "-gfxip=9.0.0", + "-verify-ir", + "-auto-layout-desc" + ], + "binary": "amdllpc" + } + } + ] + }, + "extra_graphics_fuzz_generate_args": [], + "extra_graphics_fuzz_reduce_args": [], + "extra_spirv_fuzz_generate_args": [], + "extra_spirv_fuzz_shrink_args": [], + "extra_spirv_reduce_args": [], + "keep_reduction_work": false, + "latest_binary_versions": [ + { + "name": "glslangValidator", + "path": "", + "tags": [ + "Debug" + ], + "version": "e0771b5d4c7e64a4354e1aa93fb2a673b2a08010" + }, + { + "name": "spirv-opt", + "path": "", + "tags": [ + "Debug" + ], + "version": "06f114d482143bd3c2fae6c8d8174a39521b09ce" + }, + { + "name": "spirv-dis", + "path": "", + "tags": [ + "Debug" + ], + "version": "06f114d482143bd3c2fae6c8d8174a39521b09ce" + }, + { + "name": "spirv-as", + "path": "", + "tags": [ + "Debug" + ], + "version": "06f114d482143bd3c2fae6c8d8174a39521b09ce" + }, + { + "name": "spirv-val", + "path": "", + "tags": [ + "Debug" + ], + "version": "06f114d482143bd3c2fae6c8d8174a39521b09ce" + }, + { + "name": "spirv-fuzz", + "path": "", + "tags": [ + "Debug" + ], + "version": "06f114d482143bd3c2fae6c8d8174a39521b09ce" + }, + { + "name": "spirv-reduce", + "path": "", + "tags": [ + "Debug" + ], + "version": "06f114d482143bd3c2fae6c8d8174a39521b09ce" + }, + { + "name": "swift_shader_icd", + "path": "", + "tags": [ + "Debug" + ], + "version": "8f075627d16bdd2a8d861e9d81df541f5cf68e2e" + }, + { + "name": "amber", + "path": "", + "tags": [ + "Debug" + ], + "version": "8c3bfef40c2387944fdc81746e2e3249e4da5566" + }, + { + "name": "amber_apk", + "path": "", + "tags": [ + "Debug" + ], + "version": "8c3bfef40c2387944fdc81746e2e3249e4da5566" + }, + { + "name": "amber_apk_test", + "path": "", + "tags": [ + "Debug" + ], + "version": "8c3bfef40c2387944fdc81746e2e3249e4da5566" + }, + { + "name": "amber_vulkan_loader", + "path": "", + "tags": [ + "Debug" + ], + "version": "8c3bfef40c2387944fdc81746e2e3249e4da5566" + }, + { + "name": "graphicsfuzz-tool", + "path": "", + "tags": [], + "version": "4221987bacb5d1468422e4813f05121b1b60fd35" + }, + { + "name": "amdllpc", + "path": "", + "tags": [ + "Debug" + ], + "version": "f9a85a5a2cd20884bcfa7794f74aa3516d1892c1" + } + ], + "legacy_graphics_fuzz_vulkan_arg": false, + "maximum_duplicate_crashes": 3, + "maximum_fuzz_failures": 10, + "only_reduce_signature_regex": "", + "reduce_bad_images": true, + "reduce_crashes": true, + "reduce_tool_crashes": true, + "skip_semantics_changing_reduction": false, + "spirv_opt_just_o": false +} \ No newline at end of file diff --git a/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/work/variant/0_glsl/shader.frag b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/work/variant/0_glsl/shader.frag new file mode 100644 index 00000000..85c11f06 --- /dev/null +++ b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/work/variant/0_glsl/shader.frag @@ -0,0 +1,64 @@ +#version 320 es +#define _int_20 _GLF_uniform_int_values[0] +#define _int_1 _GLF_uniform_int_values[1] +#define _int_0 _GLF_uniform_int_values[2] +#define _int_5 _GLF_uniform_int_values[3] +#define _int_3 _GLF_uniform_int_values[4] +#define _float_0_0 _GLF_uniform_float_values[0] + +precision highp float; +precision highp int; + +// Contents of _GLF_uniform_float_values: 0.0 +layout(set = 0, binding = 0) uniform buf0 +{ + float _GLF_uniform_float_values[1]; +}; + +// Contents of _GLF_uniform_int_values: [20, 1, 0, 5, 3] +layout(set = 0, binding = 1) uniform buf1 +{ + int _GLF_uniform_int_values[5]; +}; + +const int _GLF_global_loop_bound = 10; +int _GLF_global_loop_count = 0; + +layout(location = 0) out vec4 _GLF_color; + +void main() +{ + int a = _int_1; + + for(int i = _int_0; i < _int_3; i++) + { + // Always true. + if(gl_FragCoord.x > _float_0_0) + { + a++; + } + } + + while(_GLF_global_loop_count < _GLF_global_loop_bound) + { + _GLF_global_loop_count ++; + + // Breaks when a is five. + if(a * a + _int_1 > _int_20) + { + break; + } + + a++; + } + + // Always true. + if(a == _int_5) + { + _GLF_color = vec4(_int_1, _int_0, _int_0, _int_1); + } + else + { + _GLF_color = vec4(_int_0); + } +} diff --git a/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/work/variant/0_glsl/shader.json b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/work/variant/0_glsl/shader.json new file mode 100644 index 00000000..e496cfa8 --- /dev/null +++ b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/work/variant/0_glsl/shader.json @@ -0,0 +1,22 @@ +{ + "_GLF_uniform_int_values": { + "func": "glUniform1iv", + "args": [ + 20, + 1, + 0, + 5, + 3 + ], + "count": 0, + "binding": 1 + }, + "_GLF_uniform_float_values": { + "func": "glUniform1fv", + "args": [ + 0.0 + ], + "count": 0, + "binding": 0 + } +} diff --git a/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/work/variant/1_spirv/shader.frag.spv b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/work/variant/1_spirv/shader.frag.spv new file mode 100644 index 00000000..0044faf2 Binary files /dev/null and b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/work/variant/1_spirv/shader.frag.spv differ diff --git a/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/work/variant/1_spirv/shader.json b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/work/variant/1_spirv/shader.json new file mode 100644 index 00000000..e496cfa8 --- /dev/null +++ b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/work/variant/1_spirv/shader.json @@ -0,0 +1,22 @@ +{ + "_GLF_uniform_int_values": { + "func": "glUniform1iv", + "args": [ + 20, + 1, + 0, + 5, + 3 + ], + "count": 0, + "binding": 1 + }, + "_GLF_uniform_float_values": { + "func": "glUniform1fv", + "args": [ + 0.0 + ], + "count": 0, + "binding": 0 + } +} diff --git a/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/work/variant/1_spirv_asm/shader.frag.asm b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/work/variant/1_spirv_asm/shader.frag.asm new file mode 100644 index 00000000..4bfb1c76 --- /dev/null +++ b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/work/variant/1_spirv_asm/shader.frag.asm @@ -0,0 +1,176 @@ +; SPIR-V +; Version: 1.0 +; Generator: Khronos Glslang Reference Front End; 10 +; Bound: 111 +; Schema: 0 + OpCapability Shader + %1 = OpExtInstImport "GLSL.std.450" + OpMemoryModel Logical GLSL450 + OpEntryPoint Fragment %4 "main" %40 %92 + OpExecutionMode %4 OriginUpperLeft + OpSource ESSL 320 + OpName %4 "main" + OpName %8 "_GLF_global_loop_count" + OpName %11 "a" + OpName %15 "buf1" + OpMemberName %15 0 "_GLF_uniform_int_values" + OpName %17 "" + OpName %22 "i" + OpName %40 "gl_FragCoord" + OpName %47 "buf0" + OpMemberName %47 0 "_GLF_uniform_float_values" + OpName %49 "" + OpName %92 "_GLF_color" + OpDecorate %14 ArrayStride 16 + OpMemberDecorate %15 0 Offset 0 + OpDecorate %15 Block + OpDecorate %17 DescriptorSet 0 + OpDecorate %17 Binding 1 + OpDecorate %40 BuiltIn FragCoord + OpDecorate %46 ArrayStride 16 + OpMemberDecorate %47 0 Offset 0 + OpDecorate %47 Block + OpDecorate %49 DescriptorSet 0 + OpDecorate %49 Binding 0 + OpDecorate %92 Location 0 + %2 = OpTypeVoid + %3 = OpTypeFunction %2 + %6 = OpTypeInt 32 1 + %7 = OpTypePointer Private %6 + %8 = OpVariable %7 Private + %9 = OpConstant %6 0 + %10 = OpTypePointer Function %6 + %12 = OpTypeInt 32 0 + %13 = OpConstant %12 5 + %14 = OpTypeArray %6 %13 + %15 = OpTypeStruct %14 + %16 = OpTypePointer Uniform %15 + %17 = OpVariable %16 Uniform + %18 = OpConstant %6 1 + %19 = OpTypePointer Uniform %6 + %23 = OpConstant %6 2 + %32 = OpConstant %6 4 + %35 = OpTypeBool + %37 = OpTypeFloat 32 + %38 = OpTypeVector %37 4 + %39 = OpTypePointer Input %38 + %40 = OpVariable %39 Input + %41 = OpConstant %12 0 + %42 = OpTypePointer Input %37 + %45 = OpConstant %12 1 + %46 = OpTypeArray %37 %45 + %47 = OpTypeStruct %46 + %48 = OpTypePointer Uniform %47 + %49 = OpVariable %48 Uniform + %50 = OpTypePointer Uniform %37 + %66 = OpConstant %6 10 + %85 = OpConstant %6 3 + %91 = OpTypePointer Output %38 + %92 = OpVariable %91 Output + %4 = OpFunction %2 None %3 + %5 = OpLabel + %11 = OpVariable %10 Function + %22 = OpVariable %10 Function + OpStore %8 %9 + %20 = OpAccessChain %19 %17 %9 %18 + %21 = OpLoad %6 %20 + OpStore %11 %21 + %24 = OpAccessChain %19 %17 %9 %23 + %25 = OpLoad %6 %24 + OpStore %22 %25 + OpBranch %26 + %26 = OpLabel + OpLoopMerge %28 %29 None + OpBranch %30 + %30 = OpLabel + %31 = OpLoad %6 %22 + %33 = OpAccessChain %19 %17 %9 %32 + %34 = OpLoad %6 %33 + %36 = OpSLessThan %35 %31 %34 + OpBranchConditional %36 %27 %28 + %27 = OpLabel + %43 = OpAccessChain %42 %40 %41 + %44 = OpLoad %37 %43 + %51 = OpAccessChain %50 %49 %9 %9 + %52 = OpLoad %37 %51 + %53 = OpFOrdGreaterThan %35 %44 %52 + OpSelectionMerge %55 None + OpBranchConditional %53 %54 %55 + %54 = OpLabel + %56 = OpLoad %6 %11 + %57 = OpIAdd %6 %56 %18 + OpStore %11 %57 + OpBranch %55 + %55 = OpLabel + OpBranch %29 + %29 = OpLabel + %58 = OpLoad %6 %22 + %59 = OpIAdd %6 %58 %18 + OpStore %22 %59 + OpBranch %26 + %28 = OpLabel + OpBranch %60 + %60 = OpLabel + OpLoopMerge %62 %63 None + OpBranch %64 + %64 = OpLabel + %65 = OpLoad %6 %8 + %67 = OpSLessThan %35 %65 %66 + OpBranchConditional %67 %61 %62 + %61 = OpLabel + %68 = OpLoad %6 %8 + %69 = OpIAdd %6 %68 %18 + OpStore %8 %69 + %70 = OpLoad %6 %11 + %71 = OpLoad %6 %11 + %72 = OpIMul %6 %70 %71 + %73 = OpAccessChain %19 %17 %9 %18 + %74 = OpLoad %6 %73 + %75 = OpIAdd %6 %72 %74 + %76 = OpAccessChain %19 %17 %9 %9 + %77 = OpLoad %6 %76 + %78 = OpSGreaterThan %35 %75 %77 + OpSelectionMerge %80 None + OpBranchConditional %78 %79 %80 + %79 = OpLabel + OpBranch %62 + %80 = OpLabel + %82 = OpLoad %6 %11 + %83 = OpIAdd %6 %82 %18 + OpStore %11 %83 + OpBranch %63 + %63 = OpLabel + OpBranch %60 + %62 = OpLabel + %84 = OpLoad %6 %11 + %86 = OpAccessChain %19 %17 %9 %85 + %87 = OpLoad %6 %86 + %88 = OpIEqual %35 %84 %87 + OpSelectionMerge %90 None + OpBranchConditional %88 %89 %106 + %89 = OpLabel + %93 = OpAccessChain %19 %17 %9 %18 + %94 = OpLoad %6 %93 + %95 = OpConvertSToF %37 %94 + %96 = OpAccessChain %19 %17 %9 %23 + %97 = OpLoad %6 %96 + %98 = OpConvertSToF %37 %97 + %99 = OpAccessChain %19 %17 %9 %23 + %100 = OpLoad %6 %99 + %101 = OpConvertSToF %37 %100 + %102 = OpAccessChain %19 %17 %9 %18 + %103 = OpLoad %6 %102 + %104 = OpConvertSToF %37 %103 + %105 = OpCompositeConstruct %38 %95 %98 %101 %104 + OpStore %92 %105 + OpBranch %90 + %106 = OpLabel + %107 = OpAccessChain %19 %17 %9 %23 + %108 = OpLoad %6 %107 + %109 = OpConvertSToF %37 %108 + %110 = OpCompositeConstruct %38 %109 %109 %109 %109 + OpStore %92 %110 + OpBranch %90 + %90 = OpLabel + OpReturn + OpFunctionEnd diff --git a/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/work/variant/1_spirv_asm/shader.json b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/work/variant/1_spirv_asm/shader.json new file mode 100644 index 00000000..e496cfa8 --- /dev/null +++ b/coverage/PENDING_SUBMIT/amdvlk/0711-COVERAGE-scalar-evolution-9808/work/variant/1_spirv_asm/shader.json @@ -0,0 +1,22 @@ +{ + "_GLF_uniform_int_values": { + "func": "glUniform1iv", + "args": [ + 20, + 1, + 0, + 5, + 3 + ], + "count": 0, + "binding": 1 + }, + "_GLF_uniform_float_values": { + "func": "glUniform1fv", + "args": [ + 0.0 + ], + "count": 0, + "binding": 0 + } +}