This commit adds a batch of GraphicsFuzz coverage tests.
Components: Vulkan
New Tests:
dEQP-VK.graphicsfuzz.cov-bitwise-and-variable-and-its-negation
dEQP-VK.graphicsfuzz.cov-bitwise-shift-right-always-select-one
dEQP-VK.graphicsfuzz.cov-extend-uniform-vec2-to-vec3-matrix-multiply
dEQP-VK.graphicsfuzz.cov-fragcoord-bitwise-and-loop-reduce-value-index-array
dEQP-VK.graphicsfuzz.cov-function-loop-same-conditions-multiple-times-struct-array
dEQP-VK.graphicsfuzz.cov-function-variable-plus-one-minus-one
dEQP-VK.graphicsfuzz.cov-integer-constant-mod-variable-increased-condition-array-element
dEQP-VK.graphicsfuzz.cov-ldexp-exponent-undefined-divided-fragcoord-never-executed
dEQP-VK.graphicsfuzz.cov-loop-exit-conditions-sampler-struct-integer-variable
dEQP-VK.graphicsfuzz.cov-mix-uninitialized-vector-select-only-defined-data
dEQP-VK.graphicsfuzz.cov-nested-loops-different-iteration-rates-function-copy-array-elements
dEQP-VK.graphicsfuzz.cov-nested-loops-divide-integer-constant-always-zero
dEQP-VK.graphicsfuzz.cov-nested-loops-redundant-condition
dEQP-VK.graphicsfuzz.cov-nouble-negation-fragcoord-cast-ivec2-bitwise-and
dEQP-VK.graphicsfuzz.cov-two-loops-global-loop-counter-shift-right-zero-increment-array-element
Change-Id: I05c88a4045b807966e5f92616d01a84b97b5acdd
dEQP-VK.graphicsfuzz.cov-bitfieldinsert-undefined
dEQP-VK.graphicsfuzz.cov-bitfieldreverse-left-shift-findmsb
dEQP-VK.graphicsfuzz.cov-bitfieldreverse-loop-limit-underflow
+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-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-dummy-function-loop-array-element-increment-never-read
dEQP-VK.graphicsfuzz.cov-empty-loop-minus-one-modulo-variable-one
dEQP-VK.graphicsfuzz.cov-exp2-two
+dEQP-VK.graphicsfuzz.cov-extend-uniform-vec2-to-vec3-matrix-multiply
dEQP-VK.graphicsfuzz.cov-findlsb-division-by-zero
dEQP-VK.graphicsfuzz.cov-float-array-init-pow
dEQP-VK.graphicsfuzz.cov-fold-and-in-for-loop-range
dEQP-VK.graphicsfuzz.cov-fract-smoothstep-undefined
dEQP-VK.graphicsfuzz.cov-fract-trunc-always-zero
dEQP-VK.graphicsfuzz.cov-fragcood-multiple-conditions-function-loop-global-counter
+dEQP-VK.graphicsfuzz.cov-fragcoord-bitwise-and-loop-reduce-value-index-array
dEQP-VK.graphicsfuzz.cov-fragcoord-bitwise-not
dEQP-VK.graphicsfuzz.cov-fragcoord-clamp-array-access
dEQP-VK.graphicsfuzz.cov-fragcoord-conditions-never-return-index-array-using-uniform
dEQP-VK.graphicsfuzz.cov-function-fragcoord-condition-always-return
dEQP-VK.graphicsfuzz.cov-function-large-array-max-clamp
dEQP-VK.graphicsfuzz.cov-function-loop-condition-uniform-shift-right
+dEQP-VK.graphicsfuzz.cov-function-loop-same-conditions-multiple-times-struct-array
dEQP-VK.graphicsfuzz.cov-function-nested-do-whiles-looped-once
dEQP-VK.graphicsfuzz.cov-function-nested-loops-break-early-never-discard
dEQP-VK.graphicsfuzz.cov-function-trivial-switch-case
dEQP-VK.graphicsfuzz.cov-function-two-loops-limit-using-arguments-array-element-copies
dEQP-VK.graphicsfuzz.cov-function-unpack-unorm-2x16-one
+dEQP-VK.graphicsfuzz.cov-function-variable-plus-one-minus-one
dEQP-VK.graphicsfuzz.cov-function-vec2-never-discard
dEQP-VK.graphicsfuzz.cov-function-with-nested-loops-called-from-nested-loops
dEQP-VK.graphicsfuzz.cov-global-loop-bound-true-logical-or
dEQP-VK.graphicsfuzz.cov-int-div-round-to-zero
dEQP-VK.graphicsfuzz.cov-int-full-bits-divide-by-two-loop
dEQP-VK.graphicsfuzz.cov-int-initialize-from-multiple-large-arrays
+dEQP-VK.graphicsfuzz.cov-integer-constant-mod-variable-increased-condition-array-element
dEQP-VK.graphicsfuzz.cov-integer-minus-one-increased-before-indexing-array
dEQP-VK.graphicsfuzz.cov-integer-modulo-negative
dEQP-VK.graphicsfuzz.cov-intervalmap-set-stop
dEQP-VK.graphicsfuzz.cov-isnan-asinh-clamp-always-zero
dEQP-VK.graphicsfuzz.cov-ivec-shift-right-by-large-number
dEQP-VK.graphicsfuzz.cov-large-int-array-nested-loops-set-ivec-index-component-sum
+dEQP-VK.graphicsfuzz.cov-ldexp-exponent-undefined-divided-fragcoord-never-executed
dEQP-VK.graphicsfuzz.cov-ldexp-undefined-mat-vec-multiply
dEQP-VK.graphicsfuzz.cov-left-shift-array-access
dEQP-VK.graphicsfuzz.cov-left-shift-right-shift-compare
dEQP-VK.graphicsfuzz.cov-loop-condition-double-negate
dEQP-VK.graphicsfuzz.cov-loop-condition-logical-or-never-iterated
dEQP-VK.graphicsfuzz.cov-loop-dfdx-constant-divide
+dEQP-VK.graphicsfuzz.cov-loop-exit-conditions-sampler-struct-integer-variable
dEQP-VK.graphicsfuzz.cov-loop-findmsb-findlsb
dEQP-VK.graphicsfuzz.cov-loop-fragcoord-identical-condition
dEQP-VK.graphicsfuzz.cov-loop-increment-array-elements-clamp-index
dEQP-VK.graphicsfuzz.cov-min-negative-constant-always-below-one
dEQP-VK.graphicsfuzz.cov-min-nested-loop-same-value-for-variables
dEQP-VK.graphicsfuzz.cov-missing-return-value-function-never-called
+dEQP-VK.graphicsfuzz.cov-mix-uninitialized-vector-select-only-defined-data
dEQP-VK.graphicsfuzz.cov-mod-acosh
dEQP-VK.graphicsfuzz.cov-mod-uint-bits-float
dEQP-VK.graphicsfuzz.cov-modf-clamp-for
dEQP-VK.graphicsfuzz.cov-nested-loop-not-greater-than-increment-array-element
dEQP-VK.graphicsfuzz.cov-nested-loop-undefined-smoothstep-never-executed
dEQP-VK.graphicsfuzz.cov-nested-loops-clamp-ivec-push-constant-increment-global-counter
+dEQP-VK.graphicsfuzz.cov-nested-loops-different-iteration-rates-function-copy-array-elements
+dEQP-VK.graphicsfuzz.cov-nested-loops-divide-integer-constant-always-zero
dEQP-VK.graphicsfuzz.cov-nested-loops-decrease-vector-component-by-matrix-element-global-loop-counter
dEQP-VK.graphicsfuzz.cov-nested-loops-float-array-select-by-fragcoord
dEQP-VK.graphicsfuzz.cov-nested-loops-float-bits-to-int-increment-array
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-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-nir-array-access
dEQP-VK.graphicsfuzz.cov-nir-opt-large-constants-for-clamp-vector-access
dEQP-VK.graphicsfuzz.cov-nir-opt-loop-unroll-if-if-if-if-do-while
+dEQP-VK.graphicsfuzz.cov-nouble-negation-fragcoord-cast-ivec2-bitwise-and
dEQP-VK.graphicsfuzz.cov-one-minus-clamp-always-one-cast-to-int
dEQP-VK.graphicsfuzz.cov-optimize-phis-for
dEQP-VK.graphicsfuzz.cov-optimize-phis-for-for-do-while-if-if
dEQP-VK.graphicsfuzz.cov-texel-double-negation
dEQP-VK.graphicsfuzz.cov-transpose-multiply
dEQP-VK.graphicsfuzz.cov-trunc-fract-always-zero
+dEQP-VK.graphicsfuzz.cov-two-loops-global-loop-counter-shift-right-zero-increment-array-element
dEQP-VK.graphicsfuzz.cov-two-nested-loops-switch-case-matrix-array-increment
dEQP-VK.graphicsfuzz.cov-types-return-in-main-never-hit
dEQP-VK.graphicsfuzz.cov-ucarryadd-one-and-one
dEQP-VK.graphicsfuzz.cov-bitfieldinsert-undefined
dEQP-VK.graphicsfuzz.cov-bitfieldreverse-left-shift-findmsb
dEQP-VK.graphicsfuzz.cov-bitfieldreverse-loop-limit-underflow
+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-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-dummy-function-loop-array-element-increment-never-read
dEQP-VK.graphicsfuzz.cov-empty-loop-minus-one-modulo-variable-one
dEQP-VK.graphicsfuzz.cov-exp2-two
+dEQP-VK.graphicsfuzz.cov-extend-uniform-vec2-to-vec3-matrix-multiply
dEQP-VK.graphicsfuzz.cov-findlsb-division-by-zero
dEQP-VK.graphicsfuzz.cov-float-array-init-pow
dEQP-VK.graphicsfuzz.cov-fold-and-in-for-loop-range
dEQP-VK.graphicsfuzz.cov-fract-smoothstep-undefined
dEQP-VK.graphicsfuzz.cov-fract-trunc-always-zero
dEQP-VK.graphicsfuzz.cov-fragcood-multiple-conditions-function-loop-global-counter
+dEQP-VK.graphicsfuzz.cov-fragcoord-bitwise-and-loop-reduce-value-index-array
dEQP-VK.graphicsfuzz.cov-fragcoord-bitwise-not
dEQP-VK.graphicsfuzz.cov-fragcoord-clamp-array-access
dEQP-VK.graphicsfuzz.cov-fragcoord-conditions-never-return-index-array-using-uniform
dEQP-VK.graphicsfuzz.cov-function-fragcoord-condition-always-return
dEQP-VK.graphicsfuzz.cov-function-large-array-max-clamp
dEQP-VK.graphicsfuzz.cov-function-loop-condition-uniform-shift-right
+dEQP-VK.graphicsfuzz.cov-function-loop-same-conditions-multiple-times-struct-array
dEQP-VK.graphicsfuzz.cov-function-nested-do-whiles-looped-once
dEQP-VK.graphicsfuzz.cov-function-nested-loops-break-early-never-discard
dEQP-VK.graphicsfuzz.cov-function-trivial-switch-case
dEQP-VK.graphicsfuzz.cov-function-two-loops-limit-using-arguments-array-element-copies
dEQP-VK.graphicsfuzz.cov-function-unpack-unorm-2x16-one
+dEQP-VK.graphicsfuzz.cov-function-variable-plus-one-minus-one
dEQP-VK.graphicsfuzz.cov-function-vec2-never-discard
dEQP-VK.graphicsfuzz.cov-function-with-nested-loops-called-from-nested-loops
dEQP-VK.graphicsfuzz.cov-global-loop-bound-true-logical-or
dEQP-VK.graphicsfuzz.cov-int-div-round-to-zero
dEQP-VK.graphicsfuzz.cov-int-full-bits-divide-by-two-loop
dEQP-VK.graphicsfuzz.cov-int-initialize-from-multiple-large-arrays
+dEQP-VK.graphicsfuzz.cov-integer-constant-mod-variable-increased-condition-array-element
dEQP-VK.graphicsfuzz.cov-integer-minus-one-increased-before-indexing-array
dEQP-VK.graphicsfuzz.cov-integer-modulo-negative
dEQP-VK.graphicsfuzz.cov-intervalmap-set-stop
dEQP-VK.graphicsfuzz.cov-isnan-asinh-clamp-always-zero
dEQP-VK.graphicsfuzz.cov-ivec-shift-right-by-large-number
dEQP-VK.graphicsfuzz.cov-large-int-array-nested-loops-set-ivec-index-component-sum
+dEQP-VK.graphicsfuzz.cov-ldexp-exponent-undefined-divided-fragcoord-never-executed
dEQP-VK.graphicsfuzz.cov-ldexp-undefined-mat-vec-multiply
dEQP-VK.graphicsfuzz.cov-left-shift-array-access
dEQP-VK.graphicsfuzz.cov-left-shift-right-shift-compare
dEQP-VK.graphicsfuzz.cov-loop-condition-double-negate
dEQP-VK.graphicsfuzz.cov-loop-condition-logical-or-never-iterated
dEQP-VK.graphicsfuzz.cov-loop-dfdx-constant-divide
+dEQP-VK.graphicsfuzz.cov-loop-exit-conditions-sampler-struct-integer-variable
dEQP-VK.graphicsfuzz.cov-loop-findmsb-findlsb
dEQP-VK.graphicsfuzz.cov-loop-fragcoord-identical-condition
dEQP-VK.graphicsfuzz.cov-loop-increment-array-elements-clamp-index
dEQP-VK.graphicsfuzz.cov-min-negative-constant-always-below-one
dEQP-VK.graphicsfuzz.cov-min-nested-loop-same-value-for-variables
dEQP-VK.graphicsfuzz.cov-missing-return-value-function-never-called
+dEQP-VK.graphicsfuzz.cov-mix-uninitialized-vector-select-only-defined-data
dEQP-VK.graphicsfuzz.cov-mod-acosh
dEQP-VK.graphicsfuzz.cov-mod-uint-bits-float
dEQP-VK.graphicsfuzz.cov-modf-clamp-for
dEQP-VK.graphicsfuzz.cov-nested-loop-not-greater-than-increment-array-element
dEQP-VK.graphicsfuzz.cov-nested-loop-undefined-smoothstep-never-executed
dEQP-VK.graphicsfuzz.cov-nested-loops-clamp-ivec-push-constant-increment-global-counter
+dEQP-VK.graphicsfuzz.cov-nested-loops-different-iteration-rates-function-copy-array-elements
+dEQP-VK.graphicsfuzz.cov-nested-loops-divide-integer-constant-always-zero
dEQP-VK.graphicsfuzz.cov-nested-loops-decrease-vector-component-by-matrix-element-global-loop-counter
dEQP-VK.graphicsfuzz.cov-nested-loops-float-array-select-by-fragcoord
dEQP-VK.graphicsfuzz.cov-nested-loops-float-bits-to-int-increment-array
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-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-nir-array-access
dEQP-VK.graphicsfuzz.cov-nir-opt-large-constants-for-clamp-vector-access
dEQP-VK.graphicsfuzz.cov-nir-opt-loop-unroll-if-if-if-if-do-while
+dEQP-VK.graphicsfuzz.cov-nouble-negation-fragcoord-cast-ivec2-bitwise-and
dEQP-VK.graphicsfuzz.cov-one-minus-clamp-always-one-cast-to-int
dEQP-VK.graphicsfuzz.cov-optimize-phis-for
dEQP-VK.graphicsfuzz.cov-optimize-phis-for-for-do-while-if-if
dEQP-VK.graphicsfuzz.cov-texel-double-negation
dEQP-VK.graphicsfuzz.cov-transpose-multiply
dEQP-VK.graphicsfuzz.cov-trunc-fract-always-zero
+dEQP-VK.graphicsfuzz.cov-two-loops-global-loop-counter-shift-right-zero-increment-array-element
dEQP-VK.graphicsfuzz.cov-two-nested-loops-switch-case-matrix-array-increment
dEQP-VK.graphicsfuzz.cov-types-return-in-main-never-hit
dEQP-VK.graphicsfuzz.cov-ucarryadd-one-and-one
--- /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]
+#
+# precision highp int;
+# precision highp float;
+#
+# // Contents of _GLF_uniform_int_values: [1, 0]
+# layout(set = 0, binding = 0) uniform buf0
+# {
+# int _GLF_uniform_int_values[2];
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void main()
+# {
+# // After this a has either all or none of the bits as one.
+# int a = (int(gl_FragCoord.y) & 1) != 0 ? 0 : ~ 0;
+#
+# // Bitwise AND with a negation is always zero.
+# if((a & (~a)) == _int_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: 61
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %12 %42
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %8 "a"
+ OpName %12 "gl_FragCoord"
+ OpName %32 "buf0"
+ OpMemberName %32 0 "_GLF_uniform_int_values"
+ OpName %34 ""
+ OpName %42 "_GLF_color"
+ OpDecorate %12 BuiltIn FragCoord
+ OpDecorate %31 ArrayStride 16
+ OpMemberDecorate %32 0 Offset 0
+ OpDecorate %32 Block
+ OpDecorate %34 DescriptorSet 0
+ OpDecorate %34 Binding 0
+ OpDecorate %42 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeInt 32 1
+ %7 = OpTypePointer Function %6
+ %9 = OpTypeFloat 32
+ %10 = OpTypeVector %9 4
+ %11 = OpTypePointer Input %10
+ %12 = OpVariable %11 Input
+ %13 = OpTypeInt 32 0
+ %14 = OpConstant %13 1
+ %15 = OpTypePointer Input %9
+ %19 = OpConstant %6 1
+ %21 = OpConstant %6 0
+ %22 = OpTypeBool
+ %24 = OpConstant %6 -1
+ %30 = OpConstant %13 2
+ %31 = OpTypeArray %6 %30
+ %32 = OpTypeStruct %31
+ %33 = OpTypePointer Uniform %32
+ %34 = OpVariable %33 Uniform
+ %35 = OpTypePointer Uniform %6
+ %41 = OpTypePointer Output %10
+ %42 = OpVariable %41 Output
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %8 = OpVariable %7 Function
+ %16 = OpAccessChain %15 %12 %14
+ %17 = OpLoad %9 %16
+ %18 = OpConvertFToS %6 %17
+ %20 = OpBitwiseAnd %6 %18 %19
+ %23 = OpINotEqual %22 %20 %21
+ %25 = OpSelect %6 %23 %21 %24
+ OpStore %8 %25
+ %26 = OpLoad %6 %8
+ %27 = OpLoad %6 %8
+ %28 = OpNot %6 %27
+ %29 = OpBitwiseAnd %6 %26 %28
+ %36 = OpAccessChain %35 %34 %21 %19
+ %37 = OpLoad %6 %36
+ %38 = OpIEqual %22 %29 %37
+ OpSelectionMerge %40 None
+ OpBranchConditional %38 %39 %56
+ %39 = OpLabel
+ %43 = OpAccessChain %35 %34 %21 %21
+ %44 = OpLoad %6 %43
+ %45 = OpConvertSToF %9 %44
+ %46 = OpAccessChain %35 %34 %21 %19
+ %47 = OpLoad %6 %46
+ %48 = OpConvertSToF %9 %47
+ %49 = OpAccessChain %35 %34 %21 %19
+ %50 = OpLoad %6 %49
+ %51 = OpConvertSToF %9 %50
+ %52 = OpAccessChain %35 %34 %21 %21
+ %53 = OpLoad %6 %52
+ %54 = OpConvertSToF %9 %53
+ %55 = OpCompositeConstruct %10 %45 %48 %51 %54
+ OpStore %42 %55
+ OpBranch %40
+ %56 = OpLabel
+ %57 = OpAccessChain %35 %34 %21 %19
+ %58 = OpLoad %6 %57
+ %59 = OpConvertSToF %9 %58
+ %60 = OpCompositeConstruct %10 %59 %59 %59 %59
+ OpStore %42 %60
+ OpBranch %40
+ %40 = 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
+
+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_1 _GLF_uniform_int_values[0]
+# #define _int_0 _GLF_uniform_int_values[1]
+# #define _int_2 _GLF_uniform_int_values[2]
+# #define _float_0_0 _GLF_uniform_float_values[0]
+#
+# precision highp int;
+# precision highp float;
+#
+# // 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, 2]
+# layout(set = 0, binding = 1) uniform buf1
+# {
+# int _GLF_uniform_int_values[3];
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void main()
+# {
+# // Shifting by 256 would be undefined, but value one is always selected.
+# if(4 >> (gl_FragCoord.y < _float_0_0 ? 256 : 1) == _int_2)
+# {
+# _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: 63
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %11 %44
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %11 "gl_FragCoord"
+ OpName %18 "buf0"
+ OpMemberName %18 0 "_GLF_uniform_float_values"
+ OpName %20 ""
+ OpName %33 "buf1"
+ OpMemberName %33 0 "_GLF_uniform_int_values"
+ OpName %35 ""
+ OpName %44 "_GLF_color"
+ OpDecorate %11 BuiltIn FragCoord
+ OpDecorate %17 ArrayStride 16
+ OpMemberDecorate %18 0 Offset 0
+ OpDecorate %18 Block
+ OpDecorate %20 DescriptorSet 0
+ OpDecorate %20 Binding 0
+ OpDecorate %32 ArrayStride 16
+ OpMemberDecorate %33 0 Offset 0
+ OpDecorate %33 Block
+ OpDecorate %35 DescriptorSet 0
+ OpDecorate %35 Binding 1
+ OpDecorate %44 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeInt 32 1
+ %7 = OpConstant %6 4
+ %8 = OpTypeFloat 32
+ %9 = OpTypeVector %8 4
+ %10 = OpTypePointer Input %9
+ %11 = OpVariable %10 Input
+ %12 = OpTypeInt 32 0
+ %13 = OpConstant %12 1
+ %14 = OpTypePointer Input %8
+ %17 = OpTypeArray %8 %13
+ %18 = OpTypeStruct %17
+ %19 = OpTypePointer Uniform %18
+ %20 = OpVariable %19 Uniform
+ %21 = OpConstant %6 0
+ %22 = OpTypePointer Uniform %8
+ %25 = OpTypeBool
+ %27 = OpConstant %6 256
+ %28 = OpConstant %6 1
+ %31 = OpConstant %12 3
+ %32 = OpTypeArray %6 %31
+ %33 = OpTypeStruct %32
+ %34 = OpTypePointer Uniform %33
+ %35 = OpVariable %34 Uniform
+ %36 = OpConstant %6 2
+ %37 = OpTypePointer Uniform %6
+ %43 = OpTypePointer Output %9
+ %44 = OpVariable %43 Output
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %15 = OpAccessChain %14 %11 %13
+ %16 = OpLoad %8 %15
+ %23 = OpAccessChain %22 %20 %21 %21
+ %24 = OpLoad %8 %23
+ %26 = OpFOrdLessThan %25 %16 %24
+ %29 = OpSelect %6 %26 %27 %28
+ %30 = OpShiftRightArithmetic %6 %7 %29
+ %38 = OpAccessChain %37 %35 %21 %36
+ %39 = OpLoad %6 %38
+ %40 = OpIEqual %25 %30 %39
+ OpSelectionMerge %42 None
+ OpBranchConditional %40 %41 %58
+ %41 = OpLabel
+ %45 = OpAccessChain %37 %35 %21 %21
+ %46 = OpLoad %6 %45
+ %47 = OpConvertSToF %8 %46
+ %48 = OpAccessChain %37 %35 %21 %28
+ %49 = OpLoad %6 %48
+ %50 = OpConvertSToF %8 %49
+ %51 = OpAccessChain %37 %35 %21 %28
+ %52 = OpLoad %6 %51
+ %53 = OpConvertSToF %8 %52
+ %54 = OpAccessChain %37 %35 %21 %21
+ %55 = OpLoad %6 %54
+ %56 = OpConvertSToF %8 %55
+ %57 = OpCompositeConstruct %9 %47 %50 %53 %56
+ OpStore %44 %57
+ OpBranch %42
+ %58 = OpLabel
+ %59 = OpAccessChain %37 %35 %21 %28
+ %60 = OpLoad %6 %59
+ %61 = OpConvertSToF %8 %60
+ %62 = OpCompositeConstruct %9 %61 %61 %61 %61
+ OpStore %44 %62
+ OpBranch %42
+ %42 = 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
+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
--- /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 _float_1_0 _GLF_uniform_float_values[0]
+# #define _float_0_0 _GLF_uniform_float_values[1]
+#
+# precision highp float;
+# precision highp int;
+#
+# // Contents of _GLF_uniform_float_values: [1.0, 0.0]
+# layout(set = 0, binding = 0) uniform buf0
+# {
+# float _GLF_uniform_float_values[2];
+# };
+#
+# // Contents of _GLF_uniform_int_values: 0
+# layout(set = 0, binding = 1) uniform buf1
+# {
+# int _GLF_uniform_int_values[1];
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# // Contents of resolution: [256.0, 256.0]
+# layout(set = 0, binding = 2) uniform buf2
+# {
+# vec2 resolution;
+# };
+#
+# void main()
+# {
+# // v becomes (0, 0).
+# vec2 v = (mat3(_float_0_0) * vec3(resolution, 1)).xy;
+#
+# // Always true.
+# if(v == vec2(_int_0))
+# {
+# _GLF_color = vec4(_float_1_0, v, _float_1_0);
+# }
+# 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: 74
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %60
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %9 "v"
+ OpName %13 "buf0"
+ OpMemberName %13 0 "_GLF_uniform_float_values"
+ OpName %15 ""
+ OpName %30 "buf2"
+ OpMemberName %30 0 "resolution"
+ OpName %32 ""
+ OpName %44 "buf1"
+ OpMemberName %44 0 "_GLF_uniform_int_values"
+ OpName %46 ""
+ OpName %60 "_GLF_color"
+ OpDecorate %12 ArrayStride 16
+ OpMemberDecorate %13 0 Offset 0
+ OpDecorate %13 Block
+ OpDecorate %15 DescriptorSet 0
+ OpDecorate %15 Binding 0
+ OpMemberDecorate %30 0 Offset 0
+ OpDecorate %30 Block
+ OpDecorate %32 DescriptorSet 0
+ OpDecorate %32 Binding 2
+ OpDecorate %43 ArrayStride 16
+ OpMemberDecorate %44 0 Offset 0
+ OpDecorate %44 Block
+ OpDecorate %46 DescriptorSet 0
+ OpDecorate %46 Binding 1
+ OpDecorate %60 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeFloat 32
+ %7 = OpTypeVector %6 2
+ %8 = OpTypePointer Function %7
+ %10 = OpTypeInt 32 0
+ %11 = OpConstant %10 2
+ %12 = OpTypeArray %6 %11
+ %13 = OpTypeStruct %12
+ %14 = OpTypePointer Uniform %13
+ %15 = OpVariable %14 Uniform
+ %16 = OpTypeInt 32 1
+ %17 = OpConstant %16 0
+ %18 = OpConstant %16 1
+ %19 = OpTypePointer Uniform %6
+ %22 = OpTypeVector %6 3
+ %23 = OpTypeMatrix %22 3
+ %24 = OpConstant %6 1
+ %25 = OpConstant %6 0
+ %30 = OpTypeStruct %7
+ %31 = OpTypePointer Uniform %30
+ %32 = OpVariable %31 Uniform
+ %33 = OpTypePointer Uniform %7
+ %42 = OpConstant %10 1
+ %43 = OpTypeArray %16 %42
+ %44 = OpTypeStruct %43
+ %45 = OpTypePointer Uniform %44
+ %46 = OpVariable %45 Uniform
+ %47 = OpTypePointer Uniform %16
+ %52 = OpTypeBool
+ %53 = OpTypeVector %52 2
+ %58 = OpTypeVector %6 4
+ %59 = OpTypePointer Output %58
+ %60 = OpVariable %59 Output
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %9 = OpVariable %8 Function
+ %20 = OpAccessChain %19 %15 %17 %18
+ %21 = OpLoad %6 %20
+ %26 = OpCompositeConstruct %22 %21 %25 %25
+ %27 = OpCompositeConstruct %22 %25 %21 %25
+ %28 = OpCompositeConstruct %22 %25 %25 %21
+ %29 = OpCompositeConstruct %23 %26 %27 %28
+ %34 = OpAccessChain %33 %32 %17
+ %35 = OpLoad %7 %34
+ %36 = OpCompositeExtract %6 %35 0
+ %37 = OpCompositeExtract %6 %35 1
+ %38 = OpCompositeConstruct %22 %36 %37 %24
+ %39 = OpMatrixTimesVector %22 %29 %38
+ %40 = OpVectorShuffle %7 %39 %39 0 1
+ OpStore %9 %40
+ %41 = OpLoad %7 %9
+ %48 = OpAccessChain %47 %46 %17 %17
+ %49 = OpLoad %16 %48
+ %50 = OpConvertSToF %6 %49
+ %51 = OpCompositeConstruct %7 %50 %50
+ %54 = OpFOrdEqual %53 %41 %51
+ %55 = OpAll %52 %54
+ OpSelectionMerge %57 None
+ OpBranchConditional %55 %56 %69
+ %56 = OpLabel
+ %61 = OpAccessChain %19 %15 %17 %17
+ %62 = OpLoad %6 %61
+ %63 = OpLoad %7 %9
+ %64 = OpAccessChain %19 %15 %17 %17
+ %65 = OpLoad %6 %64
+ %66 = OpCompositeExtract %6 %63 0
+ %67 = OpCompositeExtract %6 %63 1
+ %68 = OpCompositeConstruct %58 %62 %66 %67 %65
+ OpStore %60 %68
+ OpBranch %57
+ %69 = OpLabel
+ %70 = OpAccessChain %47 %46 %17 %17
+ %71 = OpLoad %16 %70
+ %72 = OpConvertSToF %6 %71
+ %73 = OpCompositeConstruct %58 %72 %72 %72 %72
+ OpStore %60 %73
+ OpBranch %57
+ %57 = OpLabel
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# resolution
+BUFFER variant_resolution DATA_TYPE vec2<float> STD140 DATA
+ 256.0 256.0
+END
+# _GLF_uniform_int_values
+BUFFER variant__GLF_uniform_int_values DATA_TYPE int32[] STD140 DATA
+ 0
+END
+# _GLF_uniform_float_values
+BUFFER variant__GLF_uniform_float_values DATA_TYPE float[] STD140 DATA
+ 1.0 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_resolution 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 texgen_vert PASSTHROUGH
+
+SHADER fragment texgen_frag GLSL
+#version 430
+precision highp float;
+
+layout(location = 0) out vec4 _GLF_color;
+
+void main()
+{
+ _GLF_color = vec4(
+ gl_FragCoord.x * (1.0 / 256.0),
+ (int(gl_FragCoord.x) ^ int(gl_FragCoord.y)) * (1.0 / 256.0),
+ gl_FragCoord.y * (1.0 / 256.0),
+ 1.0);
+}
+END
+BUFFER default_texture FORMAT B8G8R8A8_UNORM
+
+PIPELINE graphics texgen_pipeline
+ ATTACH texgen_vert
+ ATTACH texgen_frag
+ FRAMEBUFFER_SIZE 256 256
+ BIND BUFFER default_texture AS color LOCATION 0
+END
+
+CLEAR_COLOR texgen_pipeline 0 0 0 255
+CLEAR texgen_pipeline
+RUN texgen_pipeline DRAW_RECT POS 0 0 SIZE 256 256
+
+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 sampler2D tex;
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void main()
+# {
+# ivec2 ipos = ivec2(gl_FragCoord.xy);
+# int a = (ipos.x & 5) + ((ipos.y & 5) | (ipos.x & 10));
+#
+# // This loop reduces a to a range of 0..3.
+# while(a > 3)
+# {
+# vec4 v = texture(tex, vec2(1.0));
+#
+# // Sampled values are between 0..1 making this condition always false.
+# while(v.x > 2.0)
+# {
+# }
+#
+# a -= 4;
+# }
+#
+# // Always true.
+# if (a >= 0 && a < 4)
+# _GLF_color = vec4[4](vec4(1, 0, 0, 1), vec4(1, 0, 0, 1), vec4(1, 0, 0, 1), vec4(1, 0, 0, 1))[a];
+# 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: 90
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %13 %77
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %9 "ipos"
+ OpName %13 "gl_FragCoord"
+ OpName %19 "a"
+ OpName %46 "v"
+ OpName %50 "tex"
+ OpName %77 "_GLF_color"
+ OpName %85 "indexable"
+ OpDecorate %13 BuiltIn FragCoord
+ OpDecorate %50 RelaxedPrecision
+ OpDecorate %50 DescriptorSet 0
+ OpDecorate %50 Binding 0
+ OpDecorate %51 RelaxedPrecision
+ OpDecorate %54 RelaxedPrecision
+ OpDecorate %77 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeInt 32 1
+ %7 = OpTypeVector %6 2
+ %8 = OpTypePointer Function %7
+ %10 = OpTypeFloat 32
+ %11 = OpTypeVector %10 4
+ %12 = OpTypePointer Input %11
+ %13 = OpVariable %12 Input
+ %14 = OpTypeVector %10 2
+ %18 = OpTypePointer Function %6
+ %20 = OpTypeInt 32 0
+ %21 = OpConstant %20 0
+ %24 = OpConstant %6 5
+ %26 = OpConstant %20 1
+ %32 = OpConstant %6 10
+ %42 = OpConstant %6 3
+ %43 = OpTypeBool
+ %45 = OpTypePointer Function %11
+ %47 = OpTypeImage %10 2D 0 0 0 1 Unknown
+ %48 = OpTypeSampledImage %47
+ %49 = OpTypePointer UniformConstant %48
+ %50 = OpVariable %49 UniformConstant
+ %52 = OpConstant %10 1
+ %53 = OpConstantComposite %14 %52 %52
+ %60 = OpTypePointer Function %10
+ %63 = OpConstant %10 2
+ %65 = OpConstant %6 4
+ %69 = OpConstant %6 0
+ %76 = OpTypePointer Output %11
+ %77 = OpVariable %76 Output
+ %78 = OpConstant %20 4
+ %79 = OpTypeArray %11 %78
+ %80 = OpConstant %10 0
+ %81 = OpConstantComposite %11 %52 %80 %80 %52
+ %82 = OpConstantComposite %79 %81 %81 %81 %81
+ %84 = OpTypePointer Function %79
+ %89 = OpConstantComposite %11 %80 %80 %80 %80
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %9 = OpVariable %8 Function
+ %19 = OpVariable %18 Function
+ %46 = OpVariable %45 Function
+ %85 = OpVariable %84 Function
+ %15 = OpLoad %11 %13
+ %16 = OpVectorShuffle %14 %15 %15 0 1
+ %17 = OpConvertFToS %7 %16
+ OpStore %9 %17
+ %22 = OpAccessChain %18 %9 %21
+ %23 = OpLoad %6 %22
+ %25 = OpBitwiseAnd %6 %23 %24
+ %27 = OpAccessChain %18 %9 %26
+ %28 = OpLoad %6 %27
+ %29 = OpBitwiseAnd %6 %28 %24
+ %30 = OpAccessChain %18 %9 %21
+ %31 = OpLoad %6 %30
+ %33 = OpBitwiseAnd %6 %31 %32
+ %34 = OpBitwiseOr %6 %29 %33
+ %35 = OpIAdd %6 %25 %34
+ OpStore %19 %35
+ OpBranch %36
+ %36 = OpLabel
+ OpLoopMerge %38 %39 None
+ OpBranch %40
+ %40 = OpLabel
+ %41 = OpLoad %6 %19
+ %44 = OpSGreaterThan %43 %41 %42
+ OpBranchConditional %44 %37 %38
+ %37 = OpLabel
+ %51 = OpLoad %48 %50
+ %54 = OpImageSampleImplicitLod %11 %51 %53
+ OpStore %46 %54
+ OpBranch %55
+ %55 = OpLabel
+ OpLoopMerge %57 %58 None
+ OpBranch %59
+ %59 = OpLabel
+ %61 = OpAccessChain %60 %46 %21
+ %62 = OpLoad %10 %61
+ %64 = OpFOrdGreaterThan %43 %62 %63
+ OpBranchConditional %64 %56 %57
+ %56 = OpLabel
+ OpBranch %58
+ %58 = OpLabel
+ OpBranch %55
+ %57 = OpLabel
+ %66 = OpLoad %6 %19
+ %67 = OpISub %6 %66 %65
+ OpStore %19 %67
+ OpBranch %39
+ %39 = OpLabel
+ OpBranch %36
+ %38 = OpLabel
+ %68 = OpLoad %6 %19
+ %70 = OpSGreaterThanEqual %43 %68 %69
+ %71 = OpLoad %6 %19
+ %72 = OpSLessThan %43 %71 %65
+ %73 = OpLogicalAnd %43 %70 %72
+ OpSelectionMerge %75 None
+ OpBranchConditional %73 %74 %88
+ %74 = OpLabel
+ %83 = OpLoad %6 %19
+ OpStore %85 %82
+ %86 = OpAccessChain %45 %85 %83
+ %87 = OpLoad %11 %86
+ OpStore %77 %87
+ OpBranch %75
+ %88 = OpLabel
+ OpStore %77 %89
+ OpBranch %75
+ %75 = OpLabel
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# GLF_dead6tex
+SAMPLER variant_GLF_dead6tex
+
+
+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 default_texture AS combined_image_sampler SAMPLER variant_GLF_dead6tex 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_5 _GLF_uniform_int_values[0]
+# #define _int_0 _GLF_uniform_int_values[1]
+# #define _int_11 _GLF_uniform_int_values[2]
+# #define _int_1 _GLF_uniform_int_values[3]
+# #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: [5, 0, 11, 1]
+# layout(set = 0, binding = 1) uniform buf1
+# {
+# int _GLF_uniform_int_values[4];
+# };
+#
+# // Contents of injectionSwitch: [0.0, 1.0]
+# layout(push_constant) uniform buf_push
+# {
+# highp vec2 injectionSwitch;
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# struct S
+# {
+# int data;
+# };
+#
+# S arr[10] = S[10](S(1), S(2), S(3), S(4), S(5), S(6), S(7), S(8), S(9), S(10));
+#
+# void func0(inout S s)
+# {
+# }
+#
+# int func1()
+# {
+# int a = _int_0;
+#
+# // Each iteration increases a by one.
+# for(int i = _int_0; i < _int_5; i++)
+# {
+# // s.data is always a + 1.
+# S s = arr[a];
+#
+# // Always false.
+# if(gl_FragCoord.x < _float_0_0)
+# {
+# continue;
+# }
+#
+# // Always false.
+# if(injectionSwitch.x > injectionSwitch.y)
+# {
+# continue;
+# }
+#
+# // Always false.
+# if(s.data == _int_11)
+# {
+# return -1;
+# }
+#
+# // Always false.
+# if(injectionSwitch.x > injectionSwitch.y)
+# {
+# break;
+# }
+#
+# // Always false.
+# if(gl_FragCoord.x < _float_0_0)
+# {
+# return - 1;
+# }
+#
+# a = s.data;
+# }
+#
+# return a;
+# }
+#
+# void main()
+# {
+# // An empty function does nothing.
+# func0(arr[_int_1]);
+#
+# // Always true.
+# if(func1() == _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: 263
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %74 %151
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %7 "S"
+ OpMemberName %7 0 "data"
+ OpName %20 "arr"
+ OpName %46 "buf1"
+ OpMemberName %46 0 "_GLF_uniform_int_values"
+ OpName %48 ""
+ OpName %74 "gl_FragCoord"
+ OpName %81 "buf0"
+ OpMemberName %81 0 "_GLF_uniform_float_values"
+ OpName %83 ""
+ OpName %92 "buf_push"
+ OpMemberName %92 0 "injectionSwitch"
+ OpName %94 ""
+ OpName %151 "_GLF_color"
+ OpDecorate %45 ArrayStride 16
+ OpMemberDecorate %46 0 Offset 0
+ OpDecorate %46 Block
+ OpDecorate %48 DescriptorSet 0
+ OpDecorate %48 Binding 1
+ OpDecorate %74 BuiltIn FragCoord
+ OpDecorate %80 ArrayStride 16
+ OpMemberDecorate %81 0 Offset 0
+ OpDecorate %81 Block
+ OpDecorate %83 DescriptorSet 0
+ OpDecorate %83 Binding 0
+ OpMemberDecorate %92 0 Offset 0
+ OpDecorate %92 Block
+ OpDecorate %151 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeInt 32 1
+ %7 = OpTypeStruct %6
+ %8 = OpTypePointer Function %7
+ %16 = OpTypeInt 32 0
+ %17 = OpConstant %16 10
+ %18 = OpTypeArray %7 %17
+ %21 = OpConstant %6 1
+ %22 = OpConstantComposite %7 %21
+ %23 = OpConstant %6 2
+ %24 = OpConstantComposite %7 %23
+ %25 = OpConstant %6 3
+ %26 = OpConstantComposite %7 %25
+ %27 = OpConstant %6 4
+ %28 = OpConstantComposite %7 %27
+ %29 = OpConstant %6 5
+ %30 = OpConstantComposite %7 %29
+ %31 = OpConstant %6 6
+ %32 = OpConstantComposite %7 %31
+ %33 = OpConstant %6 7
+ %34 = OpConstantComposite %7 %33
+ %35 = OpConstant %6 8
+ %36 = OpConstantComposite %7 %35
+ %37 = OpConstant %6 9
+ %38 = OpConstantComposite %7 %37
+ %39 = OpConstant %6 10
+ %40 = OpConstantComposite %7 %39
+ %41 = OpConstantComposite %18 %22 %24 %26 %28 %30 %32 %34 %36 %38 %40
+ %44 = OpConstant %16 4
+ %45 = OpTypeArray %6 %44
+ %46 = OpTypeStruct %45
+ %47 = OpTypePointer Uniform %46
+ %48 = OpVariable %47 Uniform
+ %49 = OpConstant %6 0
+ %50 = OpTypePointer Uniform %6
+ %64 = OpTypeBool
+ %71 = OpTypeFloat 32
+ %72 = OpTypeVector %71 4
+ %73 = OpTypePointer Input %72
+ %74 = OpVariable %73 Input
+ %75 = OpConstant %16 0
+ %76 = OpTypePointer Input %71
+ %79 = OpConstant %16 1
+ %80 = OpTypeArray %71 %79
+ %81 = OpTypeStruct %80
+ %82 = OpTypePointer Uniform %81
+ %83 = OpVariable %82 Uniform
+ %84 = OpTypePointer Uniform %71
+ %91 = OpTypeVector %71 2
+ %92 = OpTypeStruct %91
+ %93 = OpTypePointer PushConstant %92
+ %94 = OpVariable %93 PushConstant
+ %95 = OpTypePointer PushConstant %71
+ %111 = OpConstant %6 -1
+ %150 = OpTypePointer Output %72
+ %151 = OpVariable %150 Output
+ %174 = OpConstantFalse %64
+ %177 = OpConstantTrue %64
+ %249 = OpTypePointer Function %18
+ %260 = OpUndef %6
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %20 = OpVariable %249 Function
+ OpStore %20 %41
+ %136 = OpAccessChain %50 %48 %49 %25
+ %137 = OpLoad %6 %136
+ %139 = OpAccessChain %8 %20 %137
+ %140 = OpLoad %7 %139
+ OpStore %139 %140
+ OpSelectionMerge %247 None
+ OpSwitch %75 %188
+ %188 = OpLabel
+ %189 = OpAccessChain %50 %48 %49 %21
+ %190 = OpLoad %6 %189
+ OpBranch %193
+ %193 = OpLabel
+ %253 = OpPhi %6 %190 %188 %262 %240
+ %252 = OpPhi %6 %190 %188 %242 %240
+ %196 = OpAccessChain %50 %48 %49 %49
+ %197 = OpLoad %6 %196
+ %198 = OpSLessThan %64 %252 %197
+ OpLoopMerge %243 %240 None
+ OpBranchConditional %198 %199 %243
+ %199 = OpLabel
+ %201 = OpAccessChain %8 %20 %253
+ %202 = OpLoad %7 %201
+ %251 = OpCompositeExtract %6 %202 0
+ %203 = OpAccessChain %76 %74 %75
+ %204 = OpLoad %71 %203
+ %205 = OpAccessChain %84 %83 %49 %49
+ %206 = OpLoad %71 %205
+ %207 = OpFOrdLessThan %64 %204 %206
+ OpSelectionMerge %209 None
+ OpBranchConditional %207 %208 %209
+ %208 = OpLabel
+ OpBranch %240
+ %209 = OpLabel
+ %210 = OpAccessChain %95 %94 %49 %75
+ %211 = OpLoad %71 %210
+ %212 = OpAccessChain %95 %94 %49 %79
+ %213 = OpLoad %71 %212
+ %214 = OpFOrdGreaterThan %64 %211 %213
+ OpSelectionMerge %216 None
+ OpBranchConditional %214 %215 %216
+ %215 = OpLabel
+ OpBranch %240
+ %216 = OpLabel
+ %219 = OpAccessChain %50 %48 %49 %23
+ %220 = OpLoad %6 %219
+ %221 = OpIEqual %64 %251 %220
+ OpSelectionMerge %223 None
+ OpBranchConditional %221 %222 %223
+ %222 = OpLabel
+ OpBranch %243
+ %223 = OpLabel
+ OpSelectionMerge %230 None
+ OpBranchConditional %214 %229 %230
+ %229 = OpLabel
+ OpBranch %243
+ %230 = OpLabel
+ OpSelectionMerge %237 None
+ OpBranchConditional %207 %236 %237
+ %236 = OpLabel
+ OpBranch %243
+ %237 = OpLabel
+ OpBranch %240
+ %240 = OpLabel
+ %262 = OpPhi %6 %253 %208 %253 %215 %251 %237
+ %242 = OpIAdd %6 %252 %21
+ OpBranch %193
+ %243 = OpLabel
+ %258 = OpPhi %6 %260 %193 %111 %222 %260 %229 %111 %236
+ %254 = OpPhi %64 %174 %193 %177 %222 %174 %229 %177 %236
+ OpSelectionMerge %245 None
+ OpBranchConditional %254 %247 %245
+ %245 = OpLabel
+ OpBranch %247
+ %247 = OpLabel
+ %257 = OpPhi %6 %258 %243 %253 %245
+ %147 = OpIEqual %64 %257 %197
+ OpSelectionMerge %149 None
+ OpBranchConditional %147 %148 %165
+ %148 = OpLabel
+ %154 = OpConvertSToF %71 %137
+ %157 = OpConvertSToF %71 %190
+ %164 = OpCompositeConstruct %72 %154 %157 %157 %154
+ OpStore %151 %164
+ OpBranch %149
+ %165 = OpLabel
+ %168 = OpConvertSToF %71 %190
+ %169 = OpCompositeConstruct %72 %168 %168 %168 %168
+ OpStore %151 %169
+ OpBranch %149
+ %149 = 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
+ 5 0 11 1
+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 push_constant
+ 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]
+#
+# precision highp int;
+# precision highp float;
+#
+# // Contents of _GLF_uniform_int_values: [1, 0]
+# layout(set = 0, binding = 0) uniform buf0
+# {
+# int _GLF_uniform_int_values[2];
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# int func()
+# {
+# int a = 1;
+# return (1 + a) - 1;
+# }
+#
+# void main()
+# {
+# // Always true.
+# if(func() == 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: 53
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %26
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %8 "func("
+ OpName %11 "a"
+ OpName %26 "_GLF_color"
+ OpName %30 "buf0"
+ OpMemberName %30 0 "_GLF_uniform_int_values"
+ OpName %32 ""
+ OpDecorate %26 Location 0
+ OpDecorate %29 ArrayStride 16
+ OpMemberDecorate %30 0 Offset 0
+ OpDecorate %30 Block
+ OpDecorate %32 DescriptorSet 0
+ OpDecorate %32 Binding 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeInt 32 1
+ %7 = OpTypeFunction %6
+ %10 = OpTypePointer Function %6
+ %12 = OpConstant %6 1
+ %19 = OpTypeBool
+ %23 = OpTypeFloat 32
+ %24 = OpTypeVector %23 4
+ %25 = OpTypePointer Output %24
+ %26 = OpVariable %25 Output
+ %27 = OpTypeInt 32 0
+ %28 = OpConstant %27 2
+ %29 = OpTypeArray %6 %28
+ %30 = OpTypeStruct %29
+ %31 = OpTypePointer Uniform %30
+ %32 = OpVariable %31 Uniform
+ %33 = OpConstant %6 0
+ %34 = OpTypePointer Uniform %6
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %18 = OpFunctionCall %6 %8
+ %20 = OpIEqual %19 %18 %12
+ OpSelectionMerge %22 None
+ OpBranchConditional %20 %21 %48
+ %21 = OpLabel
+ %35 = OpAccessChain %34 %32 %33 %33
+ %36 = OpLoad %6 %35
+ %37 = OpConvertSToF %23 %36
+ %38 = OpAccessChain %34 %32 %33 %12
+ %39 = OpLoad %6 %38
+ %40 = OpConvertSToF %23 %39
+ %41 = OpAccessChain %34 %32 %33 %12
+ %42 = OpLoad %6 %41
+ %43 = OpConvertSToF %23 %42
+ %44 = OpAccessChain %34 %32 %33 %33
+ %45 = OpLoad %6 %44
+ %46 = OpConvertSToF %23 %45
+ %47 = OpCompositeConstruct %24 %37 %40 %43 %46
+ OpStore %26 %47
+ OpBranch %22
+ %48 = OpLabel
+ %49 = OpAccessChain %34 %32 %33 %12
+ %50 = OpLoad %6 %49
+ %51 = OpConvertSToF %23 %50
+ %52 = OpCompositeConstruct %24 %51 %51 %51 %51
+ OpStore %26 %52
+ OpBranch %22
+ %22 = OpLabel
+ OpReturn
+ OpFunctionEnd
+ %8 = OpFunction %6 None %7
+ %9 = OpLabel
+ %11 = OpVariable %10 Function
+ OpStore %11 %12
+ %13 = OpLoad %6 %11
+ %14 = OpIAdd %6 %12 %13
+ %15 = OpISub %6 %14 %12
+ OpReturnValue %15
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# _GLF_uniform_int_values
+BUFFER variant__GLF_uniform_int_values DATA_TYPE int32[] 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__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_2 _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: [2, 1, 0]
+# layout(set = 0, binding = 0) uniform buf0
+# {
+# int _GLF_uniform_int_values[3];
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# int arr[10] = int[10](1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
+#
+# void main()
+# {
+# ivec2 v = ivec2(_int_1);
+# int a = 1;
+#
+# // Always true.
+# if(arr[_int_1] == _int_1)
+# {
+# a++;
+# }
+#
+# // Always true.
+# if(57678 % a == _int_0)
+# {
+# // arr[2] becomes 2.
+# arr[v.x + v.y] = _int_2;
+# }
+#
+# // Always true.
+# if(arr[_int_2] == _int_2)
+# {
+# _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: 92
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %73
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %11 "arr"
+ OpName %16 "v"
+ OpName %19 "buf0"
+ OpMemberName %19 0 "_GLF_uniform_int_values"
+ OpName %21 ""
+ OpName %28 "a"
+ OpName %73 "_GLF_color"
+ OpDecorate %18 ArrayStride 16
+ OpMemberDecorate %19 0 Offset 0
+ OpDecorate %19 Block
+ OpDecorate %21 DescriptorSet 0
+ OpDecorate %21 Binding 0
+ OpDecorate %73 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeInt 32 1
+ %7 = OpTypeInt 32 0
+ %8 = OpConstant %7 10
+ %9 = OpTypeArray %6 %8
+ %10 = OpTypePointer Private %9
+ %11 = OpVariable %10 Private
+ %12 = OpConstant %6 1
+ %13 = OpConstantComposite %9 %12 %12 %12 %12 %12 %12 %12 %12 %12 %12
+ %14 = OpTypeVector %6 2
+ %15 = OpTypePointer Function %14
+ %17 = OpConstant %7 3
+ %18 = OpTypeArray %6 %17
+ %19 = OpTypeStruct %18
+ %20 = OpTypePointer Uniform %19
+ %21 = OpVariable %20 Uniform
+ %22 = OpConstant %6 0
+ %23 = OpTypePointer Uniform %6
+ %27 = OpTypePointer Function %6
+ %31 = OpTypePointer Private %6
+ %36 = OpTypeBool
+ %42 = OpConstant %6 57678
+ %45 = OpConstant %6 2
+ %51 = OpConstant %7 0
+ %54 = OpConstant %7 1
+ %70 = OpTypeFloat 32
+ %71 = OpTypeVector %70 4
+ %72 = OpTypePointer Output %71
+ %73 = OpVariable %72 Output
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %16 = OpVariable %15 Function
+ %28 = OpVariable %27 Function
+ OpStore %11 %13
+ %24 = OpAccessChain %23 %21 %22 %12
+ %25 = OpLoad %6 %24
+ %26 = OpCompositeConstruct %14 %25 %25
+ OpStore %16 %26
+ OpStore %28 %12
+ %29 = OpAccessChain %23 %21 %22 %12
+ %30 = OpLoad %6 %29
+ %32 = OpAccessChain %31 %11 %30
+ %33 = OpLoad %6 %32
+ %34 = OpAccessChain %23 %21 %22 %12
+ %35 = OpLoad %6 %34
+ %37 = OpIEqual %36 %33 %35
+ OpSelectionMerge %39 None
+ OpBranchConditional %37 %38 %39
+ %38 = OpLabel
+ %40 = OpLoad %6 %28
+ %41 = OpIAdd %6 %40 %12
+ OpStore %28 %41
+ OpBranch %39
+ %39 = OpLabel
+ %43 = OpLoad %6 %28
+ %44 = OpSMod %6 %42 %43
+ %46 = OpAccessChain %23 %21 %22 %45
+ %47 = OpLoad %6 %46
+ %48 = OpIEqual %36 %44 %47
+ OpSelectionMerge %50 None
+ OpBranchConditional %48 %49 %50
+ %49 = OpLabel
+ %52 = OpAccessChain %27 %16 %51
+ %53 = OpLoad %6 %52
+ %55 = OpAccessChain %27 %16 %54
+ %56 = OpLoad %6 %55
+ %57 = OpIAdd %6 %53 %56
+ %58 = OpAccessChain %23 %21 %22 %22
+ %59 = OpLoad %6 %58
+ %60 = OpAccessChain %31 %11 %57
+ OpStore %60 %59
+ OpBranch %50
+ %50 = OpLabel
+ %61 = OpAccessChain %23 %21 %22 %22
+ %62 = OpLoad %6 %61
+ %63 = OpAccessChain %31 %11 %62
+ %64 = OpLoad %6 %63
+ %65 = OpAccessChain %23 %21 %22 %22
+ %66 = OpLoad %6 %65
+ %67 = OpIEqual %36 %64 %66
+ OpSelectionMerge %69 None
+ OpBranchConditional %67 %68 %87
+ %68 = OpLabel
+ %74 = OpAccessChain %23 %21 %22 %12
+ %75 = OpLoad %6 %74
+ %76 = OpConvertSToF %70 %75
+ %77 = OpAccessChain %23 %21 %22 %45
+ %78 = OpLoad %6 %77
+ %79 = OpConvertSToF %70 %78
+ %80 = OpAccessChain %23 %21 %22 %45
+ %81 = OpLoad %6 %80
+ %82 = OpConvertSToF %70 %81
+ %83 = OpAccessChain %23 %21 %22 %12
+ %84 = OpLoad %6 %83
+ %85 = OpConvertSToF %70 %84
+ %86 = OpCompositeConstruct %71 %76 %79 %82 %85
+ OpStore %73 %86
+ OpBranch %69
+ %87 = OpLabel
+ %88 = OpAccessChain %23 %21 %22 %45
+ %89 = OpLoad %6 %88
+ %90 = OpConvertSToF %70 %89
+ %91 = OpCompositeConstruct %71 %90 %90 %90 %90
+ OpStore %73 %91
+ OpBranch %69
+ %69 = OpLabel
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# _GLF_uniform_int_values
+BUFFER variant__GLF_uniform_int_values DATA_TYPE int32[] STD140 DATA
+ 2 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__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]
+# #define _float_1_0 _GLF_uniform_float_values[1]
+#
+# precision highp float;
+# precision highp int;
+#
+# // Contents of _GLF_uniform_int_values: [1, 0]
+# layout(set = 0, binding = 0) uniform buf0
+# {
+# int _GLF_uniform_int_values[2];
+# };
+#
+# // Contents of _GLF_uniform_float_values: [0.0, 1.0]
+# layout(set = 0, binding = 1) uniform buf1
+# {
+# float _GLF_uniform_float_values[2];
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void main()
+# {
+# int a;
+# float f = _float_0_0;
+#
+# // Always false.
+# if(gl_FragCoord.x < _float_0_0)
+# {
+# // a is undefined, but this is never executed.
+# f = ldexp(_float_1_0, (a / int(gl_FragCoord.x)));
+# }
+#
+# // Always true.
+# if(f == _float_0_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: 75
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %22 %51
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %8 "f"
+ OpName %12 "buf1"
+ OpMemberName %12 0 "_GLF_uniform_float_values"
+ OpName %14 ""
+ OpName %22 "gl_FragCoord"
+ OpName %37 "a"
+ OpName %51 "_GLF_color"
+ OpName %53 "buf0"
+ OpMemberName %53 0 "_GLF_uniform_int_values"
+ OpName %55 ""
+ OpDecorate %11 ArrayStride 16
+ OpMemberDecorate %12 0 Offset 0
+ OpDecorate %12 Block
+ OpDecorate %14 DescriptorSet 0
+ OpDecorate %14 Binding 1
+ OpDecorate %22 BuiltIn FragCoord
+ OpDecorate %51 Location 0
+ OpDecorate %52 ArrayStride 16
+ OpMemberDecorate %53 0 Offset 0
+ OpDecorate %53 Block
+ OpDecorate %55 DescriptorSet 0
+ OpDecorate %55 Binding 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeFloat 32
+ %7 = OpTypePointer Function %6
+ %9 = OpTypeInt 32 0
+ %10 = OpConstant %9 2
+ %11 = OpTypeArray %6 %10
+ %12 = OpTypeStruct %11
+ %13 = OpTypePointer Uniform %12
+ %14 = OpVariable %13 Uniform
+ %15 = OpTypeInt 32 1
+ %16 = OpConstant %15 0
+ %17 = OpTypePointer Uniform %6
+ %20 = OpTypeVector %6 4
+ %21 = OpTypePointer Input %20
+ %22 = OpVariable %21 Input
+ %23 = OpConstant %9 0
+ %24 = OpTypePointer Input %6
+ %29 = OpTypeBool
+ %33 = OpConstant %15 1
+ %36 = OpTypePointer Function %15
+ %50 = OpTypePointer Output %20
+ %51 = OpVariable %50 Output
+ %52 = OpTypeArray %15 %10
+ %53 = OpTypeStruct %52
+ %54 = OpTypePointer Uniform %53
+ %55 = OpVariable %54 Uniform
+ %56 = OpTypePointer Uniform %15
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %8 = OpVariable %7 Function
+ %37 = OpVariable %36 Function
+ %18 = OpAccessChain %17 %14 %16 %16
+ %19 = OpLoad %6 %18
+ OpStore %8 %19
+ %25 = OpAccessChain %24 %22 %23
+ %26 = OpLoad %6 %25
+ %27 = OpAccessChain %17 %14 %16 %16
+ %28 = OpLoad %6 %27
+ %30 = OpFOrdLessThan %29 %26 %28
+ OpSelectionMerge %32 None
+ OpBranchConditional %30 %31 %32
+ %31 = OpLabel
+ %34 = OpAccessChain %17 %14 %16 %33
+ %35 = OpLoad %6 %34
+ %38 = OpLoad %15 %37
+ %39 = OpAccessChain %24 %22 %23
+ %40 = OpLoad %6 %39
+ %41 = OpConvertFToS %15 %40
+ %42 = OpSDiv %15 %38 %41
+ %43 = OpExtInst %6 %1 Ldexp %35 %42
+ OpStore %8 %43
+ OpBranch %32
+ %32 = OpLabel
+ %44 = OpLoad %6 %8
+ %45 = OpAccessChain %17 %14 %16 %16
+ %46 = OpLoad %6 %45
+ %47 = OpFOrdEqual %29 %44 %46
+ OpSelectionMerge %49 None
+ OpBranchConditional %47 %48 %70
+ %48 = OpLabel
+ %57 = OpAccessChain %56 %55 %16 %16
+ %58 = OpLoad %15 %57
+ %59 = OpConvertSToF %6 %58
+ %60 = OpAccessChain %56 %55 %16 %33
+ %61 = OpLoad %15 %60
+ %62 = OpConvertSToF %6 %61
+ %63 = OpAccessChain %56 %55 %16 %33
+ %64 = OpLoad %15 %63
+ %65 = OpConvertSToF %6 %64
+ %66 = OpAccessChain %56 %55 %16 %16
+ %67 = OpLoad %15 %66
+ %68 = OpConvertSToF %6 %67
+ %69 = OpCompositeConstruct %20 %59 %62 %65 %68
+ OpStore %51 %69
+ OpBranch %49
+ %70 = OpLabel
+ %71 = OpAccessChain %56 %55 %16 %33
+ %72 = OpLoad %15 %71
+ %73 = OpConvertSToF %6 %72
+ %74 = OpCompositeConstruct %20 %73 %73 %73 %73
+ OpStore %51 %74
+ OpBranch %49
+ %49 = OpLabel
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# _GLF_uniform_float_values
+BUFFER variant__GLF_uniform_float_values DATA_TYPE 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
+
+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_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.
+
+# Optimized using spirv-opt with the following arguments:
+# '--copy-propagate-arrays'
+# '--eliminate-dead-inserts'
+# '--convert-local-access-chains'
+# '--private-to-local'
+# '--redundancy-elimination'
+# '--eliminate-local-multi-store'
+# '--eliminate-local-single-block'
+# '--eliminate-dead-code-aggressive'
+# '--copy-propagate-arrays'
+# '--eliminate-dead-inserts'
+# '--redundancy-elimination'
+# '--eliminate-local-single-block'
+# '--eliminate-local-single-store'
+# '--eliminate-local-single-store'
+# '--eliminate-dead-code-aggressive'
+# '--inline-entry-points-exhaustive'
+# '--combine-access-chains'
+# '--eliminate-dead-branches'
+# '--merge-return'
+# '--eliminate-local-single-block'
+# '--eliminate-dead-branches'
+# '--reduce-load-size'
+# '--eliminate-dead-inserts'
+# '--copy-propagate-arrays'
+# '--convert-local-access-chains'
+# '--vector-dce'
+# '--redundancy-elimination'
+# '--eliminate-local-multi-store'
+# '--redundancy-elimination'
+# '--eliminate-dead-inserts'
+# '--eliminate-dead-code-aggressive'
+# spirv-opt commit hash: a0370efd589be33d5d9a85cfde2f85841b3755af
+
+
+
+SHADER vertex texgen_vert PASSTHROUGH
+
+SHADER fragment texgen_frag GLSL
+#version 430
+precision highp float;
+
+layout(location = 0) out vec4 _GLF_color;
+
+void main()
+{
+ _GLF_color = vec4(
+ gl_FragCoord.x * (1.0 / 256.0),
+ (int(gl_FragCoord.x) ^ int(gl_FragCoord.y)) * (1.0 / 256.0),
+ gl_FragCoord.y * (1.0 / 256.0),
+ 1.0);
+}
+END
+BUFFER default_texture FORMAT B8G8R8A8_UNORM
+
+PIPELINE graphics texgen_pipeline
+ ATTACH texgen_vert
+ ATTACH texgen_frag
+ FRAMEBUFFER_SIZE 256 256
+ BIND BUFFER default_texture AS color LOCATION 0
+END
+
+CLEAR_COLOR texgen_pipeline 0 0 0 255
+CLEAR texgen_pipeline
+RUN texgen_pipeline DRAW_RECT POS 0 0 SIZE 256 256
+
+SHADER vertex variant_vertex_shader PASSTHROUGH
+
+# variant_fragment_shader is derived from the following GLSL:
+# #version 320 es
+#
+# precision highp float;
+# precision highp int;
+#
+# const int _GLF_global_loop_bound = 10;
+# int _GLF_global_loop_count = 0;
+#
+# struct S
+# {
+# int data;
+# };
+#
+# layout(set = 0, binding = 0) uniform sampler2D tex;
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void main()
+# {
+# int a = 1;
+# int b = 1;
+# vec4 v = vec4(1.0);
+# S s = S(1);
+#
+# // Iterated once.
+# while(v.x + 1.0 > 0.0 && s.data <= 1 && _GLF_global_loop_count < _GLF_global_loop_bound)
+# {
+# _GLF_global_loop_count++;
+#
+# // Always false.
+# if(b++ > 3)
+# {
+# break;
+# }
+#
+# // The sampled value doesn't matter because the loop will exit in any case.
+# v = texture(tex, vec2(1.0));
+#
+# // This will cause the loop to exit.
+# s.data++;
+# }
+#
+# // Always true.
+# if (s.data == 2)
+# _GLF_color = vec4(float(a), 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: 96
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %75
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %20 "S"
+ OpMemberName %20 0 "data"
+ OpName %60 "tex"
+ OpName %75 "_GLF_color"
+ OpDecorate %60 RelaxedPrecision
+ OpDecorate %60 DescriptorSet 0
+ OpDecorate %60 Binding 0
+ OpDecorate %61 RelaxedPrecision
+ OpDecorate %64 RelaxedPrecision
+ OpDecorate %75 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeInt 32 1
+ %9 = OpConstant %6 0
+ %12 = OpConstant %6 1
+ %14 = OpTypeFloat 32
+ %15 = OpTypeVector %14 4
+ %18 = OpConstant %14 1
+ %19 = OpConstantComposite %15 %18 %18 %18 %18
+ %20 = OpTypeStruct %6
+ %23 = OpConstantComposite %20 %12
+ %29 = OpTypeBool
+ %36 = OpConstant %14 0
+ %45 = OpConstant %6 10
+ %52 = OpConstant %6 3
+ %57 = OpTypeImage %14 2D 0 0 0 1 Unknown
+ %58 = OpTypeSampledImage %57
+ %59 = OpTypePointer UniformConstant %58
+ %60 = OpVariable %59 UniformConstant
+ %62 = OpTypeVector %14 2
+ %63 = OpConstantComposite %62 %18 %18
+ %70 = OpConstant %6 2
+ %74 = OpTypePointer Output %15
+ %75 = OpVariable %74 Output
+ %80 = OpConstantComposite %15 %36 %36 %36 %36
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ OpBranch %24
+ %24 = OpLabel
+ %95 = OpPhi %20 %23 %5 %85 %27
+ %94 = OpPhi %15 %19 %5 %64 %27
+ %90 = OpPhi %6 %12 %5 %51 %27
+ %88 = OpPhi %6 %9 %5 %49 %27
+ %93 = OpPhi %6 %12 %5 %93 %27
+ OpLoopMerge %26 %27 None
+ OpBranch %28
+ %28 = OpLabel
+ %34 = OpCompositeExtract %14 %94 0
+ %35 = OpFAdd %14 %34 %18
+ %37 = OpFOrdGreaterThan %29 %35 %36
+ OpSelectionMerge %39 None
+ OpBranchConditional %37 %38 %39
+ %38 = OpLabel
+ %41 = OpCompositeExtract %6 %95 0
+ %42 = OpSLessThanEqual %29 %41 %12
+ OpBranch %39
+ %39 = OpLabel
+ %43 = OpPhi %29 %37 %28 %42 %38
+ %46 = OpSLessThan %29 %88 %45
+ %47 = OpLogicalAnd %29 %43 %46
+ OpBranchConditional %47 %25 %26
+ %25 = OpLabel
+ %49 = OpIAdd %6 %88 %12
+ %51 = OpIAdd %6 %90 %12
+ %53 = OpSGreaterThan %29 %90 %52
+ OpSelectionMerge %55 None
+ OpBranchConditional %53 %54 %55
+ %54 = OpLabel
+ OpBranch %26
+ %55 = OpLabel
+ %61 = OpLoad %58 %60
+ %64 = OpImageSampleImplicitLod %15 %61 %63
+ %66 = OpCompositeExtract %6 %95 0
+ %67 = OpIAdd %6 %66 %12
+ %85 = OpCompositeInsert %20 %67 %95 0
+ OpBranch %27
+ %27 = OpLabel
+ OpBranch %24
+ %26 = OpLabel
+ %69 = OpCompositeExtract %6 %95 0
+ %71 = OpIEqual %29 %69 %70
+ OpSelectionMerge %73 None
+ OpBranchConditional %71 %72 %79
+ %72 = OpLabel
+ %77 = OpConvertSToF %14 %93
+ %78 = OpCompositeConstruct %15 %77 %36 %36 %18
+ OpStore %75 %78
+ OpBranch %73
+ %79 = OpLabel
+ OpStore %75 %80
+ OpBranch %73
+ %73 = OpLabel
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# GLF_live1tex
+SAMPLER variant_GLF_live1tex
+
+
+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 default_texture AS combined_image_sampler SAMPLER variant_GLF_live1tex 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 _float_0_0 _GLF_uniform_float_values[0]
+# #define _float_1_0 _GLF_uniform_float_values[1]
+#
+# precision highp int;
+# precision highp float;
+#
+# // Contents of _GLF_uniform_int_values: 1
+# layout(set = 0, binding = 0) uniform buf0
+# {
+# int _GLF_uniform_int_values[1];
+# };
+#
+# // Contents of _GLF_uniform_float_values: [0.0, 1.0]
+# layout(set = 0, binding = 1) uniform buf1
+# {
+# float _GLF_uniform_float_values[2];
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void main()
+# {
+# vec4 v;
+# // _GLF_color becomes (1, 1, 1, 1). Vector v is uninitialized, but none of it's values are selected.
+# _GLF_color = mix(vec4(1.0, v[_int_1], 1.0, 1.0), vec4(1), bvec4(true, true, gl_FragCoord.y > _float_0_0, true));
+# // Adjust the color to (1, 0, 0, 1).
+# _GLF_color.yz -= _float_1_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: 58
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %9 %32
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %9 "_GLF_color"
+ OpName %12 "v"
+ OpName %17 "buf0"
+ OpMemberName %17 0 "_GLF_uniform_int_values"
+ OpName %19 ""
+ OpName %32 "gl_FragCoord"
+ OpName %38 "buf1"
+ OpMemberName %38 0 "_GLF_uniform_float_values"
+ OpName %40 ""
+ OpDecorate %9 Location 0
+ OpDecorate %16 ArrayStride 16
+ OpMemberDecorate %17 0 Offset 0
+ OpDecorate %17 Block
+ OpDecorate %19 DescriptorSet 0
+ OpDecorate %19 Binding 0
+ OpDecorate %32 BuiltIn FragCoord
+ OpDecorate %37 ArrayStride 16
+ OpMemberDecorate %38 0 Offset 0
+ OpDecorate %38 Block
+ OpDecorate %40 DescriptorSet 0
+ OpDecorate %40 Binding 1
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeFloat 32
+ %7 = OpTypeVector %6 4
+ %8 = OpTypePointer Output %7
+ %9 = OpVariable %8 Output
+ %10 = OpConstant %6 1
+ %11 = OpTypePointer Function %7
+ %13 = OpTypeInt 32 1
+ %14 = OpTypeInt 32 0
+ %15 = OpConstant %14 1
+ %16 = OpTypeArray %13 %15
+ %17 = OpTypeStruct %16
+ %18 = OpTypePointer Uniform %17
+ %19 = OpVariable %18 Uniform
+ %20 = OpConstant %13 0
+ %21 = OpTypePointer Uniform %13
+ %24 = OpTypePointer Function %6
+ %28 = OpConstantComposite %7 %10 %10 %10 %10
+ %29 = OpTypeBool
+ %30 = OpConstantTrue %29
+ %31 = OpTypePointer Input %7
+ %32 = OpVariable %31 Input
+ %33 = OpTypePointer Input %6
+ %36 = OpConstant %14 2
+ %37 = OpTypeArray %6 %36
+ %38 = OpTypeStruct %37
+ %39 = OpTypePointer Uniform %38
+ %40 = OpVariable %39 Uniform
+ %41 = OpTypePointer Uniform %6
+ %45 = OpTypeVector %29 4
+ %48 = OpConstant %13 1
+ %51 = OpTypeVector %6 2
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %12 = OpVariable %11 Function
+ %22 = OpAccessChain %21 %19 %20 %20
+ %23 = OpLoad %13 %22
+ %25 = OpAccessChain %24 %12 %23
+ %26 = OpLoad %6 %25
+ %27 = OpCompositeConstruct %7 %10 %26 %10 %10
+ %34 = OpAccessChain %33 %32 %15
+ %35 = OpLoad %6 %34
+ %42 = OpAccessChain %41 %40 %20 %20
+ %43 = OpLoad %6 %42
+ %44 = OpFOrdGreaterThan %29 %35 %43
+ %46 = OpCompositeConstruct %45 %30 %30 %44 %30
+ %47 = OpSelect %7 %46 %28 %27
+ OpStore %9 %47
+ %49 = OpAccessChain %41 %40 %20 %48
+ %50 = OpLoad %6 %49
+ %52 = OpLoad %7 %9
+ %53 = OpVectorShuffle %51 %52 %52 1 2
+ %54 = OpCompositeConstruct %51 %50 %50
+ %55 = OpFSub %51 %53 %54
+ %56 = OpLoad %7 %9
+ %57 = OpVectorShuffle %7 %56 %55 0 4 5 3
+ OpStore %9 %57
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# _GLF_uniform_float_values
+BUFFER variant__GLF_uniform_float_values DATA_TYPE float[] STD140 DATA
+ 0.0 1.0
+END
+# _GLF_uniform_int_values
+BUFFER variant__GLF_uniform_int_values 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__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_2 _GLF_uniform_int_values[0]
+# #define _int_1 _GLF_uniform_int_values[1]
+# #define _int_0 _GLF_uniform_int_values[2]
+# #define _int_6 _GLF_uniform_int_values[3]
+#
+# precision highp float;
+# precision highp int;
+#
+# // Contents of _GLF_uniform_int_values: [2, 1, 0, 6]
+# layout(set = 0, binding = 0) uniform buf0
+# {
+# int _GLF_uniform_int_values[4];
+# };
+#
+# int arr0[10] = int[10](0, 0, 0, 0, 0, 0, 0, 0, 0, 0), arr1[10] = int[10](1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void func(int x, int y)
+# {
+# // Sets arr1[1..5] = arr0[1] = 0.
+# for(int i = _int_1; i < _int_6; i++)
+# {
+# arr1[i] = arr0[_int_1];
+# }
+#
+# int a = 0;
+#
+# // Sets arr0[x..min(x+8, 9)] = arr1[1] = 0.
+# for(int i = x; i < y; i++)
+# {
+# if(a++ > 6)
+# {
+# break;
+# }
+#
+# arr0[i] = arr1[_int_1];
+# }
+# }
+#
+# void main()
+# {
+# int a = 1;
+#
+# // Iterates i = 1, 2, 2, 2, 2.
+# for(int i = 1; a < 6; i = _int_2, a++)
+# {
+# // Iterates j = 1..9 during the first round, and
+# // j = 1, 3, 5, 7, 9 for the other rounds.
+# for(int j = 1; j < 10; j += i)
+# {
+# func(j, 10);
+# }
+# }
+#
+# // Sets _GLF_color to (1, 0, 0, 1).
+# _GLF_color = vec4(arr1[_int_0], arr0[_int_0], arr1[_int_1], arr1[_int_6]);
+# }
+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" %110
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %11 "func(i1;i1;"
+ OpName %9 "x"
+ OpName %10 "y"
+ OpName %17 "arr0"
+ OpName %20 "arr1"
+ OpName %23 "i"
+ OpName %26 "buf0"
+ OpMemberName %26 0 "_GLF_uniform_int_values"
+ OpName %28 ""
+ OpName %52 "a"
+ OpName %53 "i"
+ OpName %78 "a"
+ OpName %79 "i"
+ OpName %87 "j"
+ OpName %96 "param"
+ OpName %98 "param"
+ OpName %110 "_GLF_color"
+ OpDecorate %25 ArrayStride 16
+ OpMemberDecorate %26 0 Offset 0
+ OpDecorate %26 Block
+ OpDecorate %28 DescriptorSet 0
+ OpDecorate %28 Binding 0
+ OpDecorate %110 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeInt 32 1
+ %7 = OpTypePointer Function %6
+ %8 = OpTypeFunction %2 %7 %7
+ %13 = OpTypeInt 32 0
+ %14 = OpConstant %13 10
+ %15 = OpTypeArray %6 %14
+ %16 = OpTypePointer Private %15
+ %17 = OpVariable %16 Private
+ %18 = OpConstant %6 0
+ %19 = OpConstantComposite %15 %18 %18 %18 %18 %18 %18 %18 %18 %18 %18
+ %20 = OpVariable %16 Private
+ %21 = OpConstant %6 1
+ %22 = OpConstantComposite %15 %21 %21 %21 %21 %21 %21 %21 %21 %21 %21
+ %24 = OpConstant %13 4
+ %25 = OpTypeArray %6 %24
+ %26 = OpTypeStruct %25
+ %27 = OpTypePointer Uniform %26
+ %28 = OpVariable %27 Uniform
+ %29 = OpTypePointer Uniform %6
+ %38 = OpConstant %6 3
+ %41 = OpTypeBool
+ %46 = OpTypePointer Private %6
+ %65 = OpConstant %6 6
+ %94 = OpConstant %6 10
+ %107 = OpTypeFloat 32
+ %108 = OpTypeVector %107 4
+ %109 = OpTypePointer Output %108
+ %110 = OpVariable %109 Output
+ %111 = OpConstant %6 2
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %78 = OpVariable %7 Function
+ %79 = OpVariable %7 Function
+ %87 = OpVariable %7 Function
+ %96 = OpVariable %7 Function
+ %98 = OpVariable %7 Function
+ OpStore %17 %19
+ OpStore %20 %22
+ OpStore %78 %21
+ OpStore %79 %21
+ OpBranch %80
+ %80 = OpLabel
+ OpLoopMerge %82 %83 None
+ OpBranch %84
+ %84 = OpLabel
+ %85 = OpLoad %6 %78
+ %86 = OpSLessThan %41 %85 %65
+ OpBranchConditional %86 %81 %82
+ %81 = OpLabel
+ OpStore %87 %21
+ OpBranch %88
+ %88 = OpLabel
+ OpLoopMerge %90 %91 None
+ OpBranch %92
+ %92 = OpLabel
+ %93 = OpLoad %6 %87
+ %95 = OpSLessThan %41 %93 %94
+ OpBranchConditional %95 %89 %90
+ %89 = OpLabel
+ %97 = OpLoad %6 %87
+ OpStore %96 %97
+ OpStore %98 %94
+ %99 = OpFunctionCall %2 %11 %96 %98
+ OpBranch %91
+ %91 = OpLabel
+ %100 = OpLoad %6 %79
+ %101 = OpLoad %6 %87
+ %102 = OpIAdd %6 %101 %100
+ OpStore %87 %102
+ OpBranch %88
+ %90 = OpLabel
+ OpBranch %83
+ %83 = OpLabel
+ %103 = OpAccessChain %29 %28 %18 %18
+ %104 = OpLoad %6 %103
+ OpStore %79 %104
+ %105 = OpLoad %6 %78
+ %106 = OpIAdd %6 %105 %21
+ OpStore %78 %106
+ OpBranch %80
+ %82 = OpLabel
+ %112 = OpAccessChain %29 %28 %18 %111
+ %113 = OpLoad %6 %112
+ %114 = OpAccessChain %46 %20 %113
+ %115 = OpLoad %6 %114
+ %116 = OpConvertSToF %107 %115
+ %117 = OpAccessChain %29 %28 %18 %111
+ %118 = OpLoad %6 %117
+ %119 = OpAccessChain %46 %17 %118
+ %120 = OpLoad %6 %119
+ %121 = OpConvertSToF %107 %120
+ %122 = OpAccessChain %29 %28 %18 %21
+ %123 = OpLoad %6 %122
+ %124 = OpAccessChain %46 %20 %123
+ %125 = OpLoad %6 %124
+ %126 = OpConvertSToF %107 %125
+ %127 = OpAccessChain %29 %28 %18 %38
+ %128 = OpLoad %6 %127
+ %129 = OpAccessChain %46 %20 %128
+ %130 = OpLoad %6 %129
+ %131 = OpConvertSToF %107 %130
+ %132 = OpCompositeConstruct %108 %116 %121 %126 %131
+ OpStore %110 %132
+ OpReturn
+ OpFunctionEnd
+ %11 = OpFunction %2 None %8
+ %9 = OpFunctionParameter %7
+ %10 = OpFunctionParameter %7
+ %12 = OpLabel
+ %23 = OpVariable %7 Function
+ %52 = OpVariable %7 Function
+ %53 = OpVariable %7 Function
+ %30 = OpAccessChain %29 %28 %18 %21
+ %31 = OpLoad %6 %30
+ OpStore %23 %31
+ OpBranch %32
+ %32 = OpLabel
+ OpLoopMerge %34 %35 None
+ OpBranch %36
+ %36 = OpLabel
+ %37 = OpLoad %6 %23
+ %39 = OpAccessChain %29 %28 %18 %38
+ %40 = OpLoad %6 %39
+ %42 = OpSLessThan %41 %37 %40
+ OpBranchConditional %42 %33 %34
+ %33 = OpLabel
+ %43 = OpLoad %6 %23
+ %44 = OpAccessChain %29 %28 %18 %21
+ %45 = OpLoad %6 %44
+ %47 = OpAccessChain %46 %17 %45
+ %48 = OpLoad %6 %47
+ %49 = OpAccessChain %46 %20 %43
+ OpStore %49 %48
+ OpBranch %35
+ %35 = OpLabel
+ %50 = OpLoad %6 %23
+ %51 = OpIAdd %6 %50 %21
+ OpStore %23 %51
+ OpBranch %32
+ %34 = OpLabel
+ OpStore %52 %18
+ %54 = OpLoad %6 %9
+ OpStore %53 %54
+ OpBranch %55
+ %55 = OpLabel
+ OpLoopMerge %57 %58 None
+ OpBranch %59
+ %59 = OpLabel
+ %60 = OpLoad %6 %53
+ %61 = OpLoad %6 %10
+ %62 = OpSLessThan %41 %60 %61
+ OpBranchConditional %62 %56 %57
+ %56 = OpLabel
+ %63 = OpLoad %6 %52
+ %64 = OpIAdd %6 %63 %21
+ OpStore %52 %64
+ %66 = OpSGreaterThan %41 %63 %65
+ OpSelectionMerge %68 None
+ OpBranchConditional %66 %67 %68
+ %67 = OpLabel
+ OpBranch %57
+ %68 = OpLabel
+ %70 = OpLoad %6 %53
+ %71 = OpAccessChain %29 %28 %18 %21
+ %72 = OpLoad %6 %71
+ %73 = OpAccessChain %46 %20 %72
+ %74 = OpLoad %6 %73
+ %75 = OpAccessChain %46 %17 %70
+ OpStore %75 %74
+ OpBranch %58
+ %58 = OpLabel
+ %76 = OpLoad %6 %53
+ %77 = OpIAdd %6 %76 %21
+ OpStore %53 %77
+ OpBranch %55
+ %57 = OpLabel
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# _GLF_uniform_int_values
+BUFFER variant__GLF_uniform_int_values DATA_TYPE int32[] STD140 DATA
+ 2 1 0 6
+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_1 _GLF_uniform_int_values[0]
+# #define _int_0 _GLF_uniform_int_values[1]
+# #define _int_3 _GLF_uniform_int_values[2]
+# #define _int_6 _GLF_uniform_int_values[3]
+#
+# precision highp float;
+# precision highp int;
+#
+# // Contents of _GLF_uniform_int_values: [1, 0, 3, 6]
+# 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;
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void main()
+# {
+# int a = _int_1;
+#
+# // Iterated once.
+# while(a < _int_3)
+# {
+# int b = _int_1;
+#
+# // Iterated until the break.
+# do
+# {
+# _GLF_global_loop_count ++;
+#
+# if(b >= _int_6)
+# {
+# break;
+# }
+# b++;
+#
+# int unused = _int_1;
+# // a / 256 is always zero simplifying the line below to a = b.
+# a = (a / 256 + b);
+# }
+# while(_GLF_global_loop_count < _GLF_global_loop_bound);
+# }
+#
+# // The coverage point is lost if a or _GLF_global_loop_count is checked, so just write the correct color.
+# _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: 80
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %66
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %8 "_GLF_global_loop_count"
+ OpName %11 "a"
+ OpName %15 "buf0"
+ OpMemberName %15 0 "_GLF_uniform_int_values"
+ OpName %17 ""
+ OpName %32 "b"
+ OpName %52 "unused"
+ OpName %66 "_GLF_color"
+ OpDecorate %14 ArrayStride 16
+ OpMemberDecorate %15 0 Offset 0
+ OpDecorate %15 Block
+ OpDecorate %17 DescriptorSet 0
+ OpDecorate %17 Binding 0
+ OpDecorate %66 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 4
+ %14 = OpTypeArray %6 %13
+ %15 = OpTypeStruct %14
+ %16 = OpTypePointer Uniform %15
+ %17 = OpVariable %16 Uniform
+ %18 = OpTypePointer Uniform %6
+ %27 = OpConstant %6 2
+ %30 = OpTypeBool
+ %40 = OpConstant %6 1
+ %43 = OpConstant %6 3
+ %56 = OpConstant %6 256
+ %61 = OpConstant %6 10
+ %63 = OpTypeFloat 32
+ %64 = OpTypeVector %63 4
+ %65 = OpTypePointer Output %64
+ %66 = OpVariable %65 Output
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %11 = OpVariable %10 Function
+ %32 = OpVariable %10 Function
+ %52 = OpVariable %10 Function
+ OpStore %8 %9
+ %19 = OpAccessChain %18 %17 %9 %9
+ %20 = OpLoad %6 %19
+ OpStore %11 %20
+ OpBranch %21
+ %21 = OpLabel
+ OpLoopMerge %23 %24 None
+ OpBranch %25
+ %25 = OpLabel
+ %26 = OpLoad %6 %11
+ %28 = OpAccessChain %18 %17 %9 %27
+ %29 = OpLoad %6 %28
+ %31 = OpSLessThan %30 %26 %29
+ OpBranchConditional %31 %22 %23
+ %22 = OpLabel
+ %33 = OpAccessChain %18 %17 %9 %9
+ %34 = OpLoad %6 %33
+ OpStore %32 %34
+ OpBranch %35
+ %35 = OpLabel
+ OpLoopMerge %37 %38 None
+ OpBranch %36
+ %36 = OpLabel
+ %39 = OpLoad %6 %8
+ %41 = OpIAdd %6 %39 %40
+ OpStore %8 %41
+ %42 = OpLoad %6 %32
+ %44 = OpAccessChain %18 %17 %9 %43
+ %45 = OpLoad %6 %44
+ %46 = OpSGreaterThanEqual %30 %42 %45
+ OpSelectionMerge %48 None
+ OpBranchConditional %46 %47 %48
+ %47 = OpLabel
+ OpBranch %37
+ %48 = OpLabel
+ %50 = OpLoad %6 %32
+ %51 = OpIAdd %6 %50 %40
+ OpStore %32 %51
+ %53 = OpAccessChain %18 %17 %9 %9
+ %54 = OpLoad %6 %53
+ OpStore %52 %54
+ %55 = OpLoad %6 %11
+ %57 = OpSDiv %6 %55 %56
+ %58 = OpLoad %6 %32
+ %59 = OpIAdd %6 %57 %58
+ OpStore %11 %59
+ OpBranch %38
+ %38 = OpLabel
+ %60 = OpLoad %6 %8
+ %62 = OpSLessThan %30 %60 %61
+ OpBranchConditional %62 %35 %37
+ %37 = OpLabel
+ OpBranch %24
+ %24 = OpLabel
+ OpBranch %21
+ %23 = OpLabel
+ %67 = OpAccessChain %18 %17 %9 %9
+ %68 = OpLoad %6 %67
+ %69 = OpConvertSToF %63 %68
+ %70 = OpAccessChain %18 %17 %9 %40
+ %71 = OpLoad %6 %70
+ %72 = OpConvertSToF %63 %71
+ %73 = OpAccessChain %18 %17 %9 %40
+ %74 = OpLoad %6 %73
+ %75 = OpConvertSToF %63 %74
+ %76 = OpAccessChain %18 %17 %9 %9
+ %77 = OpLoad %6 %76
+ %78 = OpConvertSToF %63 %77
+ %79 = OpCompositeConstruct %64 %69 %72 %75 %78
+ OpStore %66 %79
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# _GLF_uniform_int_values
+BUFFER variant__GLF_uniform_int_values DATA_TYPE int32[] STD140 DATA
+ 1 0 3 6
+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_0 _GLF_uniform_int_values[0]
+# #define _int_5 _GLF_uniform_int_values[1]
+# #define _int_1 _GLF_uniform_int_values[2]
+# #define _float_0_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_float_values: [0.0, 1.0]
+# layout(set = 0, binding = 0) uniform buf0
+# {
+# float _GLF_uniform_float_values[2];
+# };
+#
+# // Contents of _GLF_uniform_int_values: [0, 5, 1]
+# layout(set = 0, binding = 1) uniform buf1
+# {
+# int _GLF_uniform_int_values[3];
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# // Contents of injectionSwitch: [0.0, 1.0]
+# layout(set = 0, binding = 2) uniform buf2
+# {
+# vec2 injectionSwitch;
+# };
+#
+# void main()
+# {
+# _GLF_color = vec4(_int_0);
+#
+# // Always false.
+# if(injectionSwitch.x > injectionSwitch.y)
+# {
+# }
+# else
+# {
+# // Always true.
+# if(gl_FragCoord.x >= _float_0_0)
+# {
+# _GLF_color = vec4(_float_1_0);
+# }
+#
+# for(int i = _int_0; i < _int_5; i++)
+# {
+# _GLF_color = vec4(_int_1, _int_0, _int_0, 1);
+#
+# // Always true.
+# if(gl_FragCoord.y >= _float_0_0)
+# {
+# // Always false.
+# if(injectionSwitch.x > injectionSwitch.y)
+# {
+# _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: 101
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %9 %40
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %9 "_GLF_color"
+ OpName %14 "buf1"
+ OpMemberName %14 0 "_GLF_uniform_int_values"
+ OpName %16 ""
+ OpName %24 "buf2"
+ OpMemberName %24 0 "injectionSwitch"
+ OpName %26 ""
+ OpName %40 "gl_FragCoord"
+ OpName %46 "buf0"
+ OpMemberName %46 0 "_GLF_uniform_float_values"
+ OpName %48 ""
+ OpName %59 "i"
+ OpDecorate %9 Location 0
+ OpDecorate %13 ArrayStride 16
+ OpMemberDecorate %14 0 Offset 0
+ OpDecorate %14 Block
+ OpDecorate %16 DescriptorSet 0
+ OpDecorate %16 Binding 1
+ OpMemberDecorate %24 0 Offset 0
+ OpDecorate %24 Block
+ OpDecorate %26 DescriptorSet 0
+ OpDecorate %26 Binding 2
+ OpDecorate %40 BuiltIn FragCoord
+ OpDecorate %45 ArrayStride 16
+ OpMemberDecorate %46 0 Offset 0
+ OpDecorate %46 Block
+ OpDecorate %48 DescriptorSet 0
+ OpDecorate %48 Binding 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeFloat 32
+ %7 = OpTypeVector %6 4
+ %8 = OpTypePointer Output %7
+ %9 = OpVariable %8 Output
+ %10 = OpTypeInt 32 1
+ %11 = OpTypeInt 32 0
+ %12 = OpConstant %11 3
+ %13 = OpTypeArray %10 %12
+ %14 = OpTypeStruct %13
+ %15 = OpTypePointer Uniform %14
+ %16 = OpVariable %15 Uniform
+ %17 = OpConstant %10 0
+ %18 = OpTypePointer Uniform %10
+ %23 = OpTypeVector %6 2
+ %24 = OpTypeStruct %23
+ %25 = OpTypePointer Uniform %24
+ %26 = OpVariable %25 Uniform
+ %27 = OpConstant %11 0
+ %28 = OpTypePointer Uniform %6
+ %31 = OpConstant %11 1
+ %34 = OpTypeBool
+ %39 = OpTypePointer Input %7
+ %40 = OpVariable %39 Input
+ %41 = OpTypePointer Input %6
+ %44 = OpConstant %11 2
+ %45 = OpTypeArray %6 %44
+ %46 = OpTypeStruct %45
+ %47 = OpTypePointer Uniform %46
+ %48 = OpVariable %47 Uniform
+ %54 = OpConstant %10 1
+ %58 = OpTypePointer Function %10
+ %71 = OpConstant %10 2
+ %81 = OpConstant %6 1
+ %97 = OpConstant %6 0
+ %98 = OpConstantComposite %7 %97 %97 %97 %97
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %59 = OpVariable %58 Function
+ %19 = OpAccessChain %18 %16 %17 %17
+ %20 = OpLoad %10 %19
+ %21 = OpConvertSToF %6 %20
+ %22 = OpCompositeConstruct %7 %21 %21 %21 %21
+ OpStore %9 %22
+ %29 = OpAccessChain %28 %26 %17 %27
+ %30 = OpLoad %6 %29
+ %32 = OpAccessChain %28 %26 %17 %31
+ %33 = OpLoad %6 %32
+ %35 = OpFOrdGreaterThan %34 %30 %33
+ OpSelectionMerge %37 None
+ OpBranchConditional %35 %36 %38
+ %36 = OpLabel
+ OpBranch %37
+ %38 = OpLabel
+ %42 = OpAccessChain %41 %40 %27
+ %43 = OpLoad %6 %42
+ %49 = OpAccessChain %28 %48 %17 %17
+ %50 = OpLoad %6 %49
+ %51 = OpFOrdGreaterThanEqual %34 %43 %50
+ OpSelectionMerge %53 None
+ OpBranchConditional %51 %52 %53
+ %52 = OpLabel
+ %55 = OpAccessChain %28 %48 %17 %54
+ %56 = OpLoad %6 %55
+ %57 = OpCompositeConstruct %7 %56 %56 %56 %56
+ OpStore %9 %57
+ OpBranch %53
+ %53 = OpLabel
+ %60 = OpAccessChain %18 %16 %17 %17
+ %61 = OpLoad %10 %60
+ OpStore %59 %61
+ OpBranch %62
+ %62 = OpLabel
+ OpLoopMerge %64 %65 None
+ OpBranch %66
+ %66 = OpLabel
+ %67 = OpLoad %10 %59
+ %68 = OpAccessChain %18 %16 %17 %54
+ %69 = OpLoad %10 %68
+ %70 = OpSLessThan %34 %67 %69
+ OpBranchConditional %70 %63 %64
+ %63 = OpLabel
+ %72 = OpAccessChain %18 %16 %17 %71
+ %73 = OpLoad %10 %72
+ %74 = OpConvertSToF %6 %73
+ %75 = OpAccessChain %18 %16 %17 %17
+ %76 = OpLoad %10 %75
+ %77 = OpConvertSToF %6 %76
+ %78 = OpAccessChain %18 %16 %17 %17
+ %79 = OpLoad %10 %78
+ %80 = OpConvertSToF %6 %79
+ %82 = OpCompositeConstruct %7 %74 %77 %80 %81
+ OpStore %9 %82
+ %83 = OpAccessChain %41 %40 %31
+ %84 = OpLoad %6 %83
+ %85 = OpAccessChain %28 %48 %17 %17
+ %86 = OpLoad %6 %85
+ %87 = OpFOrdGreaterThanEqual %34 %84 %86
+ OpSelectionMerge %89 None
+ OpBranchConditional %87 %88 %89
+ %88 = OpLabel
+ %90 = OpAccessChain %28 %26 %17 %27
+ %91 = OpLoad %6 %90
+ %92 = OpAccessChain %28 %26 %17 %31
+ %93 = OpLoad %6 %92
+ %94 = OpFOrdGreaterThan %34 %91 %93
+ OpSelectionMerge %96 None
+ OpBranchConditional %94 %95 %96
+ %95 = OpLabel
+ OpStore %9 %98
+ OpBranch %96
+ %96 = OpLabel
+ OpBranch %89
+ %89 = OpLabel
+ OpBranch %65
+ %65 = OpLabel
+ %99 = OpLoad %10 %59
+ %100 = OpIAdd %10 %99 %54
+ OpStore %59 %100
+ OpBranch %62
+ %64 = OpLabel
+ OpBranch %37
+ %37 = 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
+ 0 5 1
+END
+# _GLF_uniform_float_values
+BUFFER variant__GLF_uniform_float_values DATA_TYPE float[] STD140 DATA
+ 0.0 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_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.
+
+# 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_1 _GLF_uniform_int_values[1]
+#
+# precision highp int;
+# precision highp float;
+#
+# // Contents of _GLF_uniform_int_values: [0, 1]
+# layout(set = 0, binding = 0) uniform buf0
+# {
+# int _GLF_uniform_int_values[2];
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void main()
+# {
+# // Test resolution is 256 which makes fragment coordinate ANDed with 256 always zero.
+# int a = ((!(!((ivec2(gl_FragCoord.xy).y & 256) != 0))) ? 0 : ~0) | ((ivec2(gl_FragCoord.xy).y & 256) != 0 ? 0 : ~0);
+#
+# // Always true.
+# if(a == ~ _int_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: 72
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %12 %52
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %12 "gl_FragCoord"
+ OpName %41 "buf0"
+ OpMemberName %41 0 "_GLF_uniform_int_values"
+ OpName %43 ""
+ OpName %52 "_GLF_color"
+ OpDecorate %12 BuiltIn FragCoord
+ OpDecorate %40 ArrayStride 16
+ OpMemberDecorate %41 0 Offset 0
+ OpDecorate %41 Block
+ OpDecorate %43 DescriptorSet 0
+ OpDecorate %43 Binding 0
+ OpDecorate %52 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeInt 32 1
+ %9 = OpTypeFloat 32
+ %10 = OpTypeVector %9 4
+ %11 = OpTypePointer Input %10
+ %12 = OpVariable %11 Input
+ %13 = OpTypeVector %9 2
+ %16 = OpTypeVector %6 2
+ %18 = OpTypeInt 32 0
+ %21 = OpConstant %6 256
+ %23 = OpConstant %6 0
+ %24 = OpTypeBool
+ %28 = OpConstant %6 -1
+ %39 = OpConstant %18 2
+ %40 = OpTypeArray %6 %39
+ %41 = OpTypeStruct %40
+ %42 = OpTypePointer Uniform %41
+ %43 = OpVariable %42 Uniform
+ %44 = OpTypePointer Uniform %6
+ %51 = OpTypePointer Output %10
+ %52 = OpVariable %51 Output
+ %53 = OpConstant %6 1
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %14 = OpLoad %10 %12
+ %15 = OpVectorShuffle %13 %14 %14 0 1
+ %17 = OpConvertFToS %16 %15
+ %20 = OpCompositeExtract %6 %17 1
+ %22 = OpBitwiseAnd %6 %20 %21
+ %25 = OpINotEqual %24 %22 %23
+ %26 = OpLogicalNot %24 %25
+ %27 = OpLogicalNot %24 %26
+ %29 = OpSelect %6 %27 %23 %28
+ %36 = OpSelect %6 %25 %23 %28
+ %37 = OpBitwiseOr %6 %29 %36
+ %45 = OpAccessChain %44 %43 %23 %23
+ %46 = OpLoad %6 %45
+ %47 = OpNot %6 %46
+ %48 = OpIEqual %24 %37 %47
+ OpSelectionMerge %50 None
+ OpBranchConditional %48 %49 %67
+ %49 = OpLabel
+ %54 = OpAccessChain %44 %43 %23 %53
+ %55 = OpLoad %6 %54
+ %56 = OpConvertSToF %9 %55
+ %59 = OpConvertSToF %9 %46
+ %66 = OpCompositeConstruct %10 %56 %59 %59 %56
+ OpStore %52 %66
+ OpBranch %50
+ %67 = OpLabel
+ %70 = OpConvertSToF %9 %46
+ %71 = OpCompositeConstruct %10 %70 %70 %70 %70
+ OpStore %52 %71
+ OpBranch %50
+ %50 = OpLabel
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# _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__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_9 _GLF_uniform_int_values[1]
+# #define _int_10 _GLF_uniform_int_values[2]
+# #define _int_0 _GLF_uniform_int_values[3]
+# #define _int_32 _GLF_uniform_int_values[4]
+#
+# precision highp float;
+# precision highp int;
+#
+# // Contents of _GLF_uniform_int_values: [1, 9, 10, 0, 32]
+# layout(set = 0, binding = 0) uniform buf0
+# {
+# 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 arr[32] = int[32](_int_1, _int_1, _int_1, _int_1, _int_1, _int_1, _int_1, _int_1, _int_1, _int_1, _int_1, _int_1, _int_1, _int_1, _int_1, _int_1, _int_1, _int_1, _int_1, _int_1, _int_1, _int_1, _int_1, _int_1, _int_1, _int_1, _int_1, _int_1, _int_1, _int_1, _int_1, _int_1);
+#
+# // Iterated once.
+# for(int i = _int_1; _GLF_global_loop_count < _GLF_global_loop_bound; )
+# {
+# _GLF_global_loop_count ++;
+#
+# // Always true.
+# if(_int_1 > _int_0)
+# {
+# break;
+# }
+# }
+#
+# // Iterated nine times until global loop count is reached.
+# for(int i = _int_1; i < _int_32 && _GLF_global_loop_count < _GLF_global_loop_bound; i++)
+# {
+# _GLF_global_loop_count++;
+# // arr[i] = arr[i - 1];
+# arr[i] += arr[i - (_int_1 >> _int_0)];
+# }
+#
+# // Always true.
+# if(arr[_int_9] == _int_10 && arr[_int_10] == _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: 187
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %168
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %8 "_GLF_global_loop_count"
+ OpName %14 "arr"
+ OpName %17 "buf0"
+ OpMemberName %17 0 "_GLF_uniform_int_values"
+ OpName %19 ""
+ OpName %87 "i"
+ OpName %111 "i"
+ OpName %168 "_GLF_color"
+ OpDecorate %16 ArrayStride 16
+ OpMemberDecorate %17 0 Offset 0
+ OpDecorate %17 Block
+ OpDecorate %19 DescriptorSet 0
+ OpDecorate %19 Binding 0
+ OpDecorate %168 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeInt 32 1
+ %7 = OpTypePointer Private %6
+ %8 = OpVariable %7 Private
+ %9 = OpConstant %6 0
+ %10 = OpTypeInt 32 0
+ %11 = OpConstant %10 32
+ %12 = OpTypeArray %6 %11
+ %13 = OpTypePointer Function %12
+ %15 = OpConstant %10 5
+ %16 = OpTypeArray %6 %15
+ %17 = OpTypeStruct %16
+ %18 = OpTypePointer Uniform %17
+ %19 = OpVariable %18 Uniform
+ %20 = OpTypePointer Uniform %6
+ %86 = OpTypePointer Function %6
+ %96 = OpConstant %6 10
+ %97 = OpTypeBool
+ %100 = OpConstant %6 1
+ %104 = OpConstant %6 3
+ %120 = OpConstant %6 4
+ %149 = OpConstant %6 2
+ %165 = OpTypeFloat 32
+ %166 = OpTypeVector %165 4
+ %167 = OpTypePointer Output %166
+ %168 = OpVariable %167 Output
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %14 = OpVariable %13 Function
+ %87 = OpVariable %86 Function
+ %111 = OpVariable %86 Function
+ OpStore %8 %9
+ %21 = OpAccessChain %20 %19 %9 %9
+ %22 = OpLoad %6 %21
+ %23 = OpAccessChain %20 %19 %9 %9
+ %24 = OpLoad %6 %23
+ %25 = OpAccessChain %20 %19 %9 %9
+ %26 = OpLoad %6 %25
+ %27 = OpAccessChain %20 %19 %9 %9
+ %28 = OpLoad %6 %27
+ %29 = OpAccessChain %20 %19 %9 %9
+ %30 = OpLoad %6 %29
+ %31 = OpAccessChain %20 %19 %9 %9
+ %32 = OpLoad %6 %31
+ %33 = OpAccessChain %20 %19 %9 %9
+ %34 = OpLoad %6 %33
+ %35 = OpAccessChain %20 %19 %9 %9
+ %36 = OpLoad %6 %35
+ %37 = OpAccessChain %20 %19 %9 %9
+ %38 = OpLoad %6 %37
+ %39 = OpAccessChain %20 %19 %9 %9
+ %40 = OpLoad %6 %39
+ %41 = OpAccessChain %20 %19 %9 %9
+ %42 = OpLoad %6 %41
+ %43 = OpAccessChain %20 %19 %9 %9
+ %44 = OpLoad %6 %43
+ %45 = OpAccessChain %20 %19 %9 %9
+ %46 = OpLoad %6 %45
+ %47 = OpAccessChain %20 %19 %9 %9
+ %48 = OpLoad %6 %47
+ %49 = OpAccessChain %20 %19 %9 %9
+ %50 = OpLoad %6 %49
+ %51 = OpAccessChain %20 %19 %9 %9
+ %52 = OpLoad %6 %51
+ %53 = OpAccessChain %20 %19 %9 %9
+ %54 = OpLoad %6 %53
+ %55 = OpAccessChain %20 %19 %9 %9
+ %56 = OpLoad %6 %55
+ %57 = OpAccessChain %20 %19 %9 %9
+ %58 = OpLoad %6 %57
+ %59 = OpAccessChain %20 %19 %9 %9
+ %60 = OpLoad %6 %59
+ %61 = OpAccessChain %20 %19 %9 %9
+ %62 = OpLoad %6 %61
+ %63 = OpAccessChain %20 %19 %9 %9
+ %64 = OpLoad %6 %63
+ %65 = OpAccessChain %20 %19 %9 %9
+ %66 = OpLoad %6 %65
+ %67 = OpAccessChain %20 %19 %9 %9
+ %68 = OpLoad %6 %67
+ %69 = OpAccessChain %20 %19 %9 %9
+ %70 = OpLoad %6 %69
+ %71 = OpAccessChain %20 %19 %9 %9
+ %72 = OpLoad %6 %71
+ %73 = OpAccessChain %20 %19 %9 %9
+ %74 = OpLoad %6 %73
+ %75 = OpAccessChain %20 %19 %9 %9
+ %76 = OpLoad %6 %75
+ %77 = OpAccessChain %20 %19 %9 %9
+ %78 = OpLoad %6 %77
+ %79 = OpAccessChain %20 %19 %9 %9
+ %80 = OpLoad %6 %79
+ %81 = OpAccessChain %20 %19 %9 %9
+ %82 = OpLoad %6 %81
+ %83 = OpAccessChain %20 %19 %9 %9
+ %84 = OpLoad %6 %83
+ %85 = OpCompositeConstruct %12 %22 %24 %26 %28 %30 %32 %34 %36 %38 %40 %42 %44 %46 %48 %50 %52 %54 %56 %58 %60 %62 %64 %66 %68 %70 %72 %74 %76 %78 %80 %82 %84
+ OpStore %14 %85
+ %88 = OpAccessChain %20 %19 %9 %9
+ %89 = OpLoad %6 %88
+ OpStore %87 %89
+ OpBranch %90
+ %90 = OpLabel
+ OpLoopMerge %92 %93 None
+ OpBranch %94
+ %94 = OpLabel
+ %95 = OpLoad %6 %8
+ %98 = OpSLessThan %97 %95 %96
+ OpBranchConditional %98 %91 %92
+ %91 = OpLabel
+ %99 = OpLoad %6 %8
+ %101 = OpIAdd %6 %99 %100
+ OpStore %8 %101
+ %102 = OpAccessChain %20 %19 %9 %9
+ %103 = OpLoad %6 %102
+ %105 = OpAccessChain %20 %19 %9 %104
+ %106 = OpLoad %6 %105
+ %107 = OpSGreaterThan %97 %103 %106
+ OpSelectionMerge %109 None
+ OpBranchConditional %107 %108 %109
+ %108 = OpLabel
+ OpBranch %92
+ %109 = OpLabel
+ OpBranch %93
+ %93 = OpLabel
+ OpBranch %90
+ %92 = OpLabel
+ %112 = OpAccessChain %20 %19 %9 %9
+ %113 = OpLoad %6 %112
+ OpStore %111 %113
+ OpBranch %114
+ %114 = OpLabel
+ OpLoopMerge %116 %117 None
+ OpBranch %118
+ %118 = OpLabel
+ %119 = OpLoad %6 %111
+ %121 = OpAccessChain %20 %19 %9 %120
+ %122 = OpLoad %6 %121
+ %123 = OpSLessThan %97 %119 %122
+ %124 = OpLoad %6 %8
+ %125 = OpSLessThan %97 %124 %96
+ %126 = OpLogicalAnd %97 %123 %125
+ OpBranchConditional %126 %115 %116
+ %115 = OpLabel
+ %127 = OpLoad %6 %8
+ %128 = OpIAdd %6 %127 %100
+ OpStore %8 %128
+ %129 = OpLoad %6 %111
+ %130 = OpLoad %6 %111
+ %131 = OpAccessChain %20 %19 %9 %9
+ %132 = OpLoad %6 %131
+ %133 = OpAccessChain %20 %19 %9 %104
+ %134 = OpLoad %6 %133
+ %135 = OpShiftRightArithmetic %6 %132 %134
+ %136 = OpISub %6 %130 %135
+ %137 = OpAccessChain %86 %14 %136
+ %138 = OpLoad %6 %137
+ %139 = OpAccessChain %86 %14 %129
+ %140 = OpLoad %6 %139
+ %141 = OpIAdd %6 %140 %138
+ %142 = OpAccessChain %86 %14 %129
+ OpStore %142 %141
+ OpBranch %117
+ %117 = OpLabel
+ %143 = OpLoad %6 %111
+ %144 = OpIAdd %6 %143 %100
+ OpStore %111 %144
+ OpBranch %114
+ %116 = OpLabel
+ %145 = OpAccessChain %20 %19 %9 %100
+ %146 = OpLoad %6 %145
+ %147 = OpAccessChain %86 %14 %146
+ %148 = OpLoad %6 %147
+ %150 = OpAccessChain %20 %19 %9 %149
+ %151 = OpLoad %6 %150
+ %152 = OpIEqual %97 %148 %151
+ OpSelectionMerge %154 None
+ OpBranchConditional %152 %153 %154
+ %153 = OpLabel
+ %155 = OpAccessChain %20 %19 %9 %149
+ %156 = OpLoad %6 %155
+ %157 = OpAccessChain %86 %14 %156
+ %158 = OpLoad %6 %157
+ %159 = OpAccessChain %20 %19 %9 %9
+ %160 = OpLoad %6 %159
+ %161 = OpIEqual %97 %158 %160
+ OpBranch %154
+ %154 = OpLabel
+ %162 = OpPhi %97 %152 %116 %161 %153
+ OpSelectionMerge %164 None
+ OpBranchConditional %162 %163 %182
+ %163 = OpLabel
+ %169 = OpAccessChain %20 %19 %9 %9
+ %170 = OpLoad %6 %169
+ %171 = OpConvertSToF %165 %170
+ %172 = OpAccessChain %20 %19 %9 %104
+ %173 = OpLoad %6 %172
+ %174 = OpConvertSToF %165 %173
+ %175 = OpAccessChain %20 %19 %9 %104
+ %176 = OpLoad %6 %175
+ %177 = OpConvertSToF %165 %176
+ %178 = OpAccessChain %20 %19 %9 %9
+ %179 = OpLoad %6 %178
+ %180 = OpConvertSToF %165 %179
+ %181 = OpCompositeConstruct %166 %171 %174 %177 %180
+ OpStore %168 %181
+ OpBranch %164
+ %182 = OpLabel
+ %183 = OpAccessChain %20 %19 %9 %104
+ %184 = OpLoad %6 %183
+ %185 = OpConvertSToF %165 %184
+ %186 = OpCompositeConstruct %166 %185 %185 %185 %185
+ OpStore %168 %186
+ OpBranch %164
+ %164 = OpLabel
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# _GLF_uniform_int_values
+BUFFER variant__GLF_uniform_int_values DATA_TYPE int32[] STD140 DATA
+ 1 9 10 0 32
+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
{ "cov-bitfieldinsert-undefined.amber", "cov-bitfieldinsert-undefined", "A fragment shader that covers a specific instruction simplify code path" },
{ "cov-bitfieldreverse-left-shift-findmsb.amber", "cov-bitfieldreverse-left-shift-findmsb", "Covers specific DAG combiner and legalize vector ops code paths" },
{ "cov-bitfieldreverse-loop-limit-underflow.amber", "cov-bitfieldreverse-loop-limit-underflow", "A fragment shader that covers specific NIR code paths" },
+{ "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-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-dummy-function-loop-array-element-increment-never-read.amber", "cov-dummy-function-loop-array-element-increment-never-read", "A fragment shader that covers specific LLVM code paths" },
{ "cov-empty-loop-minus-one-modulo-variable-one.amber", "cov-empty-loop-minus-one-modulo-variable-one", "A fragment shader that covers specific LLVM code paths" },
{ "cov-exp2-two.amber", "cov-exp2-two", "A fragment shader that covers specific NIR code paths" },
+{ "cov-extend-uniform-vec2-to-vec3-matrix-multiply.amber", "cov-extend-uniform-vec2-to-vec3-matrix-multiply", "A fragment shader that covers specific LLVM code paths" },
{ "cov-findlsb-division-by-zero.amber", "cov-findlsb-division-by-zero", "A fragment shader that covers a specific instruction simplify code path" },
{ "cov-float-array-init-pow.amber", "cov-float-array-init-pow", "A fragment shader that covers specific arith builder code path" },
{ "cov-fold-and-in-for-loop-range.amber", "cov-fold-and-in-for-loop-range", "A fragment shader that covers a specific folding path" },
{ "cov-fract-smoothstep-undefined.amber", "cov-fract-smoothstep-undefined", "A fragment shader that covers a specific APFloat code path" },
{ "cov-fract-trunc-always-zero.amber", "cov-fract-trunc-always-zero", "A fragment shader that covers specific LLVM code paths" },
{ "cov-fragcood-multiple-conditions-function-loop-global-counter.amber", "cov-fragcood-multiple-conditions-function-loop-global-counter", "A fragment shader that covers specific LLVM code paths" },
+{ "cov-fragcoord-bitwise-and-loop-reduce-value-index-array.amber", "cov-fragcoord-bitwise-and-loop-reduce-value-index-array", "A fragment shader that covers specific LLVM code paths" },
{ "cov-fragcoord-bitwise-not.amber", "cov-fragcoord-bitwise-not", "A fragment shader that covers specific BRW code paths" },
{ "cov-fragcoord-clamp-array-access.amber", "cov-fragcoord-clamp-array-access", "A fragment shader that covers a specific instruction simplify path" },
{ "cov-fragcoord-conditions-never-return-index-array-using-uniform.amber", "cov-fragcoord-conditions-never-return-index-array-using-uniform", "A fragment shader that covers specific LLVM code paths" },
{ "cov-function-fragcoord-condition-always-return.amber", "cov-function-fragcoord-condition-always-return", "A fragment shader that covers specific LLVM code paths" },
{ "cov-function-large-array-max-clamp.amber", "cov-function-large-array-max-clamp", "A fragment shader that covers specific LLVM code paths" },
{ "cov-function-loop-condition-uniform-shift-right.amber", "cov-function-loop-condition-uniform-shift-right", "A fragment shader that covers specific LLVM code paths" },
+{ "cov-function-loop-same-conditions-multiple-times-struct-array.amber", "cov-function-loop-same-conditions-multiple-times-struct-array", "A fragment shader that covers specific LLVM code paths" },
{ "cov-function-nested-do-whiles-looped-once.amber", "cov-function-nested-do-whiles-looped-once", "A fragment shader that covers specific LLVM code paths" },
{ "cov-function-nested-loops-break-early-never-discard.amber", "cov-function-nested-loops-break-early-never-discard", "A fragment shader that covers specific LLVM code paths" },
{ "cov-function-trivial-switch-case.amber", "cov-function-trivial-switch-case", "A fragment shader that covers specific LLVM code paths" },
{ "cov-function-two-loops-limit-using-arguments-array-element-copies.amber", "cov-function-two-loops-limit-using-arguments-array-element-copies", "A fragment shader that covers specific LLVM code paths" },
{ "cov-function-unpack-unorm-2x16-one.amber", "cov-function-unpack-unorm-2x16-one", "A fragment shader that covers specific LLVM code paths" },
+{ "cov-function-variable-plus-one-minus-one.amber", "cov-function-variable-plus-one-minus-one", "A fragment shader that covers specific LLVM code paths" },
{ "cov-function-vec2-never-discard.amber", "cov-function-vec2-never-discard", "A fragment shader that covers specific BRW code paths" },
{ "cov-function-with-nested-loops-called-from-nested-loops.amber", "cov-function-with-nested-loops-called-from-nested-loops", "A fragment shader that covers specific BRW 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-int-div-round-to-zero.amber", "cov-int-div-round-to-zero", "A fragment shader that covers specific fast idiv code path" },
{ "cov-int-full-bits-divide-by-two-loop.amber", "cov-int-full-bits-divide-by-two-loop", "A fragment shader that covers specific BRW code paths" },
{ "cov-int-initialize-from-multiple-large-arrays.amber", "cov-int-initialize-from-multiple-large-arrays", "A fragment shader that covers specific LLVM code paths" },
+{ "cov-integer-constant-mod-variable-increased-condition-array-element.amber", "cov-integer-constant-mod-variable-increased-condition-array-element", "A fragment shader that covers specific LLVM code paths" },
{ "cov-integer-minus-one-increased-before-indexing-array.amber", "cov-integer-minus-one-increased-before-indexing-array", "A fragment shader that covers specific LLVM code paths" },
{ "cov-integer-modulo-negative.amber", "cov-integer-modulo-negative", "A fragment shader that covers specific instruction combining code paths" },
{ "cov-intervalmap-set-stop.amber", "cov-intervalmap-set-stop", "A fragment shader that covers a specific interval map code 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-shift-right-by-large-number.amber", "cov-ivec-shift-right-by-large-number", "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-ldexp-exponent-undefined-divided-fragcoord-never-executed.amber", "cov-ldexp-exponent-undefined-divided-fragcoord-never-executed", "A fragment shader that covers specific LLVM code paths" },
{ "cov-ldexp-undefined-mat-vec-multiply.amber", "cov-ldexp-undefined-mat-vec-multiply", "Covers specific inst combine simplify demanded and inst combine shifts path" },
{ "cov-left-shift-array-access.amber", "cov-left-shift-array-access", "A fragment shader that covers a specific inst combine shifts code path" },
{ "cov-left-shift-right-shift-compare.amber", "cov-left-shift-right-shift-compare", "A fragment shader that covers a specific inst combine compares code path" },
{ "cov-loop-condition-double-negate.amber", "cov-loop-condition-double-negate", "A fragment shader that covers specific NIR code paths" },
{ "cov-loop-condition-logical-or-never-iterated.amber", "cov-loop-condition-logical-or-never-iterated", "A fragment shader that covers specific LLVM code paths" },
{ "cov-loop-dfdx-constant-divide.amber", "cov-loop-dfdx-constant-divide", "A fragment shader that covers specific patch optimization code paths" },
+{ "cov-loop-exit-conditions-sampler-struct-integer-variable.amber", "cov-loop-exit-conditions-sampler-struct-integer-variable", "A fragment shader that covers specific LLVM code paths" },
{ "cov-loop-findmsb-findlsb.amber", "cov-loop-findmsb-findlsb", "A fragment shader that covers specific simplification and value tracking 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-min-negative-constant-always-below-one.amber", "cov-min-negative-constant-always-below-one", "A fragment shader that covers specific LLVM code paths" },
{ "cov-min-nested-loop-same-value-for-variables.amber", "cov-min-nested-loop-same-value-for-variables", "A fragment shader that covers specific NIR code paths" },
{ "cov-missing-return-value-function-never-called.amber", "cov-missing-return-value-function-never-called", "A fragment shader that covers specific BRW code paths" },
+{ "cov-mix-uninitialized-vector-select-only-defined-data.amber", "cov-mix-uninitialized-vector-select-only-defined-data", "A fragment shader that covers specific LLVM code paths" },
{ "cov-mod-acosh.amber", "cov-mod-acosh", "A fragment shader that calculates modulo of an acosh result" },
{ "cov-mod-uint-bits-float.amber", "cov-mod-uint-bits-float", "A fragment shader that covers a specific APFloat path" },
{ "cov-modf-clamp-for.amber", "cov-modf-clamp-for", "A fragment shader that covers a specific live intervals code path" },
{ "cov-nested-loop-not-greater-than-increment-array-element.amber", "cov-nested-loop-not-greater-than-increment-array-element", "A fragment shader that covers specific LLVM code paths" },
{ "cov-nested-loop-undefined-smoothstep-never-executed.amber", "cov-nested-loop-undefined-smoothstep-never-executed", "A fragment shader that covers specific BRW code paths" },
{ "cov-nested-loops-clamp-ivec-push-constant-increment-global-counter.amber", "cov-nested-loops-clamp-ivec-push-constant-increment-global-counter", "A fragment shader that covers specific LLVM code paths" },
+{ "cov-nested-loops-different-iteration-rates-function-copy-array-elements.amber", "cov-nested-loops-different-iteration-rates-function-copy-array-elements", "A fragment shader that covers specific LLVM code paths" },
+{ "cov-nested-loops-divide-integer-constant-always-zero.amber", "cov-nested-loops-divide-integer-constant-always-zero", "A fragment shader that covers specific LLVM code paths" },
{ "cov-nested-loops-decrease-vector-component-by-matrix-element-global-loop-counter.amber", "cov-nested-loops-decrease-vector-component-by-matrix-element-global-loop-counter", "A fragment shader that covers specific LLVM code paths" },
{ "cov-nested-loops-float-array-select-by-fragcoord.amber", "cov-nested-loops-float-array-select-by-fragcoord", "A fragment shader that covers specific BRW code paths" },
{ "cov-nested-loops-float-bits-to-int-increment-array.amber", "cov-nested-loops-float-bits-to-int-increment-array", "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-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" },
{ "cov-nir-array-access.amber", "cov-nir-array-access", "A fragment shader that covers a specific nir path" },
{ "cov-nir-opt-large-constants-for-clamp-vector-access.amber", "cov-nir-opt-large-constants-for-clamp-vector-access", "A fragment shader that covers a specific nir opt large constants path" },
{ "cov-nir-opt-loop-unroll-if-if-if-if-do-while.amber", "cov-nir-opt-loop-unroll-if-if-if-if-do-while", "A fragment shader that covers a specific nir opt loop unroll path" },
+{ "cov-nouble-negation-fragcoord-cast-ivec2-bitwise-and.amber", "cov-nouble-negation-fragcoord-cast-ivec2-bitwise-and", "A fragment shader that covers specific LLVM code paths" },
{ "cov-one-minus-clamp-always-one-cast-to-int.amber", "cov-one-minus-clamp-always-one-cast-to-int", "A fragment shader that covers specific NIR code paths" },
{ "cov-optimize-phis-for.amber", "cov-optimize-phis-for", "A fragment shader that cover specific optimize phis code paths" },
{ "cov-optimize-phis-for-for-do-while-if-if.amber", "cov-optimize-phis-for-for-do-while-if-if", "A fragment shader that covers a specific optimize PHIs code path" },
{ "cov-texel-double-negation.amber", "cov-texel-double-negation", "A fragment shader that covers specific NIR code paths" },
{ "cov-transpose-multiply.amber", "cov-transpose-multiply", "A fragment shader that covers specific NIR code paths" },
{ "cov-trunc-fract-always-zero.amber", "cov-trunc-fract-always-zero", "A fragment shader that covers specific NIR code paths" },
+{ "cov-two-loops-global-loop-counter-shift-right-zero-increment-array-element.amber", "cov-two-loops-global-loop-counter-shift-right-zero-increment-array-element", "A fragment shader that covers specific LLVM code paths" },
{ "cov-two-nested-loops-switch-case-matrix-array-increment.amber", "cov-two-nested-loops-switch-case-matrix-array-increment", "A fragment shader that covers specific LLVM code paths" },
{ "cov-types-return-in-main-never-hit.amber", "cov-types-return-in-main-never-hit", "A fragment shader that covers a specific types optimization path." },
{ "cov-ucarryadd-one-and-one.amber", "cov-ucarryadd-one-and-one", "A fragment shader that covers specific LLVM code paths" },
dEQP-VK.graphicsfuzz.cov-bitfieldinsert-undefined
dEQP-VK.graphicsfuzz.cov-bitfieldreverse-left-shift-findmsb
dEQP-VK.graphicsfuzz.cov-bitfieldreverse-loop-limit-underflow
+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-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-dummy-function-loop-array-element-increment-never-read
dEQP-VK.graphicsfuzz.cov-empty-loop-minus-one-modulo-variable-one
dEQP-VK.graphicsfuzz.cov-exp2-two
+dEQP-VK.graphicsfuzz.cov-extend-uniform-vec2-to-vec3-matrix-multiply
dEQP-VK.graphicsfuzz.cov-findlsb-division-by-zero
dEQP-VK.graphicsfuzz.cov-float-array-init-pow
dEQP-VK.graphicsfuzz.cov-fold-and-in-for-loop-range
dEQP-VK.graphicsfuzz.cov-fract-smoothstep-undefined
dEQP-VK.graphicsfuzz.cov-fract-trunc-always-zero
dEQP-VK.graphicsfuzz.cov-fragcood-multiple-conditions-function-loop-global-counter
+dEQP-VK.graphicsfuzz.cov-fragcoord-bitwise-and-loop-reduce-value-index-array
dEQP-VK.graphicsfuzz.cov-fragcoord-bitwise-not
dEQP-VK.graphicsfuzz.cov-fragcoord-clamp-array-access
dEQP-VK.graphicsfuzz.cov-fragcoord-conditions-never-return-index-array-using-uniform
dEQP-VK.graphicsfuzz.cov-function-fragcoord-condition-always-return
dEQP-VK.graphicsfuzz.cov-function-large-array-max-clamp
dEQP-VK.graphicsfuzz.cov-function-loop-condition-uniform-shift-right
+dEQP-VK.graphicsfuzz.cov-function-loop-same-conditions-multiple-times-struct-array
dEQP-VK.graphicsfuzz.cov-function-nested-do-whiles-looped-once
dEQP-VK.graphicsfuzz.cov-function-nested-loops-break-early-never-discard
dEQP-VK.graphicsfuzz.cov-function-trivial-switch-case
dEQP-VK.graphicsfuzz.cov-function-two-loops-limit-using-arguments-array-element-copies
dEQP-VK.graphicsfuzz.cov-function-unpack-unorm-2x16-one
+dEQP-VK.graphicsfuzz.cov-function-variable-plus-one-minus-one
dEQP-VK.graphicsfuzz.cov-function-vec2-never-discard
dEQP-VK.graphicsfuzz.cov-function-with-nested-loops-called-from-nested-loops
dEQP-VK.graphicsfuzz.cov-global-loop-bound-true-logical-or
dEQP-VK.graphicsfuzz.cov-int-div-round-to-zero
dEQP-VK.graphicsfuzz.cov-int-full-bits-divide-by-two-loop
dEQP-VK.graphicsfuzz.cov-int-initialize-from-multiple-large-arrays
+dEQP-VK.graphicsfuzz.cov-integer-constant-mod-variable-increased-condition-array-element
dEQP-VK.graphicsfuzz.cov-integer-minus-one-increased-before-indexing-array
dEQP-VK.graphicsfuzz.cov-integer-modulo-negative
dEQP-VK.graphicsfuzz.cov-intervalmap-set-stop
dEQP-VK.graphicsfuzz.cov-isnan-asinh-clamp-always-zero
dEQP-VK.graphicsfuzz.cov-ivec-shift-right-by-large-number
dEQP-VK.graphicsfuzz.cov-large-int-array-nested-loops-set-ivec-index-component-sum
+dEQP-VK.graphicsfuzz.cov-ldexp-exponent-undefined-divided-fragcoord-never-executed
dEQP-VK.graphicsfuzz.cov-ldexp-undefined-mat-vec-multiply
dEQP-VK.graphicsfuzz.cov-left-shift-array-access
dEQP-VK.graphicsfuzz.cov-left-shift-right-shift-compare
dEQP-VK.graphicsfuzz.cov-loop-condition-double-negate
dEQP-VK.graphicsfuzz.cov-loop-condition-logical-or-never-iterated
dEQP-VK.graphicsfuzz.cov-loop-dfdx-constant-divide
+dEQP-VK.graphicsfuzz.cov-loop-exit-conditions-sampler-struct-integer-variable
dEQP-VK.graphicsfuzz.cov-loop-findmsb-findlsb
dEQP-VK.graphicsfuzz.cov-loop-fragcoord-identical-condition
dEQP-VK.graphicsfuzz.cov-loop-increment-array-elements-clamp-index
dEQP-VK.graphicsfuzz.cov-min-negative-constant-always-below-one
dEQP-VK.graphicsfuzz.cov-min-nested-loop-same-value-for-variables
dEQP-VK.graphicsfuzz.cov-missing-return-value-function-never-called
+dEQP-VK.graphicsfuzz.cov-mix-uninitialized-vector-select-only-defined-data
dEQP-VK.graphicsfuzz.cov-mod-acosh
dEQP-VK.graphicsfuzz.cov-mod-uint-bits-float
dEQP-VK.graphicsfuzz.cov-modf-clamp-for
dEQP-VK.graphicsfuzz.cov-nested-loop-not-greater-than-increment-array-element
dEQP-VK.graphicsfuzz.cov-nested-loop-undefined-smoothstep-never-executed
dEQP-VK.graphicsfuzz.cov-nested-loops-clamp-ivec-push-constant-increment-global-counter
+dEQP-VK.graphicsfuzz.cov-nested-loops-different-iteration-rates-function-copy-array-elements
+dEQP-VK.graphicsfuzz.cov-nested-loops-divide-integer-constant-always-zero
dEQP-VK.graphicsfuzz.cov-nested-loops-decrease-vector-component-by-matrix-element-global-loop-counter
dEQP-VK.graphicsfuzz.cov-nested-loops-float-array-select-by-fragcoord
dEQP-VK.graphicsfuzz.cov-nested-loops-float-bits-to-int-increment-array
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-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-nir-array-access
dEQP-VK.graphicsfuzz.cov-nir-opt-large-constants-for-clamp-vector-access
dEQP-VK.graphicsfuzz.cov-nir-opt-loop-unroll-if-if-if-if-do-while
+dEQP-VK.graphicsfuzz.cov-nouble-negation-fragcoord-cast-ivec2-bitwise-and
dEQP-VK.graphicsfuzz.cov-one-minus-clamp-always-one-cast-to-int
dEQP-VK.graphicsfuzz.cov-optimize-phis-for
dEQP-VK.graphicsfuzz.cov-optimize-phis-for-for-do-while-if-if
dEQP-VK.graphicsfuzz.cov-texel-double-negation
dEQP-VK.graphicsfuzz.cov-transpose-multiply
dEQP-VK.graphicsfuzz.cov-trunc-fract-always-zero
+dEQP-VK.graphicsfuzz.cov-two-loops-global-loop-counter-shift-right-zero-increment-array-element
dEQP-VK.graphicsfuzz.cov-two-nested-loops-switch-case-matrix-array-increment
dEQP-VK.graphicsfuzz.cov-types-return-in-main-never-hit
dEQP-VK.graphicsfuzz.cov-ucarryadd-one-and-one
projects / platform / upstream / VK-GL-CTS.git / commitdiff