This commit adds a batch of GraphicsFuzz coverage tests.
Components: Vulkan
New Tests:
dEQP-VK.graphicsfuzz.cov-bitwise-shift-right-full-bits-no-effect-clamp
dEQP-VK.graphicsfuzz.cov-conditions-empty-blocks-index-array-one-divided-by-findlsb
dEQP-VK.graphicsfuzz.cov-discard-condition-loop-same-condition-again
dEQP-VK.graphicsfuzz.cov-global-loop-counter-for-loop-function-call-inside-never-called
dEQP-VK.graphicsfuzz.cov-ivec-from-uniform-float-shift-right-add-components
dEQP-VK.graphicsfuzz.cov-loop-increment-integer-set-output-color-break
dEQP-VK.graphicsfuzz.cov-multiple-loops-same-condition-always-false-global-loop-counter
dEQP-VK.graphicsfuzz.cov-nested-loops-increase-integer-dot-product
Change-Id: I8be6b8c3d5ee2a3b2803b51de4f5e38591528935
dEQP-VK.graphicsfuzz.cov-bitwise-and-variable-and-its-negation
dEQP-VK.graphicsfuzz.cov-bitwise-inverse-uniform-condition
dEQP-VK.graphicsfuzz.cov-bitwise-shift-right-always-select-one
+dEQP-VK.graphicsfuzz.cov-bitwise-shift-right-full-bits-no-effect-clamp
dEQP-VK.graphicsfuzz.cov-blockfrequency-several-for-loops
dEQP-VK.graphicsfuzz.cov-branch-probability-identity-matrix
dEQP-VK.graphicsfuzz.cov-cast-float-to-int-and-back
dEQP-VK.graphicsfuzz.cov-condition-loop-index-bitwise-not
dEQP-VK.graphicsfuzz.cov-condition-matrix-determinant-uniform
dEQP-VK.graphicsfuzz.cov-conditional-discard-inside-loop
+dEQP-VK.graphicsfuzz.cov-conditions-empty-blocks-index-array-one-divided-by-findlsb
dEQP-VK.graphicsfuzz.cov-const-folding-bitfieldinsert-div-one
dEQP-VK.graphicsfuzz.cov-color-overwrite-identity-matrix-multiply
dEQP-VK.graphicsfuzz.cov-const-folding-ceil-vec4
dEQP-VK.graphicsfuzz.cov-descending-loop-min-max-always-zero
dEQP-VK.graphicsfuzz.cov-determinant-uninitialized-matrix-never-chosen
dEQP-VK.graphicsfuzz.cov-dfdx-dfdy-after-nested-loops
+dEQP-VK.graphicsfuzz.cov-discard-condition-loop-same-condition-again
dEQP-VK.graphicsfuzz.cov-divide-matrix-transpose-by-constant
dEQP-VK.graphicsfuzz.cov-do-while-loop-until-uniform-lt-itself
dEQP-VK.graphicsfuzz.cov-do-while-negative-iterator-nested-loops-increment-array-element
dEQP-VK.graphicsfuzz.cov-global-loop-bound-true-logical-or
dEQP-VK.graphicsfuzz.cov-global-loop-counter-exhaust-calling-function-twice
dEQP-VK.graphicsfuzz.cov-global-loop-counter-float-accumulate-matrix
+dEQP-VK.graphicsfuzz.cov-global-loop-counter-for-loop-function-call-inside-never-called
dEQP-VK.graphicsfuzz.cov-global-loop-counter-main-function-call
dEQP-VK.graphicsfuzz.cov-global-loop-counter-multiply-one-minus
dEQP-VK.graphicsfuzz.cov-global-loop-counter-read-past-matrix-size-never-executed
dEQP-VK.graphicsfuzz.cov-ir-builder-constant-fold-inst-combine-calls-value-tracking-findmsb-incr-if
dEQP-VK.graphicsfuzz.cov-irbuilder-matrix-cell-uniform
dEQP-VK.graphicsfuzz.cov-isnan-asinh-clamp-always-zero
+dEQP-VK.graphicsfuzz.cov-ivec-from-uniform-float-shift-right-add-components
dEQP-VK.graphicsfuzz.cov-ivec-shift-right-by-large-number
dEQP-VK.graphicsfuzz.cov-large-for-loop-exit-early-set-iterator-array-element
dEQP-VK.graphicsfuzz.cov-large-int-array-nested-loops-set-ivec-index-component-sum
dEQP-VK.graphicsfuzz.cov-loop-fragcoord-identical-condition
dEQP-VK.graphicsfuzz.cov-loop-increment-array-elements-clamp-index
dEQP-VK.graphicsfuzz.cov-loop-increment-integer-findmsb-minus-uniform
+dEQP-VK.graphicsfuzz.cov-loop-increment-integer-set-output-color-break
dEQP-VK.graphicsfuzz.cov-loop-increment-matrix-element-break-after-first-iteration
dEQP-VK.graphicsfuzz.cov-loop-increment-or-divide-by-loop-index
dEQP-VK.graphicsfuzz.cov-loop-integer-half-minus-one
dEQP-VK.graphicsfuzz.cov-modulo-zero-never-executed
dEQP-VK.graphicsfuzz.cov-multiple-fragcoord-conditions-false-never-return-sample-texture
dEQP-VK.graphicsfuzz.cov-multiple-fragcoord-conditions-never-return-color-uninitialized
+dEQP-VK.graphicsfuzz.cov-multiple-loops-same-condition-always-false-global-loop-counter
dEQP-VK.graphicsfuzz.cov-multiple-one-iteration-loops-global-counter-write-matrices
dEQP-VK.graphicsfuzz.cov-nested-functions-accumulate-global-matrix
dEQP-VK.graphicsfuzz.cov-nested-functions-compare-fragcood-length-zero-vector
dEQP-VK.graphicsfuzz.cov-nested-loops-global-loop-counter-do-while-accumulate-float
dEQP-VK.graphicsfuzz.cov-nested-loops-global-loop-counter-fragcoord-negative-always-false
dEQP-VK.graphicsfuzz.cov-nested-loops-global-loop-counter-iterator-dependency
+dEQP-VK.graphicsfuzz.cov-nested-loops-increase-integer-dot-product
dEQP-VK.graphicsfuzz.cov-nested-loops-redundant-condition
dEQP-VK.graphicsfuzz.cov-nested-loops-sample-opposite-corners
dEQP-VK.graphicsfuzz.cov-nested-loops-set-struct-data-verify-in-function
dEQP-VK.graphicsfuzz.cov-bitwise-and-variable-and-its-negation
dEQP-VK.graphicsfuzz.cov-bitwise-inverse-uniform-condition
dEQP-VK.graphicsfuzz.cov-bitwise-shift-right-always-select-one
+dEQP-VK.graphicsfuzz.cov-bitwise-shift-right-full-bits-no-effect-clamp
dEQP-VK.graphicsfuzz.cov-blockfrequency-several-for-loops
dEQP-VK.graphicsfuzz.cov-branch-probability-identity-matrix
dEQP-VK.graphicsfuzz.cov-cast-float-to-int-and-back
dEQP-VK.graphicsfuzz.cov-condition-loop-index-bitwise-not
dEQP-VK.graphicsfuzz.cov-condition-matrix-determinant-uniform
dEQP-VK.graphicsfuzz.cov-conditional-discard-inside-loop
+dEQP-VK.graphicsfuzz.cov-conditions-empty-blocks-index-array-one-divided-by-findlsb
dEQP-VK.graphicsfuzz.cov-const-folding-bitfieldinsert-div-one
dEQP-VK.graphicsfuzz.cov-color-overwrite-identity-matrix-multiply
dEQP-VK.graphicsfuzz.cov-const-folding-ceil-vec4
dEQP-VK.graphicsfuzz.cov-descending-loop-min-max-always-zero
dEQP-VK.graphicsfuzz.cov-determinant-uninitialized-matrix-never-chosen
dEQP-VK.graphicsfuzz.cov-dfdx-dfdy-after-nested-loops
+dEQP-VK.graphicsfuzz.cov-discard-condition-loop-same-condition-again
dEQP-VK.graphicsfuzz.cov-divide-matrix-transpose-by-constant
dEQP-VK.graphicsfuzz.cov-do-while-loop-until-uniform-lt-itself
dEQP-VK.graphicsfuzz.cov-do-while-negative-iterator-nested-loops-increment-array-element
dEQP-VK.graphicsfuzz.cov-global-loop-bound-true-logical-or
dEQP-VK.graphicsfuzz.cov-global-loop-counter-exhaust-calling-function-twice
dEQP-VK.graphicsfuzz.cov-global-loop-counter-float-accumulate-matrix
+dEQP-VK.graphicsfuzz.cov-global-loop-counter-for-loop-function-call-inside-never-called
dEQP-VK.graphicsfuzz.cov-global-loop-counter-main-function-call
dEQP-VK.graphicsfuzz.cov-global-loop-counter-multiply-one-minus
dEQP-VK.graphicsfuzz.cov-global-loop-counter-read-past-matrix-size-never-executed
dEQP-VK.graphicsfuzz.cov-ir-builder-constant-fold-inst-combine-calls-value-tracking-findmsb-incr-if
dEQP-VK.graphicsfuzz.cov-irbuilder-matrix-cell-uniform
dEQP-VK.graphicsfuzz.cov-isnan-asinh-clamp-always-zero
+dEQP-VK.graphicsfuzz.cov-ivec-from-uniform-float-shift-right-add-components
dEQP-VK.graphicsfuzz.cov-ivec-shift-right-by-large-number
dEQP-VK.graphicsfuzz.cov-large-for-loop-exit-early-set-iterator-array-element
dEQP-VK.graphicsfuzz.cov-large-int-array-nested-loops-set-ivec-index-component-sum
dEQP-VK.graphicsfuzz.cov-loop-fragcoord-identical-condition
dEQP-VK.graphicsfuzz.cov-loop-increment-array-elements-clamp-index
dEQP-VK.graphicsfuzz.cov-loop-increment-integer-findmsb-minus-uniform
+dEQP-VK.graphicsfuzz.cov-loop-increment-integer-set-output-color-break
dEQP-VK.graphicsfuzz.cov-loop-increment-matrix-element-break-after-first-iteration
dEQP-VK.graphicsfuzz.cov-loop-increment-or-divide-by-loop-index
dEQP-VK.graphicsfuzz.cov-loop-integer-half-minus-one
dEQP-VK.graphicsfuzz.cov-modulo-zero-never-executed
dEQP-VK.graphicsfuzz.cov-multiple-fragcoord-conditions-false-never-return-sample-texture
dEQP-VK.graphicsfuzz.cov-multiple-fragcoord-conditions-never-return-color-uninitialized
+dEQP-VK.graphicsfuzz.cov-multiple-loops-same-condition-always-false-global-loop-counter
dEQP-VK.graphicsfuzz.cov-multiple-one-iteration-loops-global-counter-write-matrices
dEQP-VK.graphicsfuzz.cov-nested-functions-accumulate-global-matrix
dEQP-VK.graphicsfuzz.cov-nested-functions-compare-fragcood-length-zero-vector
dEQP-VK.graphicsfuzz.cov-nested-loops-global-loop-counter-do-while-accumulate-float
dEQP-VK.graphicsfuzz.cov-nested-loops-global-loop-counter-fragcoord-negative-always-false
dEQP-VK.graphicsfuzz.cov-nested-loops-global-loop-counter-iterator-dependency
+dEQP-VK.graphicsfuzz.cov-nested-loops-increase-integer-dot-product
dEQP-VK.graphicsfuzz.cov-nested-loops-redundant-condition
dEQP-VK.graphicsfuzz.cov-nested-loops-sample-opposite-corners
dEQP-VK.graphicsfuzz.cov-nested-loops-set-struct-data-verify-in-function
--- /dev/null
+#!amber
+
+# Copyright 2021 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
+#
+# precision highp float;
+# precision highp int;
+#
+# layout(set = 0, binding = 0) uniform buf0
+# {
+# int one;
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void main()
+# {
+# // Arithmetic shift replicates the sign bit.
+# int a = 0xffffffff >> one;
+# // Clamps to 2.0.
+# float f = clamp(5.0, 1.0, (a == 0xffffffff) ? 2.0 : 3.0);
+#
+# // Always true.
+# if (int(f) == 2)
+# _GLF_color = vec4(1, 0, 0, 1);
+# else
+# _GLF_color = vec4(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: 43
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %38
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %8 "a"
+ OpName %10 "buf0"
+ OpMemberName %10 0 "one"
+ OpName %12 ""
+ OpName %20 "f"
+ OpName %38 "_GLF_color"
+ OpMemberDecorate %10 0 Offset 0
+ OpDecorate %10 Block
+ OpDecorate %12 DescriptorSet 0
+ OpDecorate %12 Binding 0
+ OpDecorate %38 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeInt 32 1
+ %7 = OpTypePointer Function %6
+ %9 = OpConstant %6 -1
+ %10 = OpTypeStruct %6
+ %11 = OpTypePointer Uniform %10
+ %12 = OpVariable %11 Uniform
+ %13 = OpConstant %6 0
+ %14 = OpTypePointer Uniform %6
+ %18 = OpTypeFloat 32
+ %19 = OpTypePointer Function %18
+ %21 = OpConstant %18 5
+ %22 = OpConstant %18 1
+ %24 = OpTypeBool
+ %26 = OpConstant %18 2
+ %27 = OpConstant %18 3
+ %32 = OpConstant %6 2
+ %36 = OpTypeVector %18 4
+ %37 = OpTypePointer Output %36
+ %38 = OpVariable %37 Output
+ %39 = OpConstant %18 0
+ %40 = OpConstantComposite %36 %22 %39 %39 %22
+ %42 = OpConstantComposite %36 %39 %39 %39 %39
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %8 = OpVariable %7 Function
+ %20 = OpVariable %19 Function
+ %15 = OpAccessChain %14 %12 %13
+ %16 = OpLoad %6 %15
+ %17 = OpShiftRightArithmetic %6 %9 %16
+ OpStore %8 %17
+ %23 = OpLoad %6 %8
+ %25 = OpIEqual %24 %23 %9
+ %28 = OpSelect %18 %25 %26 %27
+ %29 = OpExtInst %18 %1 FClamp %21 %22 %28
+ OpStore %20 %29
+ %30 = OpLoad %18 %20
+ %31 = OpConvertFToS %6 %30
+ %33 = OpIEqual %24 %31 %32
+ OpSelectionMerge %35 None
+ OpBranchConditional %33 %34 %41
+ %34 = OpLabel
+ OpStore %38 %40
+ OpBranch %35
+ %41 = OpLabel
+ OpStore %38 %42
+ OpBranch %35
+ %35 = OpLabel
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# one
+BUFFER variant_one DATA_TYPE int32 STD140 DATA
+ 1
+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_one 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
--- /dev/null
+#!amber
+
+# Copyright 2021 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.
+
+# Optimized using spirv-opt with the following arguments:
+# '-O'
+# spirv-opt commit hash: a0370efd589be33d5d9a85cfde2f85841b3755af
+
+
+
+SHADER vertex variant_vertex_shader PASSTHROUGH
+
+# variant_fragment_shader is derived from the following GLSL:
+# #version 320 es
+#
+# #define _int_0 _GLF_uniform_int_values[0]
+# #define _int_4 _GLF_uniform_int_values[1]
+# #define _int_1 _GLF_uniform_int_values[2]
+# #define _int_2 _GLF_uniform_int_values[3]
+# #define _float_2_0 _GLF_uniform_float_values[0]
+# #define _float_1_0 _GLF_uniform_float_values[1]
+#
+# precision highp float;
+# precision highp int;
+#
+# // Contents of _GLF_uniform_int_values: [0, 4, 1, 2]
+# layout(set = 0, binding = 0) uniform buf0
+# {
+# int _GLF_uniform_int_values[4];
+# };
+#
+# // Contents of _GLF_uniform_float_values: [2.0, 1.0]
+# layout(set = 0, binding = 1) uniform buf1
+# {
+# float _GLF_uniform_float_values[2];
+# };
+#
+# // Contents of injectionSwitch: [0.0, 1.0]
+# layout(set = 0, binding = 2) uniform buf2
+# {
+# highp vec2 injectionSwitch;
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void main()
+# {
+# float arr[10] = float[10](_float_1_0, _float_1_0, _float_1_0, _float_1_0, _float_1_0, _float_1_0, _float_1_0, _float_1_0, _float_1_0, _float_1_0);
+#
+# // Always false.
+# if(injectionSwitch.x > injectionSwitch.y)
+# {
+# }
+# else
+# {
+# // Always false.
+# if(gl_FragCoord.x < 0.0)
+# {
+# }
+# else
+# {
+# // Always false.
+# if(injectionSwitch.x > injectionSwitch.y)
+# {
+# }
+# else
+# {
+# // arr[1] becomes 2.0.
+# arr[_int_2 / findLSB(_int_4)] = _float_2_0;
+# }
+# }
+# }
+#
+# // Always true.
+# if(arr[_int_0] == _float_1_0 && arr[_int_1] == _float_2_0)
+# {
+# _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: 133
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %59 %114
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %11 "arr"
+ OpName %14 "buf1"
+ OpMemberName %14 0 "_GLF_uniform_float_values"
+ OpName %16 ""
+ OpName %43 "buf2"
+ OpMemberName %43 0 "injectionSwitch"
+ OpName %45 ""
+ OpName %59 "gl_FragCoord"
+ OpName %78 "buf0"
+ OpMemberName %78 0 "_GLF_uniform_int_values"
+ OpName %80 ""
+ OpName %114 "_GLF_color"
+ OpDecorate %13 ArrayStride 16
+ OpMemberDecorate %14 0 Offset 0
+ OpDecorate %14 Block
+ OpDecorate %16 DescriptorSet 0
+ OpDecorate %16 Binding 1
+ OpMemberDecorate %43 0 Offset 0
+ OpDecorate %43 Block
+ OpDecorate %45 DescriptorSet 0
+ OpDecorate %45 Binding 2
+ OpDecorate %59 BuiltIn FragCoord
+ OpDecorate %77 ArrayStride 16
+ OpMemberDecorate %78 0 Offset 0
+ OpDecorate %78 Block
+ OpDecorate %80 DescriptorSet 0
+ OpDecorate %80 Binding 0
+ OpDecorate %114 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeFloat 32
+ %7 = OpTypeInt 32 0
+ %8 = OpConstant %7 10
+ %9 = OpTypeArray %6 %8
+ %10 = OpTypePointer Function %9
+ %12 = OpConstant %7 2
+ %13 = OpTypeArray %6 %12
+ %14 = OpTypeStruct %13
+ %15 = OpTypePointer Uniform %14
+ %16 = OpVariable %15 Uniform
+ %17 = OpTypeInt 32 1
+ %18 = OpConstant %17 0
+ %19 = OpConstant %17 1
+ %20 = OpTypePointer Uniform %6
+ %42 = OpTypeVector %6 2
+ %43 = OpTypeStruct %42
+ %44 = OpTypePointer Uniform %43
+ %45 = OpVariable %44 Uniform
+ %46 = OpConstant %7 0
+ %49 = OpConstant %7 1
+ %52 = OpTypeBool
+ %57 = OpTypeVector %6 4
+ %58 = OpTypePointer Input %57
+ %59 = OpVariable %58 Input
+ %60 = OpTypePointer Input %6
+ %63 = OpConstant %6 0
+ %76 = OpConstant %7 4
+ %77 = OpTypeArray %17 %76
+ %78 = OpTypeStruct %77
+ %79 = OpTypePointer Uniform %78
+ %80 = OpVariable %79 Uniform
+ %81 = OpConstant %17 3
+ %82 = OpTypePointer Uniform %17
+ %91 = OpTypePointer Function %6
+ %102 = OpConstant %17 2
+ %113 = OpTypePointer Output %57
+ %114 = OpVariable %113 Output
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %11 = OpVariable %10 Function
+ %21 = OpAccessChain %20 %16 %18 %19
+ %22 = OpLoad %6 %21
+ %41 = OpCompositeConstruct %9 %22 %22 %22 %22 %22 %22 %22 %22 %22 %22
+ OpStore %11 %41
+ %47 = OpAccessChain %20 %45 %18 %46
+ %48 = OpLoad %6 %47
+ %50 = OpAccessChain %20 %45 %18 %49
+ %51 = OpLoad %6 %50
+ %53 = OpFOrdGreaterThan %52 %48 %51
+ OpSelectionMerge %55 None
+ OpBranchConditional %53 %54 %56
+ %54 = OpLabel
+ OpBranch %55
+ %56 = OpLabel
+ %61 = OpAccessChain %60 %59 %46
+ %62 = OpLoad %6 %61
+ %64 = OpFOrdLessThan %52 %62 %63
+ OpSelectionMerge %66 None
+ OpBranchConditional %64 %65 %67
+ %65 = OpLabel
+ OpBranch %66
+ %67 = OpLabel
+ OpSelectionMerge %74 None
+ OpBranchConditional %53 %73 %75
+ %73 = OpLabel
+ OpBranch %74
+ %75 = OpLabel
+ %83 = OpAccessChain %82 %80 %18 %81
+ %84 = OpLoad %17 %83
+ %85 = OpAccessChain %82 %80 %18 %19
+ %86 = OpLoad %17 %85
+ %87 = OpExtInst %17 %1 FindILsb %86
+ %88 = OpSDiv %17 %84 %87
+ %89 = OpAccessChain %20 %16 %18 %18
+ %90 = OpLoad %6 %89
+ %92 = OpAccessChain %91 %11 %88
+ OpStore %92 %90
+ OpBranch %74
+ %74 = OpLabel
+ OpBranch %66
+ %66 = OpLabel
+ OpBranch %55
+ %55 = OpLabel
+ %93 = OpAccessChain %82 %80 %18 %18
+ %94 = OpLoad %17 %93
+ %95 = OpAccessChain %91 %11 %94
+ %96 = OpLoad %6 %95
+ %99 = OpFOrdEqual %52 %96 %22
+ OpSelectionMerge %101 None
+ OpBranchConditional %99 %100 %101
+ %100 = OpLabel
+ %103 = OpAccessChain %82 %80 %18 %102
+ %104 = OpLoad %17 %103
+ %105 = OpAccessChain %91 %11 %104
+ %106 = OpLoad %6 %105
+ %107 = OpAccessChain %20 %16 %18 %18
+ %108 = OpLoad %6 %107
+ %109 = OpFOrdEqual %52 %106 %108
+ OpBranch %101
+ %101 = OpLabel
+ %110 = OpPhi %52 %99 %55 %109 %100
+ OpSelectionMerge %112 None
+ OpBranchConditional %110 %111 %128
+ %111 = OpLabel
+ %115 = OpAccessChain %82 %80 %18 %102
+ %116 = OpLoad %17 %115
+ %117 = OpConvertSToF %6 %116
+ %120 = OpConvertSToF %6 %94
+ %127 = OpCompositeConstruct %57 %117 %120 %120 %117
+ OpStore %114 %127
+ OpBranch %112
+ %128 = OpLabel
+ %131 = OpConvertSToF %6 %94
+ %132 = OpCompositeConstruct %57 %131 %131 %131 %131
+ OpStore %114 %132
+ OpBranch %112
+ %112 = OpLabel
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# injectionSwitch
+BUFFER variant_injectionSwitch DATA_TYPE vec2<float> STD140 DATA
+ 0.0 1.0
+END
+# _GLF_uniform_float_values
+BUFFER variant__GLF_uniform_float_values DATA_TYPE float[] STD140 DATA
+ 2.0 1.0
+END
+# _GLF_uniform_int_values
+BUFFER variant__GLF_uniform_int_values DATA_TYPE int32[] STD140 DATA
+ 0 4 1 2
+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_injectionSwitch AS uniform DESCRIPTOR_SET 0 BINDING 2
+ BIND BUFFER variant__GLF_uniform_float_values AS uniform DESCRIPTOR_SET 0 BINDING 1
+ BIND BUFFER variant__GLF_uniform_int_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
--- /dev/null
+#!amber
+
+# Copyright 2021 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_1 _GLF_uniform_int_values[0]
+# #define _int_0 _GLF_uniform_int_values[1]
+# #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: [1, 0]
+# layout(set = 0, binding = 1) uniform buf1
+# {
+# int _GLF_uniform_int_values[2];
+# };
+#
+# // Contents of injectionSwitch: [0.0, 1.0]
+# layout(set = 0, binding = 2) uniform buf2
+# {
+# highp vec2 injectionSwitch;
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void main()
+# {
+# // Always false.
+# if(injectionSwitch.x > injectionSwitch.y)
+# {
+# discard;
+# }
+#
+# int a = 1;
+#
+# // Iterated twice.
+# while(a << int(injectionSwitch.x) >= _int_0)
+# {
+# // Always false.
+# if(injectionSwitch.x > injectionSwitch.y)
+# {
+# continue;
+# }
+#
+# a--;
+#
+# // Always false.
+# if(gl_FragCoord.x < _float_0_0)
+# {
+# discard;
+# }
+#
+# if(true)
+# {
+# }
+# }
+#
+# // Always true.
+# if(a == -_int_1)
+# {
+# _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: 104
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %60 %85
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %8 "buf2"
+ OpMemberName %8 0 "injectionSwitch"
+ OpName %10 ""
+ OpName %27 "a"
+ OpName %41 "buf1"
+ OpMemberName %41 0 "_GLF_uniform_int_values"
+ OpName %43 ""
+ OpName %60 "gl_FragCoord"
+ OpName %65 "buf0"
+ OpMemberName %65 0 "_GLF_uniform_float_values"
+ OpName %67 ""
+ OpName %85 "_GLF_color"
+ OpMemberDecorate %8 0 Offset 0
+ OpDecorate %8 Block
+ OpDecorate %10 DescriptorSet 0
+ OpDecorate %10 Binding 2
+ OpDecorate %40 ArrayStride 16
+ OpMemberDecorate %41 0 Offset 0
+ OpDecorate %41 Block
+ OpDecorate %43 DescriptorSet 0
+ OpDecorate %43 Binding 1
+ OpDecorate %60 BuiltIn FragCoord
+ OpDecorate %64 ArrayStride 16
+ OpMemberDecorate %65 0 Offset 0
+ OpDecorate %65 Block
+ OpDecorate %67 DescriptorSet 0
+ OpDecorate %67 Binding 0
+ OpDecorate %85 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeFloat 32
+ %7 = OpTypeVector %6 2
+ %8 = OpTypeStruct %7
+ %9 = OpTypePointer Uniform %8
+ %10 = OpVariable %9 Uniform
+ %11 = OpTypeInt 32 1
+ %12 = OpConstant %11 0
+ %13 = OpTypeInt 32 0
+ %14 = OpConstant %13 0
+ %15 = OpTypePointer Uniform %6
+ %18 = OpConstant %13 1
+ %21 = OpTypeBool
+ %26 = OpTypePointer Function %11
+ %28 = OpConstant %11 1
+ %39 = OpConstant %13 2
+ %40 = OpTypeArray %11 %39
+ %41 = OpTypeStruct %40
+ %42 = OpTypePointer Uniform %41
+ %43 = OpVariable %42 Uniform
+ %44 = OpTypePointer Uniform %11
+ %58 = OpTypeVector %6 4
+ %59 = OpTypePointer Input %58
+ %60 = OpVariable %59 Input
+ %61 = OpTypePointer Input %6
+ %64 = OpTypeArray %6 %18
+ %65 = OpTypeStruct %64
+ %66 = OpTypePointer Uniform %65
+ %67 = OpVariable %66 Uniform
+ %74 = OpConstantTrue %21
+ %84 = OpTypePointer Output %58
+ %85 = OpVariable %84 Output
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %27 = OpVariable %26 Function
+ %16 = OpAccessChain %15 %10 %12 %14
+ %17 = OpLoad %6 %16
+ %19 = OpAccessChain %15 %10 %12 %18
+ %20 = OpLoad %6 %19
+ %22 = OpFOrdGreaterThan %21 %17 %20
+ OpSelectionMerge %24 None
+ OpBranchConditional %22 %23 %24
+ %23 = OpLabel
+ OpKill
+ %24 = OpLabel
+ OpStore %27 %28
+ OpBranch %29
+ %29 = OpLabel
+ OpLoopMerge %31 %32 None
+ OpBranch %33
+ %33 = OpLabel
+ %34 = OpLoad %11 %27
+ %35 = OpAccessChain %15 %10 %12 %14
+ %36 = OpLoad %6 %35
+ %37 = OpConvertFToS %11 %36
+ %38 = OpShiftLeftLogical %11 %34 %37
+ %45 = OpAccessChain %44 %43 %12 %28
+ %46 = OpLoad %11 %45
+ %47 = OpSGreaterThanEqual %21 %38 %46
+ OpBranchConditional %47 %30 %31
+ %30 = OpLabel
+ %48 = OpAccessChain %15 %10 %12 %14
+ %49 = OpLoad %6 %48
+ %50 = OpAccessChain %15 %10 %12 %18
+ %51 = OpLoad %6 %50
+ %52 = OpFOrdGreaterThan %21 %49 %51
+ OpSelectionMerge %54 None
+ OpBranchConditional %52 %53 %54
+ %53 = OpLabel
+ OpBranch %32
+ %54 = OpLabel
+ %56 = OpLoad %11 %27
+ %57 = OpISub %11 %56 %28
+ OpStore %27 %57
+ %62 = OpAccessChain %61 %60 %14
+ %63 = OpLoad %6 %62
+ %68 = OpAccessChain %15 %67 %12 %12
+ %69 = OpLoad %6 %68
+ %70 = OpFOrdLessThan %21 %63 %69
+ OpSelectionMerge %72 None
+ OpBranchConditional %70 %71 %72
+ %71 = OpLabel
+ OpKill
+ %72 = OpLabel
+ OpSelectionMerge %76 None
+ OpBranchConditional %74 %75 %76
+ %75 = OpLabel
+ OpBranch %76
+ %76 = OpLabel
+ OpBranch %32
+ %32 = OpLabel
+ OpBranch %29
+ %31 = OpLabel
+ %77 = OpLoad %11 %27
+ %78 = OpAccessChain %44 %43 %12 %12
+ %79 = OpLoad %11 %78
+ %80 = OpSNegate %11 %79
+ %81 = OpIEqual %21 %77 %80
+ OpSelectionMerge %83 None
+ OpBranchConditional %81 %82 %99
+ %82 = OpLabel
+ %86 = OpAccessChain %44 %43 %12 %12
+ %87 = OpLoad %11 %86
+ %88 = OpConvertSToF %6 %87
+ %89 = OpAccessChain %44 %43 %12 %28
+ %90 = OpLoad %11 %89
+ %91 = OpConvertSToF %6 %90
+ %92 = OpAccessChain %44 %43 %12 %28
+ %93 = OpLoad %11 %92
+ %94 = OpConvertSToF %6 %93
+ %95 = OpAccessChain %44 %43 %12 %12
+ %96 = OpLoad %11 %95
+ %97 = OpConvertSToF %6 %96
+ %98 = OpCompositeConstruct %58 %88 %91 %94 %97
+ OpStore %85 %98
+ OpBranch %83
+ %99 = OpLabel
+ %100 = OpAccessChain %44 %43 %12 %28
+ %101 = OpLoad %11 %100
+ %102 = OpConvertSToF %6 %101
+ %103 = OpCompositeConstruct %58 %102 %102 %102 %102
+ OpStore %85 %103
+ OpBranch %83
+ %83 = OpLabel
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# injectionSwitch
+BUFFER variant_injectionSwitch DATA_TYPE vec2<float> STD140 DATA
+ 0.0 1.0
+END
+# _GLF_uniform_int_values
+BUFFER variant__GLF_uniform_int_values DATA_TYPE int32[] STD140 DATA
+ 1 0
+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_injectionSwitch AS uniform DESCRIPTOR_SET 0 BINDING 2
+ 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
--- /dev/null
+#!amber
+
+# Copyright 2021 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_1 _GLF_uniform_int_values[0]
+# #define _int_0 _GLF_uniform_int_values[1]
+# #define _int_2 _GLF_uniform_int_values[2]
+# #define _int_5 _GLF_uniform_int_values[3]
+#
+# precision highp float;
+# precision highp int;
+#
+# // Contents of _GLF_uniform_int_values: [1, 0, 2, 5]
+# layout(set = 0, binding = 0) uniform buf0
+# {
+# int _GLF_uniform_int_values[4];
+# };
+#
+# const int _GLF_global_loop_bound = 10;
+# int _GLF_global_loop_count = 0;
+#
+# int arr[5] = int[5](1, 1, 1, 1, 1);
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void func()
+# {
+# int b = _int_0;
+#
+# for(int i = 0; _GLF_global_loop_count < _GLF_global_loop_bound; i ++)
+# {
+# _GLF_global_loop_count++;
+#
+# if(++b > 2)
+# {
+# break;
+# }
+#
+# int c = _int_0;
+#
+# for(int j = _int_0; _GLF_global_loop_count < _GLF_global_loop_bound; )
+# {
+# _GLF_global_loop_count++;
+#
+# if(++c > _int_2)
+# {
+# break;
+# }
+#
+# // Same as arr[i] because j is always 0.
+# arr[j + i] = i - 1;
+# }
+# }
+# }
+#
+# void main()
+# {
+# // Sets arr[0] to -1 and arr[1] to 0.
+# func();
+#
+# while(_GLF_global_loop_count < _GLF_global_loop_bound)
+# {
+# _GLF_global_loop_count++;
+#
+# int a = 5;
+#
+# for(int i = 1; i < 4 && _GLF_global_loop_count < _GLF_global_loop_bound; i++)
+# {
+# _GLF_global_loop_count++;
+#
+# // Always false as i reaches four before a reaches eight.
+# if(a++ > 7)
+# {
+# func();
+# break;
+# }
+# }
+# }
+#
+# // Check for the expected values, and set color output to black if the check fails.
+# _GLF_color = vec4(_int_1, _int_0, _int_0, _int_1);
+# int ref[5] = int[5](- _int_1, _int_0, _int_1, _int_1, _int_1);
+# for(int i = _int_0; i < _int_5; i ++)
+# {
+# if(arr[i] != ref[i])
+# {
+# _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: 174
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %118
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %6 "func("
+ OpName %10 "_GLF_global_loop_count"
+ OpName %16 "arr"
+ OpName %20 "b"
+ OpName %23 "buf0"
+ OpMemberName %23 0 "_GLF_uniform_int_values"
+ OpName %25 ""
+ OpName %29 "i"
+ OpName %48 "c"
+ OpName %51 "j"
+ OpName %89 "a"
+ OpName %91 "i"
+ OpName %118 "_GLF_color"
+ OpName %133 "ref"
+ OpName %146 "i"
+ OpDecorate %22 ArrayStride 16
+ OpMemberDecorate %23 0 Offset 0
+ OpDecorate %23 Block
+ OpDecorate %25 DescriptorSet 0
+ OpDecorate %25 Binding 0
+ OpDecorate %118 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %8 = OpTypeInt 32 1
+ %9 = OpTypePointer Private %8
+ %10 = OpVariable %9 Private
+ %11 = OpConstant %8 0
+ %12 = OpTypeInt 32 0
+ %13 = OpConstant %12 5
+ %14 = OpTypeArray %8 %13
+ %15 = OpTypePointer Private %14
+ %16 = OpVariable %15 Private
+ %17 = OpConstant %8 1
+ %18 = OpConstantComposite %14 %17 %17 %17 %17 %17
+ %19 = OpTypePointer Function %8
+ %21 = OpConstant %12 4
+ %22 = OpTypeArray %8 %21
+ %23 = OpTypeStruct %22
+ %24 = OpTypePointer Uniform %23
+ %25 = OpVariable %24 Uniform
+ %26 = OpTypePointer Uniform %8
+ %36 = OpConstant %8 10
+ %37 = OpTypeBool
+ %43 = OpConstant %8 2
+ %90 = OpConstant %8 5
+ %98 = OpConstant %8 4
+ %107 = OpConstant %8 7
+ %115 = OpTypeFloat 32
+ %116 = OpTypeVector %115 4
+ %117 = OpTypePointer Output %116
+ %118 = OpVariable %117 Output
+ %132 = OpTypePointer Function %14
+ %155 = OpConstant %8 3
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %89 = OpVariable %19 Function
+ %91 = OpVariable %19 Function
+ %133 = OpVariable %132 Function
+ %146 = OpVariable %19 Function
+ OpStore %10 %11
+ OpStore %16 %18
+ %79 = OpFunctionCall %2 %6
+ OpBranch %80
+ %80 = OpLabel
+ OpLoopMerge %82 %83 None
+ OpBranch %84
+ %84 = OpLabel
+ %85 = OpLoad %8 %10
+ %86 = OpSLessThan %37 %85 %36
+ OpBranchConditional %86 %81 %82
+ %81 = OpLabel
+ %87 = OpLoad %8 %10
+ %88 = OpIAdd %8 %87 %17
+ OpStore %10 %88
+ OpStore %89 %90
+ OpStore %91 %17
+ OpBranch %92
+ %92 = OpLabel
+ OpLoopMerge %94 %95 None
+ OpBranch %96
+ %96 = OpLabel
+ %97 = OpLoad %8 %91
+ %99 = OpSLessThan %37 %97 %98
+ %100 = OpLoad %8 %10
+ %101 = OpSLessThan %37 %100 %36
+ %102 = OpLogicalAnd %37 %99 %101
+ OpBranchConditional %102 %93 %94
+ %93 = OpLabel
+ %103 = OpLoad %8 %10
+ %104 = OpIAdd %8 %103 %17
+ OpStore %10 %104
+ %105 = OpLoad %8 %89
+ %106 = OpIAdd %8 %105 %17
+ OpStore %89 %106
+ %108 = OpSGreaterThan %37 %105 %107
+ OpSelectionMerge %110 None
+ OpBranchConditional %108 %109 %110
+ %109 = OpLabel
+ %111 = OpFunctionCall %2 %6
+ OpBranch %94
+ %110 = OpLabel
+ OpBranch %95
+ %95 = OpLabel
+ %113 = OpLoad %8 %91
+ %114 = OpIAdd %8 %113 %17
+ OpStore %91 %114
+ OpBranch %92
+ %94 = OpLabel
+ OpBranch %83
+ %83 = OpLabel
+ OpBranch %80
+ %82 = OpLabel
+ %119 = OpAccessChain %26 %25 %11 %11
+ %120 = OpLoad %8 %119
+ %121 = OpConvertSToF %115 %120
+ %122 = OpAccessChain %26 %25 %11 %17
+ %123 = OpLoad %8 %122
+ %124 = OpConvertSToF %115 %123
+ %125 = OpAccessChain %26 %25 %11 %17
+ %126 = OpLoad %8 %125
+ %127 = OpConvertSToF %115 %126
+ %128 = OpAccessChain %26 %25 %11 %11
+ %129 = OpLoad %8 %128
+ %130 = OpConvertSToF %115 %129
+ %131 = OpCompositeConstruct %116 %121 %124 %127 %130
+ OpStore %118 %131
+ %134 = OpAccessChain %26 %25 %11 %11
+ %135 = OpLoad %8 %134
+ %136 = OpSNegate %8 %135
+ %137 = OpAccessChain %26 %25 %11 %17
+ %138 = OpLoad %8 %137
+ %139 = OpAccessChain %26 %25 %11 %11
+ %140 = OpLoad %8 %139
+ %141 = OpAccessChain %26 %25 %11 %11
+ %142 = OpLoad %8 %141
+ %143 = OpAccessChain %26 %25 %11 %11
+ %144 = OpLoad %8 %143
+ %145 = OpCompositeConstruct %14 %136 %138 %140 %142 %144
+ OpStore %133 %145
+ %147 = OpAccessChain %26 %25 %11 %17
+ %148 = OpLoad %8 %147
+ OpStore %146 %148
+ OpBranch %149
+ %149 = OpLabel
+ OpLoopMerge %151 %152 None
+ OpBranch %153
+ %153 = OpLabel
+ %154 = OpLoad %8 %146
+ %156 = OpAccessChain %26 %25 %11 %155
+ %157 = OpLoad %8 %156
+ %158 = OpSLessThan %37 %154 %157
+ OpBranchConditional %158 %150 %151
+ %150 = OpLabel
+ %159 = OpLoad %8 %146
+ %160 = OpAccessChain %9 %16 %159
+ %161 = OpLoad %8 %160
+ %162 = OpLoad %8 %146
+ %163 = OpAccessChain %19 %133 %162
+ %164 = OpLoad %8 %163
+ %165 = OpINotEqual %37 %161 %164
+ OpSelectionMerge %167 None
+ OpBranchConditional %165 %166 %167
+ %166 = OpLabel
+ %168 = OpAccessChain %26 %25 %11 %17
+ %169 = OpLoad %8 %168
+ %170 = OpConvertSToF %115 %169
+ %171 = OpCompositeConstruct %116 %170 %170 %170 %170
+ OpStore %118 %171
+ OpBranch %167
+ %167 = OpLabel
+ OpBranch %152
+ %152 = OpLabel
+ %172 = OpLoad %8 %146
+ %173 = OpIAdd %8 %172 %17
+ OpStore %146 %173
+ OpBranch %149
+ %151 = OpLabel
+ OpReturn
+ OpFunctionEnd
+ %6 = OpFunction %2 None %3
+ %7 = OpLabel
+ %20 = OpVariable %19 Function
+ %29 = OpVariable %19 Function
+ %48 = OpVariable %19 Function
+ %51 = OpVariable %19 Function
+ %27 = OpAccessChain %26 %25 %11 %17
+ %28 = OpLoad %8 %27
+ OpStore %20 %28
+ OpStore %29 %11
+ OpBranch %30
+ %30 = OpLabel
+ OpLoopMerge %32 %33 None
+ OpBranch %34
+ %34 = OpLabel
+ %35 = OpLoad %8 %10
+ %38 = OpSLessThan %37 %35 %36
+ OpBranchConditional %38 %31 %32
+ %31 = OpLabel
+ %39 = OpLoad %8 %10
+ %40 = OpIAdd %8 %39 %17
+ OpStore %10 %40
+ %41 = OpLoad %8 %20
+ %42 = OpIAdd %8 %41 %17
+ OpStore %20 %42
+ %44 = OpSGreaterThan %37 %42 %43
+ OpSelectionMerge %46 None
+ OpBranchConditional %44 %45 %46
+ %45 = OpLabel
+ OpBranch %32
+ %46 = OpLabel
+ %49 = OpAccessChain %26 %25 %11 %17
+ %50 = OpLoad %8 %49
+ OpStore %48 %50
+ %52 = OpAccessChain %26 %25 %11 %17
+ %53 = OpLoad %8 %52
+ OpStore %51 %53
+ OpBranch %54
+ %54 = OpLabel
+ OpLoopMerge %56 %57 None
+ OpBranch %58
+ %58 = OpLabel
+ %59 = OpLoad %8 %10
+ %60 = OpSLessThan %37 %59 %36
+ OpBranchConditional %60 %55 %56
+ %55 = OpLabel
+ %61 = OpLoad %8 %10
+ %62 = OpIAdd %8 %61 %17
+ OpStore %10 %62
+ %63 = OpLoad %8 %48
+ %64 = OpIAdd %8 %63 %17
+ OpStore %48 %64
+ %65 = OpAccessChain %26 %25 %11 %43
+ %66 = OpLoad %8 %65
+ %67 = OpSGreaterThan %37 %64 %66
+ OpSelectionMerge %69 None
+ OpBranchConditional %67 %68 %69
+ %68 = OpLabel
+ OpBranch %56
+ %69 = OpLabel
+ %71 = OpLoad %8 %51
+ %72 = OpLoad %8 %29
+ %73 = OpIAdd %8 %71 %72
+ %74 = OpLoad %8 %29
+ %75 = OpISub %8 %74 %17
+ %76 = OpAccessChain %9 %16 %73
+ OpStore %76 %75
+ OpBranch %57
+ %57 = OpLabel
+ OpBranch %54
+ %56 = OpLabel
+ OpBranch %33
+ %33 = OpLabel
+ %77 = OpLoad %8 %29
+ %78 = OpIAdd %8 %77 %17
+ OpStore %29 %78
+ OpBranch %30
+ %32 = OpLabel
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# _GLF_uniform_int_values
+BUFFER variant__GLF_uniform_int_values DATA_TYPE int32[] STD140 DATA
+ 1 0 2 5
+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 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
--- /dev/null
+#!amber
+
+# Copyright 2021 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_256 _GLF_uniform_int_values[0]
+# #define _int_1 _GLF_uniform_int_values[1]
+# #define _int_0 _GLF_uniform_int_values[2]
+#
+# precision highp float;
+# precision highp int;
+#
+# // Contents of _GLF_uniform_int_values: [256, 1, 0]
+# layout(set = 0, binding = 0) uniform buf0
+# {
+# int _GLF_uniform_int_values[3];
+# };
+#
+# // Contents of resolution: 256.0
+# layout(set = 0, binding = 1) uniform buf1
+# {
+# float resolution;
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void main()
+# {
+# // p becomes (128, 128).
+# ivec2 p = ivec2(resolution) >> ivec2(1);
+# // p becomes (256, 128).
+# p.x += p.y;
+#
+# // Always true.
+# if(p.x == _int_256)
+# {
+# _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: 69
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %49
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %9 "p"
+ OpName %11 "buf1"
+ OpMemberName %11 0 "resolution"
+ OpName %13 ""
+ OpName %37 "buf0"
+ OpMemberName %37 0 "_GLF_uniform_int_values"
+ OpName %39 ""
+ OpName %49 "_GLF_color"
+ OpMemberDecorate %11 0 Offset 0
+ OpDecorate %11 Block
+ OpDecorate %13 DescriptorSet 0
+ OpDecorate %13 Binding 1
+ OpDecorate %36 ArrayStride 16
+ OpMemberDecorate %37 0 Offset 0
+ OpDecorate %37 Block
+ OpDecorate %39 DescriptorSet 0
+ OpDecorate %39 Binding 0
+ OpDecorate %49 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeInt 32 1
+ %7 = OpTypeVector %6 2
+ %8 = OpTypePointer Function %7
+ %10 = OpTypeFloat 32
+ %11 = OpTypeStruct %10
+ %12 = OpTypePointer Uniform %11
+ %13 = OpVariable %12 Uniform
+ %14 = OpConstant %6 0
+ %15 = OpTypePointer Uniform %10
+ %20 = OpConstant %6 1
+ %21 = OpConstantComposite %7 %20 %20
+ %23 = OpTypeInt 32 0
+ %24 = OpConstant %23 1
+ %25 = OpTypePointer Function %6
+ %28 = OpConstant %23 0
+ %35 = OpConstant %23 3
+ %36 = OpTypeArray %6 %35
+ %37 = OpTypeStruct %36
+ %38 = OpTypePointer Uniform %37
+ %39 = OpVariable %38 Uniform
+ %40 = OpTypePointer Uniform %6
+ %43 = OpTypeBool
+ %47 = OpTypeVector %10 4
+ %48 = OpTypePointer Output %47
+ %49 = OpVariable %48 Output
+ %53 = OpConstant %6 2
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %9 = OpVariable %8 Function
+ %16 = OpAccessChain %15 %13 %14
+ %17 = OpLoad %10 %16
+ %18 = OpConvertFToS %6 %17
+ %19 = OpCompositeConstruct %7 %18 %18
+ %22 = OpShiftRightArithmetic %7 %19 %21
+ OpStore %9 %22
+ %26 = OpAccessChain %25 %9 %24
+ %27 = OpLoad %6 %26
+ %29 = OpAccessChain %25 %9 %28
+ %30 = OpLoad %6 %29
+ %31 = OpIAdd %6 %30 %27
+ %32 = OpAccessChain %25 %9 %28
+ OpStore %32 %31
+ %33 = OpAccessChain %25 %9 %28
+ %34 = OpLoad %6 %33
+ %41 = OpAccessChain %40 %39 %14 %14
+ %42 = OpLoad %6 %41
+ %44 = OpIEqual %43 %34 %42
+ OpSelectionMerge %46 None
+ OpBranchConditional %44 %45 %64
+ %45 = OpLabel
+ %50 = OpAccessChain %40 %39 %14 %20
+ %51 = OpLoad %6 %50
+ %52 = OpConvertSToF %10 %51
+ %54 = OpAccessChain %40 %39 %14 %53
+ %55 = OpLoad %6 %54
+ %56 = OpConvertSToF %10 %55
+ %57 = OpAccessChain %40 %39 %14 %53
+ %58 = OpLoad %6 %57
+ %59 = OpConvertSToF %10 %58
+ %60 = OpAccessChain %40 %39 %14 %20
+ %61 = OpLoad %6 %60
+ %62 = OpConvertSToF %10 %61
+ %63 = OpCompositeConstruct %47 %52 %56 %59 %62
+ OpStore %49 %63
+ OpBranch %46
+ %64 = OpLabel
+ %65 = OpAccessChain %40 %39 %14 %53
+ %66 = OpLoad %6 %65
+ %67 = OpConvertSToF %10 %66
+ %68 = OpCompositeConstruct %47 %67 %67 %67 %67
+ OpStore %49 %68
+ OpBranch %46
+ %46 = OpLabel
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# resolution
+BUFFER variant_resolution DATA_TYPE float STD140 DATA
+ 256.0
+END
+# _GLF_uniform_int_values
+BUFFER variant__GLF_uniform_int_values DATA_TYPE int32[] STD140 DATA
+ 256 1 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_resolution AS uniform DESCRIPTOR_SET 0 BINDING 1
+ BIND BUFFER variant__GLF_uniform_int_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
--- /dev/null
+#!amber
+
+# Copyright 2021 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
+#
+# precision highp int;
+# precision highp float;
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# // Contents of one: 1.0
+# layout(set = 0, binding = 0) uniform buf0
+# {
+# float one;
+# };
+#
+# void main()
+# {
+# int a = 1;
+#
+# // Iterated until the break is executed.
+# while(int(one) >= 1)
+# {
+# if(a++ >= 5)
+# {
+# _GLF_color = vec4(1, 0, 0, 1);
+# break;
+# }
+# }
+# }
+SHADER fragment variant_fragment_shader SPIRV-ASM TARGET_ENV spv1.0
+; SPIR-V
+; Version: 1.0
+; Generator: Khronos Glslang Reference Front End; 10
+; Bound: 39
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %34
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %8 "a"
+ OpName %16 "buf0"
+ OpMemberName %16 0 "one"
+ OpName %18 ""
+ OpName %34 "_GLF_color"
+ OpMemberDecorate %16 0 Offset 0
+ OpDecorate %16 Block
+ OpDecorate %18 DescriptorSet 0
+ OpDecorate %18 Binding 0
+ OpDecorate %34 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeInt 32 1
+ %7 = OpTypePointer Function %6
+ %9 = OpConstant %6 1
+ %15 = OpTypeFloat 32
+ %16 = OpTypeStruct %15
+ %17 = OpTypePointer Uniform %16
+ %18 = OpVariable %17 Uniform
+ %19 = OpConstant %6 0
+ %20 = OpTypePointer Uniform %15
+ %24 = OpTypeBool
+ %28 = OpConstant %6 5
+ %32 = OpTypeVector %15 4
+ %33 = OpTypePointer Output %32
+ %34 = OpVariable %33 Output
+ %35 = OpConstant %15 1
+ %36 = OpConstant %15 0
+ %37 = OpConstantComposite %32 %35 %36 %36 %35
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %8 = OpVariable %7 Function
+ OpStore %8 %9
+ OpBranch %10
+ %10 = OpLabel
+ OpLoopMerge %12 %13 None
+ OpBranch %14
+ %14 = OpLabel
+ %21 = OpAccessChain %20 %18 %19
+ %22 = OpLoad %15 %21
+ %23 = OpConvertFToS %6 %22
+ %25 = OpSGreaterThanEqual %24 %23 %9
+ OpBranchConditional %25 %11 %12
+ %11 = OpLabel
+ %26 = OpLoad %6 %8
+ %27 = OpIAdd %6 %26 %9
+ OpStore %8 %27
+ %29 = OpSGreaterThanEqual %24 %26 %28
+ OpSelectionMerge %31 None
+ OpBranchConditional %29 %30 %31
+ %30 = OpLabel
+ OpStore %34 %37
+ OpBranch %12
+ %31 = OpLabel
+ OpBranch %13
+ %13 = OpLabel
+ OpBranch %10
+ %12 = OpLabel
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# one
+BUFFER variant_one DATA_TYPE float STD140 DATA
+ 1.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_one 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
--- /dev/null
+#!amber
+
+# Copyright 2021 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_0 _GLF_uniform_int_values[0]
+# #define _int_1 _GLF_uniform_int_values[1]
+# #define _float_1_0 _GLF_uniform_float_values[0]
+#
+# precision highp float;
+# precision highp int;
+#
+# // Contents of _GLF_uniform_int_values: [0, 1]
+# layout(set = 0, binding = 0) uniform buf0
+# {
+# int _GLF_uniform_int_values[2];
+# };
+#
+# // Contents of _GLF_uniform_float_values: 1.0
+# layout(set = 0, binding = 1) uniform buf1
+# {
+# float _GLF_uniform_float_values[1];
+# };
+#
+# const int _GLF_global_loop_bound = 10;
+# int _GLF_global_loop_count = 0;
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# // Contents of one: 1.0
+# layout(set = 0, binding = 2) uniform buf2
+# {
+# float one;
+# };
+#
+# void main()
+# {
+# _GLF_color = vec4(_int_0);
+#
+# // Always false.
+# if(one < _float_1_0)
+# {
+# }
+# else
+# {
+# // Always false.
+# if(gl_FragCoord.y < 0.0)
+# {
+# }
+# else
+# {
+# // Always false.
+# if(gl_FragCoord.y < 0.0)
+# {
+# return;
+# }
+# }
+# }
+#
+# while(_GLF_global_loop_count < _GLF_global_loop_bound)
+# {
+# _GLF_global_loop_count ++;
+# }
+#
+# // Always true.
+# if(_GLF_global_loop_count == _GLF_global_loop_bound)
+# {
+# _GLF_color = vec4(_int_1, _int_0, _int_0, _int_1);
+# }
+# }
+SHADER fragment variant_fragment_shader SPIRV-ASM TARGET_ENV spv1.0
+; SPIR-V
+; Version: 1.0
+; Generator: Khronos Glslang Reference Front End; 10
+; Bound: 87
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %13 %44
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %8 "_GLF_global_loop_count"
+ OpName %13 "_GLF_color"
+ OpName %17 "buf0"
+ OpMemberName %17 0 "_GLF_uniform_int_values"
+ OpName %19 ""
+ OpName %25 "buf2"
+ OpMemberName %25 0 "one"
+ OpName %27 ""
+ OpName %33 "buf1"
+ OpMemberName %33 0 "_GLF_uniform_float_values"
+ OpName %35 ""
+ OpName %44 "gl_FragCoord"
+ OpDecorate %13 Location 0
+ OpDecorate %16 ArrayStride 16
+ OpMemberDecorate %17 0 Offset 0
+ OpDecorate %17 Block
+ OpDecorate %19 DescriptorSet 0
+ OpDecorate %19 Binding 0
+ OpMemberDecorate %25 0 Offset 0
+ OpDecorate %25 Block
+ OpDecorate %27 DescriptorSet 0
+ OpDecorate %27 Binding 2
+ OpDecorate %32 ArrayStride 16
+ OpMemberDecorate %33 0 Offset 0
+ OpDecorate %33 Block
+ OpDecorate %35 DescriptorSet 0
+ OpDecorate %35 Binding 1
+ OpDecorate %44 BuiltIn FragCoord
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeInt 32 1
+ %7 = OpTypePointer Private %6
+ %8 = OpVariable %7 Private
+ %9 = OpConstant %6 0
+ %10 = OpTypeFloat 32
+ %11 = OpTypeVector %10 4
+ %12 = OpTypePointer Output %11
+ %13 = OpVariable %12 Output
+ %14 = OpTypeInt 32 0
+ %15 = OpConstant %14 2
+ %16 = OpTypeArray %6 %15
+ %17 = OpTypeStruct %16
+ %18 = OpTypePointer Uniform %17
+ %19 = OpVariable %18 Uniform
+ %20 = OpTypePointer Uniform %6
+ %25 = OpTypeStruct %10
+ %26 = OpTypePointer Uniform %25
+ %27 = OpVariable %26 Uniform
+ %28 = OpTypePointer Uniform %10
+ %31 = OpConstant %14 1
+ %32 = OpTypeArray %10 %31
+ %33 = OpTypeStruct %32
+ %34 = OpTypePointer Uniform %33
+ %35 = OpVariable %34 Uniform
+ %38 = OpTypeBool
+ %43 = OpTypePointer Input %11
+ %44 = OpVariable %43 Input
+ %45 = OpTypePointer Input %10
+ %48 = OpConstant %10 0
+ %65 = OpConstant %6 10
+ %68 = OpConstant %6 1
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ OpStore %8 %9
+ %21 = OpAccessChain %20 %19 %9 %9
+ %22 = OpLoad %6 %21
+ %23 = OpConvertSToF %10 %22
+ %24 = OpCompositeConstruct %11 %23 %23 %23 %23
+ OpStore %13 %24
+ %29 = OpAccessChain %28 %27 %9
+ %30 = OpLoad %10 %29
+ %36 = OpAccessChain %28 %35 %9 %9
+ %37 = OpLoad %10 %36
+ %39 = OpFOrdLessThan %38 %30 %37
+ OpSelectionMerge %41 None
+ OpBranchConditional %39 %40 %42
+ %40 = OpLabel
+ OpBranch %41
+ %42 = OpLabel
+ %46 = OpAccessChain %45 %44 %31
+ %47 = OpLoad %10 %46
+ %49 = OpFOrdLessThan %38 %47 %48
+ OpSelectionMerge %51 None
+ OpBranchConditional %49 %50 %52
+ %50 = OpLabel
+ OpBranch %51
+ %52 = OpLabel
+ %53 = OpAccessChain %45 %44 %31
+ %54 = OpLoad %10 %53
+ %55 = OpFOrdLessThan %38 %54 %48
+ OpSelectionMerge %57 None
+ OpBranchConditional %55 %56 %57
+ %56 = OpLabel
+ OpReturn
+ %57 = OpLabel
+ OpBranch %51
+ %51 = OpLabel
+ OpBranch %41
+ %41 = OpLabel
+ OpBranch %59
+ %59 = OpLabel
+ OpLoopMerge %61 %62 None
+ OpBranch %63
+ %63 = OpLabel
+ %64 = OpLoad %6 %8
+ %66 = OpSLessThan %38 %64 %65
+ OpBranchConditional %66 %60 %61
+ %60 = OpLabel
+ %67 = OpLoad %6 %8
+ %69 = OpIAdd %6 %67 %68
+ OpStore %8 %69
+ OpBranch %62
+ %62 = OpLabel
+ OpBranch %59
+ %61 = OpLabel
+ %70 = OpLoad %6 %8
+ %71 = OpIEqual %38 %70 %65
+ OpSelectionMerge %73 None
+ OpBranchConditional %71 %72 %73
+ %72 = OpLabel
+ %74 = OpAccessChain %20 %19 %9 %68
+ %75 = OpLoad %6 %74
+ %76 = OpConvertSToF %10 %75
+ %77 = OpAccessChain %20 %19 %9 %9
+ %78 = OpLoad %6 %77
+ %79 = OpConvertSToF %10 %78
+ %80 = OpAccessChain %20 %19 %9 %9
+ %81 = OpLoad %6 %80
+ %82 = OpConvertSToF %10 %81
+ %83 = OpAccessChain %20 %19 %9 %68
+ %84 = OpLoad %6 %83
+ %85 = OpConvertSToF %10 %84
+ %86 = OpCompositeConstruct %11 %76 %79 %82 %85
+ OpStore %13 %86
+ OpBranch %73
+ %73 = OpLabel
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# one
+BUFFER variant_one DATA_TYPE float STD140 DATA
+ 1.0
+END
+# _GLF_uniform_float_values
+BUFFER variant__GLF_uniform_float_values DATA_TYPE float[] STD140 DATA
+ 1.0
+END
+# _GLF_uniform_int_values
+BUFFER variant__GLF_uniform_int_values DATA_TYPE int32[] STD140 DATA
+ 0 1
+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_one AS uniform DESCRIPTOR_SET 0 BINDING 2
+ BIND BUFFER variant__GLF_uniform_float_values AS uniform DESCRIPTOR_SET 0 BINDING 1
+ BIND BUFFER variant__GLF_uniform_int_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
--- /dev/null
+#!amber
+
+# Copyright 2021 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_1 _GLF_uniform_int_values[0]
+# #define _int_0 _GLF_uniform_int_values[1]
+# #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: [1, 0]
+# layout(set = 0, binding = 1) uniform buf1
+# {
+# int _GLF_uniform_int_values[2];
+# };
+#
+# const int _GLF_global_loop_bound = 10;
+# int _GLF_global_loop_count = 0;
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void main()
+# {
+# int a = 1;
+#
+# // After this loop a becomes 6.
+# do
+# {
+# _GLF_global_loop_count ++;
+#
+# // Iterated once.
+# do
+# {
+# _GLF_global_loop_count ++;
+# a++;
+# }
+# while((gl_FragCoord.y < _float_0_0) && (_GLF_global_loop_count < _GLF_global_loop_bound));
+# }
+# while((a != 1) && (_GLF_global_loop_count < _GLF_global_loop_bound));
+#
+# // (1, a + 1) dot (1, 1) = 1 * 1 + (a + 1) * 1 = 1 + a + 1 = a + 2 = 6 + 2 = 8
+# float f = dot(vec2(1, a +_int_1), vec2(_int_1));
+# if(f > 7.9 && f < 8.1)
+# {
+# _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: 104
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %30 %85
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %8 "_GLF_global_loop_count"
+ OpName %11 "a"
+ OpName %30 "gl_FragCoord"
+ OpName %37 "buf0"
+ OpMemberName %37 0 "_GLF_uniform_float_values"
+ OpName %39 ""
+ OpName %55 "f"
+ OpName %60 "buf1"
+ OpMemberName %60 0 "_GLF_uniform_int_values"
+ OpName %62 ""
+ OpName %85 "_GLF_color"
+ OpDecorate %30 BuiltIn FragCoord
+ OpDecorate %36 ArrayStride 16
+ OpMemberDecorate %37 0 Offset 0
+ OpDecorate %37 Block
+ OpDecorate %39 DescriptorSet 0
+ OpDecorate %39 Binding 0
+ OpDecorate %59 ArrayStride 16
+ OpMemberDecorate %60 0 Offset 0
+ OpDecorate %60 Block
+ OpDecorate %62 DescriptorSet 0
+ OpDecorate %62 Binding 1
+ OpDecorate %85 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 = OpConstant %6 1
+ %27 = OpTypeFloat 32
+ %28 = OpTypeVector %27 4
+ %29 = OpTypePointer Input %28
+ %30 = OpVariable %29 Input
+ %31 = OpTypeInt 32 0
+ %32 = OpConstant %31 1
+ %33 = OpTypePointer Input %27
+ %36 = OpTypeArray %27 %32
+ %37 = OpTypeStruct %36
+ %38 = OpTypePointer Uniform %37
+ %39 = OpVariable %38 Uniform
+ %40 = OpTypePointer Uniform %27
+ %43 = OpTypeBool
+ %46 = OpConstant %6 10
+ %54 = OpTypePointer Function %27
+ %56 = OpConstant %27 1
+ %58 = OpConstant %31 2
+ %59 = OpTypeArray %6 %58
+ %60 = OpTypeStruct %59
+ %61 = OpTypePointer Uniform %60
+ %62 = OpVariable %61 Uniform
+ %63 = OpTypePointer Uniform %6
+ %68 = OpTypeVector %27 2
+ %76 = OpConstant %27 7.9000001
+ %79 = OpConstant %27 8.10000038
+ %84 = OpTypePointer Output %28
+ %85 = OpVariable %84 Output
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %11 = OpVariable %10 Function
+ %55 = OpVariable %54 Function
+ OpStore %8 %9
+ OpStore %11 %12
+ OpBranch %13
+ %13 = OpLabel
+ OpLoopMerge %15 %16 None
+ OpBranch %14
+ %14 = OpLabel
+ %17 = OpLoad %6 %8
+ %18 = OpIAdd %6 %17 %12
+ OpStore %8 %18
+ OpBranch %19
+ %19 = OpLabel
+ OpLoopMerge %21 %22 None
+ OpBranch %20
+ %20 = OpLabel
+ %23 = OpLoad %6 %8
+ %24 = OpIAdd %6 %23 %12
+ OpStore %8 %24
+ %25 = OpLoad %6 %11
+ %26 = OpIAdd %6 %25 %12
+ OpStore %11 %26
+ OpBranch %22
+ %22 = OpLabel
+ %34 = OpAccessChain %33 %30 %32
+ %35 = OpLoad %27 %34
+ %41 = OpAccessChain %40 %39 %9 %9
+ %42 = OpLoad %27 %41
+ %44 = OpFOrdLessThan %43 %35 %42
+ %45 = OpLoad %6 %8
+ %47 = OpSLessThan %43 %45 %46
+ %48 = OpLogicalAnd %43 %44 %47
+ OpBranchConditional %48 %19 %21
+ %21 = OpLabel
+ OpBranch %16
+ %16 = OpLabel
+ %49 = OpLoad %6 %11
+ %50 = OpINotEqual %43 %49 %12
+ %51 = OpLoad %6 %8
+ %52 = OpSLessThan %43 %51 %46
+ %53 = OpLogicalAnd %43 %50 %52
+ OpBranchConditional %53 %13 %15
+ %15 = OpLabel
+ %57 = OpLoad %6 %11
+ %64 = OpAccessChain %63 %62 %9 %9
+ %65 = OpLoad %6 %64
+ %66 = OpIAdd %6 %57 %65
+ %67 = OpConvertSToF %27 %66
+ %69 = OpCompositeConstruct %68 %56 %67
+ %70 = OpAccessChain %63 %62 %9 %9
+ %71 = OpLoad %6 %70
+ %72 = OpConvertSToF %27 %71
+ %73 = OpCompositeConstruct %68 %72 %72
+ %74 = OpDot %27 %69 %73
+ OpStore %55 %74
+ %75 = OpLoad %27 %55
+ %77 = OpFOrdGreaterThan %43 %75 %76
+ %78 = OpLoad %27 %55
+ %80 = OpFOrdLessThan %43 %78 %79
+ %81 = OpLogicalAnd %43 %77 %80
+ OpSelectionMerge %83 None
+ OpBranchConditional %81 %82 %99
+ %82 = OpLabel
+ %86 = OpAccessChain %63 %62 %9 %9
+ %87 = OpLoad %6 %86
+ %88 = OpConvertSToF %27 %87
+ %89 = OpAccessChain %63 %62 %9 %12
+ %90 = OpLoad %6 %89
+ %91 = OpConvertSToF %27 %90
+ %92 = OpAccessChain %63 %62 %9 %12
+ %93 = OpLoad %6 %92
+ %94 = OpConvertSToF %27 %93
+ %95 = OpAccessChain %63 %62 %9 %9
+ %96 = OpLoad %6 %95
+ %97 = OpConvertSToF %27 %96
+ %98 = OpCompositeConstruct %28 %88 %91 %94 %97
+ OpStore %85 %98
+ OpBranch %83
+ %99 = OpLabel
+ %100 = OpAccessChain %63 %62 %9 %12
+ %101 = OpLoad %6 %100
+ %102 = OpConvertSToF %27 %101
+ %103 = OpCompositeConstruct %28 %102 %102 %102 %102
+ OpStore %85 %103
+ OpBranch %83
+ %83 = OpLabel
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# _GLF_uniform_int_values
+BUFFER variant__GLF_uniform_int_values DATA_TYPE int32[] STD140 DATA
+ 1 0
+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
{ "cov-bitwise-and-variable-and-its-negation.amber", "cov-bitwise-and-variable-and-its-negation", "A fragment shader that covers specific LLVM code paths" },
{ "cov-bitwise-inverse-uniform-condition.amber", "cov-bitwise-inverse-uniform-condition", "A fragment shader that covers specific BRW code paths" },
{ "cov-bitwise-shift-right-always-select-one.amber", "cov-bitwise-shift-right-always-select-one", "A fragment shader that covers specific LLVM code paths" },
+{ "cov-bitwise-shift-right-full-bits-no-effect-clamp.amber", "cov-bitwise-shift-right-full-bits-no-effect-clamp", "A fragment shader that covers specific LLVM code paths" },
{ "cov-blockfrequency-several-for-loops.amber", "cov-blockfrequency-several-for-loops", "A fragment shader that covers a specific block frequency info code path." },
{ "cov-branch-probability-identity-matrix.amber", "cov-branch-probability-identity-matrix", "A fragment shader that covers a specific branch propability path" },
{ "cov-cast-float-to-int-and-back.amber", "cov-cast-float-to-int-and-back", "A fragment shader that covers specific NIR code paths" },
{ "cov-condition-loop-index-bitwise-not.amber", "cov-condition-loop-index-bitwise-not", "A fragment shader that covers specific BRW code paths" },
{ "cov-condition-matrix-determinant-uniform.amber", "cov-condition-matrix-determinant-uniform", "A fragment shader that covers specific LLVM code paths" },
{ "cov-conditional-discard-inside-loop.amber", "cov-conditional-discard-inside-loop", "A fragment shader that covers specific NIR code paths" },
+{ "cov-conditions-empty-blocks-index-array-one-divided-by-findlsb.amber", "cov-conditions-empty-blocks-index-array-one-divided-by-findlsb", "A fragment shader that covers specific LLVM code paths" },
{ "cov-const-folding-bitfieldinsert-div-one.amber", "cov-const-folding-bitfieldinsert-div-one", "A fragment shader that covers a specific const folding path" },
{ "cov-color-overwrite-identity-matrix-multiply.amber", "cov-color-overwrite-identity-matrix-multiply", "A fragment shader that covers a specific DAG code paths" },
{ "cov-const-folding-ceil-vec4.amber", "cov-const-folding-ceil-vec4", "A fragment shader that covers a specific constant folding code path" },
{ "cov-descending-loop-min-max-always-zero.amber", "cov-descending-loop-min-max-always-zero", "A fragment shader that covers specific BRW code paths" },
{ "cov-determinant-uninitialized-matrix-never-chosen.amber", "cov-determinant-uninitialized-matrix-never-chosen", "A fragment shader that covers specific BRW code paths" },
{ "cov-dfdx-dfdy-after-nested-loops.amber", "cov-dfdx-dfdy-after-nested-loops", "A fragment shader that covers specific BRW code paths" },
+{ "cov-discard-condition-loop-same-condition-again.amber", "cov-discard-condition-loop-same-condition-again", "A fragment shader that covers specific LLVM code paths" },
{ "cov-divide-matrix-transpose-by-constant.amber", "cov-divide-matrix-transpose-by-constant", "A fragment shader that covers specific VTN code path" },
{ "cov-do-while-loop-until-uniform-lt-itself.amber", "cov-do-while-loop-until-uniform-lt-itself", "A fragment shader that covers specific LLVM code paths" },
{ "cov-do-while-negative-iterator-nested-loops-increment-array-element.amber", "cov-do-while-negative-iterator-nested-loops-increment-array-element", "A fragment shader that covers specific LLVM code paths" },
{ "cov-global-loop-bound-true-logical-or.amber", "cov-global-loop-bound-true-logical-or", "A fragment shader that covers specific NIR code paths" },
{ "cov-global-loop-counter-exhaust-calling-function-twice.amber", "cov-global-loop-counter-exhaust-calling-function-twice", "A fragment shader that covers specific LLVM code paths" },
{ "cov-global-loop-counter-float-accumulate-matrix.amber", "cov-global-loop-counter-float-accumulate-matrix", "A fragment shader that covers specific BRW code paths" },
+{ "cov-global-loop-counter-for-loop-function-call-inside-never-called.amber", "cov-global-loop-counter-for-loop-function-call-inside-never-called", "A fragment shader that covers specific LLVM code paths" },
{ "cov-global-loop-counter-main-function-call.amber", "cov-global-loop-counter-main-function-call", "A fragment shader that covers specific NIR code paths" },
{ "cov-global-loop-counter-multiply-one-minus.amber", "cov-global-loop-counter-multiply-one-minus", "A fragment shader that covers specific BRW code paths" },
{ "cov-global-loop-counter-read-past-matrix-size-never-executed.amber", "cov-global-loop-counter-read-past-matrix-size-never-executed", "A fragment shader that covers specific LLVM code paths" },
{ "cov-ir-builder-constant-fold-inst-combine-calls-value-tracking-findmsb-incr-if.amber", "cov-ir-builder-constant-fold-inst-combine-calls-value-tracking-findmsb-incr-if", "Covers IR builder, constant fold, inst combine calls and value tracking code paths"},
{ "cov-irbuilder-matrix-cell-uniform.amber", "cov-irbuilder-matrix-cell-uniform", "A fragment shader that covers a specific IR builder path." },
{ "cov-isnan-asinh-clamp-always-zero.amber", "cov-isnan-asinh-clamp-always-zero", "A fragment shader that covers specific LLVM code paths" },
+{ "cov-ivec-from-uniform-float-shift-right-add-components.amber", "cov-ivec-from-uniform-float-shift-right-add-components", "A fragment shader that covers specific LLVM code paths" },
{ "cov-ivec-shift-right-by-large-number.amber", "cov-ivec-shift-right-by-large-number", "A fragment shader that covers specific LLVM code paths" },
{ "cov-large-for-loop-exit-early-set-iterator-array-element.amber", "cov-large-for-loop-exit-early-set-iterator-array-element", "A fragment shader that covers specific LLVM code paths" },
{ "cov-large-int-array-nested-loops-set-ivec-index-component-sum.amber", "cov-large-int-array-nested-loops-set-ivec-index-component-sum", "A fragment shader that covers specific LLVM code paths" },
{ "cov-loop-fragcoord-identical-condition.amber", "cov-loop-fragcoord-identical-condition", "A fragment shader that covers specific LLVM code paths" },
{ "cov-loop-increment-array-elements-clamp-index.amber", "cov-loop-increment-array-elements-clamp-index", "A fragment shader that covers specific LLVM code paths" },
{ "cov-loop-increment-integer-findmsb-minus-uniform.amber", "cov-loop-increment-integer-findmsb-minus-uniform", "A fragment shader that covers specific LLVM code paths" },
+{ "cov-loop-increment-integer-set-output-color-break.amber", "cov-loop-increment-integer-set-output-color-break", "A fragment shader that covers specific LLVM code paths" },
{ "cov-loop-increment-matrix-element-break-after-first-iteration.amber", "cov-loop-increment-matrix-element-break-after-first-iteration", "A fragment shader that covers specific NIR code paths" },
{ "cov-loop-increment-or-divide-by-loop-index.amber", "cov-loop-increment-or-divide-by-loop-index", "A fragment shader that covers specific NIR code paths" },
{ "cov-loop-integer-half-minus-one.amber", "cov-loop-integer-half-minus-one", "A fragment shader that covers specific LLVM code paths" },
{ "cov-modulo-zero-never-executed.amber", "cov-modulo-zero-never-executed", "A fragment shader that covers specific NIR code paths" },
{ "cov-multiple-fragcoord-conditions-false-never-return-sample-texture.amber", "cov-multiple-fragcoord-conditions-false-never-return-sample-texture", "A fragment shader that covers specific LLVM code paths" },
{ "cov-multiple-fragcoord-conditions-never-return-color-uninitialized.amber", "cov-multiple-fragcoord-conditions-never-return-color-uninitialized", "A fragment shader that covers specific LLVM code paths" },
+{ "cov-multiple-loops-same-condition-always-false-global-loop-counter.amber", "cov-multiple-loops-same-condition-always-false-global-loop-counter", "A fragment shader that covers specific LLVM code paths" },
{ "cov-multiple-one-iteration-loops-global-counter-write-matrices.amber", "cov-multiple-one-iteration-loops-global-counter-write-matrices", "A fragment shader that covers specific BRW code paths" },
{ "cov-nested-functions-accumulate-global-matrix.amber", "cov-nested-functions-accumulate-global-matrix", "A fragment shader that covers specific NIR code paths" },
{ "cov-nested-functions-compare-fragcood-length-zero-vector.amber", "cov-nested-functions-compare-fragcood-length-zero-vector", "A fragment shader that covers specific LLVM code paths" },
{ "cov-nested-loops-global-loop-counter-do-while-accumulate-float.amber", "cov-nested-loops-global-loop-counter-do-while-accumulate-float", "A fragment shader that covers specific BRW code paths" },
{ "cov-nested-loops-global-loop-counter-fragcoord-negative-always-false.amber", "cov-nested-loops-global-loop-counter-fragcoord-negative-always-false", "A fragment shader that covers specific LLVM code paths" },
{ "cov-nested-loops-global-loop-counter-iterator-dependency.amber", "cov-nested-loops-global-loop-counter-iterator-dependency", "A fragment shader that covers specific LLVM code paths" },
+{ "cov-nested-loops-increase-integer-dot-product.amber", "cov-nested-loops-increase-integer-dot-product", "A fragment shader that covers specific LLVM code paths" },
{ "cov-nested-loops-redundant-condition.amber", "cov-nested-loops-redundant-condition", "A fragment shader that covers specific LLVM code paths" },
{ "cov-nested-loops-sample-opposite-corners.amber", "cov-nested-loops-sample-opposite-corners", "A fragment shader that covers specific LLVM code paths" },
{ "cov-nested-loops-set-struct-data-verify-in-function.amber", "cov-nested-loops-set-struct-data-verify-in-function", "A fragment shader that covers specific BRW code paths" },
dEQP-VK.graphicsfuzz.cov-bitwise-and-variable-and-its-negation
dEQP-VK.graphicsfuzz.cov-bitwise-inverse-uniform-condition
dEQP-VK.graphicsfuzz.cov-bitwise-shift-right-always-select-one
+dEQP-VK.graphicsfuzz.cov-bitwise-shift-right-full-bits-no-effect-clamp
dEQP-VK.graphicsfuzz.cov-blockfrequency-several-for-loops
dEQP-VK.graphicsfuzz.cov-branch-probability-identity-matrix
dEQP-VK.graphicsfuzz.cov-cast-float-to-int-and-back
dEQP-VK.graphicsfuzz.cov-condition-loop-index-bitwise-not
dEQP-VK.graphicsfuzz.cov-condition-matrix-determinant-uniform
dEQP-VK.graphicsfuzz.cov-conditional-discard-inside-loop
+dEQP-VK.graphicsfuzz.cov-conditions-empty-blocks-index-array-one-divided-by-findlsb
dEQP-VK.graphicsfuzz.cov-const-folding-bitfieldinsert-div-one
dEQP-VK.graphicsfuzz.cov-color-overwrite-identity-matrix-multiply
dEQP-VK.graphicsfuzz.cov-const-folding-ceil-vec4
dEQP-VK.graphicsfuzz.cov-descending-loop-min-max-always-zero
dEQP-VK.graphicsfuzz.cov-determinant-uninitialized-matrix-never-chosen
dEQP-VK.graphicsfuzz.cov-dfdx-dfdy-after-nested-loops
+dEQP-VK.graphicsfuzz.cov-discard-condition-loop-same-condition-again
dEQP-VK.graphicsfuzz.cov-divide-matrix-transpose-by-constant
dEQP-VK.graphicsfuzz.cov-do-while-loop-until-uniform-lt-itself
dEQP-VK.graphicsfuzz.cov-do-while-negative-iterator-nested-loops-increment-array-element
dEQP-VK.graphicsfuzz.cov-global-loop-bound-true-logical-or
dEQP-VK.graphicsfuzz.cov-global-loop-counter-exhaust-calling-function-twice
dEQP-VK.graphicsfuzz.cov-global-loop-counter-float-accumulate-matrix
+dEQP-VK.graphicsfuzz.cov-global-loop-counter-for-loop-function-call-inside-never-called
dEQP-VK.graphicsfuzz.cov-global-loop-counter-main-function-call
dEQP-VK.graphicsfuzz.cov-global-loop-counter-multiply-one-minus
dEQP-VK.graphicsfuzz.cov-global-loop-counter-read-past-matrix-size-never-executed
dEQP-VK.graphicsfuzz.cov-ir-builder-constant-fold-inst-combine-calls-value-tracking-findmsb-incr-if
dEQP-VK.graphicsfuzz.cov-irbuilder-matrix-cell-uniform
dEQP-VK.graphicsfuzz.cov-isnan-asinh-clamp-always-zero
+dEQP-VK.graphicsfuzz.cov-ivec-from-uniform-float-shift-right-add-components
dEQP-VK.graphicsfuzz.cov-ivec-shift-right-by-large-number
dEQP-VK.graphicsfuzz.cov-large-for-loop-exit-early-set-iterator-array-element
dEQP-VK.graphicsfuzz.cov-large-int-array-nested-loops-set-ivec-index-component-sum
dEQP-VK.graphicsfuzz.cov-loop-fragcoord-identical-condition
dEQP-VK.graphicsfuzz.cov-loop-increment-array-elements-clamp-index
dEQP-VK.graphicsfuzz.cov-loop-increment-integer-findmsb-minus-uniform
+dEQP-VK.graphicsfuzz.cov-loop-increment-integer-set-output-color-break
dEQP-VK.graphicsfuzz.cov-loop-increment-matrix-element-break-after-first-iteration
dEQP-VK.graphicsfuzz.cov-loop-increment-or-divide-by-loop-index
dEQP-VK.graphicsfuzz.cov-loop-integer-half-minus-one
dEQP-VK.graphicsfuzz.cov-modulo-zero-never-executed
dEQP-VK.graphicsfuzz.cov-multiple-fragcoord-conditions-false-never-return-sample-texture
dEQP-VK.graphicsfuzz.cov-multiple-fragcoord-conditions-never-return-color-uninitialized
+dEQP-VK.graphicsfuzz.cov-multiple-loops-same-condition-always-false-global-loop-counter
dEQP-VK.graphicsfuzz.cov-multiple-one-iteration-loops-global-counter-write-matrices
dEQP-VK.graphicsfuzz.cov-nested-functions-accumulate-global-matrix
dEQP-VK.graphicsfuzz.cov-nested-functions-compare-fragcood-length-zero-vector
dEQP-VK.graphicsfuzz.cov-nested-loops-global-loop-counter-do-while-accumulate-float
dEQP-VK.graphicsfuzz.cov-nested-loops-global-loop-counter-fragcoord-negative-always-false
dEQP-VK.graphicsfuzz.cov-nested-loops-global-loop-counter-iterator-dependency
+dEQP-VK.graphicsfuzz.cov-nested-loops-increase-integer-dot-product
dEQP-VK.graphicsfuzz.cov-nested-loops-redundant-condition
dEQP-VK.graphicsfuzz.cov-nested-loops-sample-opposite-corners
dEQP-VK.graphicsfuzz.cov-nested-loops-set-struct-data-verify-in-function
projects / platform / upstream / VK-GL-CTS.git / commitdiff