This commit adds a batch of GraphicsFuzz coverage tests.
Components: Vulkan
New Tests:
dEQP-VK.graphicsfuzz.cov-enable-bits-pixel-location-negate-not-equal-one
dEQP-VK.graphicsfuzz.cov-fragcoord-and-one-or-same-value
dEQP-VK.graphicsfuzz.cov-fragcoord-loop-limit-negative-decrease-sum-first-iteration
dEQP-VK.graphicsfuzz.cov-function-call-twice-clamp-global-variable
dEQP-VK.graphicsfuzz.cov-function-loop-variable-multiplied-unused
dEQP-VK.graphicsfuzz.cov-loop-array-element-bitfield-insert-undefined-never-read
dEQP-VK.graphicsfuzz.cov-loop-find-lsb-eight-fragcoord-never-discard
dEQP-VK.graphicsfuzz.cov-loop-index-array-max-negative-zero
dEQP-VK.graphicsfuzz.cov-loop-max-divide-integer-by-ten
dEQP-VK.graphicsfuzz.cov-loop-sampled-texel-integer-counter
dEQP-VK.graphicsfuzz.cov-loop-variable-less-than-itself
dEQP-VK.graphicsfuzz.cov-mix-uninitialized-float-never-selected
dEQP-VK.graphicsfuzz.cov-nested-loop-decrease-vector-components
dEQP-VK.graphicsfuzz.cov-nested-loops-while-condition-integer-range-increment-variable
dEQP-VK.graphicsfuzz.cov-uadd-carry-bit-count-index-array
Change-Id: I4160d3418b1a8fa3a29695f939af6aa79ded319d
dEQP-VK.graphicsfuzz.cov-double-if-true-in-loop
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-enable-bits-pixel-location-negate-not-equal-one
dEQP-VK.graphicsfuzz.cov-exp2-two
dEQP-VK.graphicsfuzz.cov-extend-uniform-vec2-to-vec3-matrix-multiply
dEQP-VK.graphicsfuzz.cov-float-array-init-pow
dEQP-VK.graphicsfuzz.cov-fract-asin-undefined-never-used
dEQP-VK.graphicsfuzz.cov-fract-trunc-always-zero
dEQP-VK.graphicsfuzz.cov-fragcood-multiple-conditions-function-loop-global-counter
+dEQP-VK.graphicsfuzz.cov-fragcoord-and-one-or-same-value
dEQP-VK.graphicsfuzz.cov-fragcoord-bitwise-and-loop-reduce-value-index-array
dEQP-VK.graphicsfuzz.cov-fragcoord-bitwise-not
dEQP-VK.graphicsfuzz.cov-fragcoord-conditions-never-return-index-array-using-uniform
dEQP-VK.graphicsfuzz.cov-fragcoord-integer-loop-reduce-to-range
+dEQP-VK.graphicsfuzz.cov-fragcoord-loop-limit-negative-decrease-sum-first-iteration
dEQP-VK.graphicsfuzz.cov-fragcoord-multiple-conditions-function-global-loop-counter-simplified
dEQP-VK.graphicsfuzz.cov-fragcoord-multiply
dEQP-VK.graphicsfuzz.cov-function-argument-uniform-float-loop-never-return
dEQP-VK.graphicsfuzz.cov-function-clamp-min-identical-shift-right
+dEQP-VK.graphicsfuzz.cov-function-call-twice-clamp-global-variable
dEQP-VK.graphicsfuzz.cov-function-find-lsb-ivec2-one
dEQP-VK.graphicsfuzz.cov-function-fragcoord-condition-always-return
dEQP-VK.graphicsfuzz.cov-function-infinite-loop-always-return
dEQP-VK.graphicsfuzz.cov-function-loop-same-conditions-multiple-times-struct-array
dEQP-VK.graphicsfuzz.cov-function-loop-switch-increment-array-element-return
dEQP-VK.graphicsfuzz.cov-function-min-integer-large-shift-unused
+dEQP-VK.graphicsfuzz.cov-function-loop-variable-multiplied-unused
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-nested-loops-limit-uniform-xor-uniform
dEQP-VK.graphicsfuzz.cov-left-shift-array-access
dEQP-VK.graphicsfuzz.cov-left-shift-right-shift-compare
dEQP-VK.graphicsfuzz.cov-loop-abs-multiply-offset
+dEQP-VK.graphicsfuzz.cov-loop-array-element-bitfield-insert-undefined-never-read
dEQP-VK.graphicsfuzz.cov-loop-array-element-copy-index-clamp-sign
dEQP-VK.graphicsfuzz.cov-loop-array-index-decrement-never-negative
dEQP-VK.graphicsfuzz.cov-loop-array-struct-field-index-array-with-uniforms
dEQP-VK.graphicsfuzz.cov-loop-dfdx-constant-divide
dEQP-VK.graphicsfuzz.cov-loop-exit-conditions-sampler-struct-integer-variable
dEQP-VK.graphicsfuzz.cov-loop-divide-uninitialized-vector-min-unused
+dEQP-VK.graphicsfuzz.cov-loop-find-lsb-eight-fragcoord-never-discard
dEQP-VK.graphicsfuzz.cov-loop-fragcoord-identical-condition
dEQP-VK.graphicsfuzz.cov-loop-global-counter-break-set-ivec-elements
dEQP-VK.graphicsfuzz.cov-loop-increase-iterator-condition-uniform-copy-array-elements
dEQP-VK.graphicsfuzz.cov-loop-increment-integer-set-output-color-break
dEQP-VK.graphicsfuzz.cov-loop-increment-matrix-element-break-after-first-iteration
dEQP-VK.graphicsfuzz.cov-loop-increment-or-divide-by-loop-index
+dEQP-VK.graphicsfuzz.cov-loop-index-array-max-negative-zero
dEQP-VK.graphicsfuzz.cov-loop-integer-half-minus-one
dEQP-VK.graphicsfuzz.cov-loop-iterator-plus-one-variable-outside-index-array
dEQP-VK.graphicsfuzz.cov-loop-large-array-index-clamp-negative-value
dEQP-VK.graphicsfuzz.cov-loop-logical-xor
dEQP-VK.graphicsfuzz.cov-loop-multiple-iterator-variables-copy-array-elements
dEQP-VK.graphicsfuzz.cov-loop-read-array-index-from-array-data
+dEQP-VK.graphicsfuzz.cov-loop-max-divide-integer-by-ten
dEQP-VK.graphicsfuzz.cov-loop-replace-output-color-restore-original
dEQP-VK.graphicsfuzz.cov-loop-returns-behind-true-and-false
+dEQP-VK.graphicsfuzz.cov-loop-sampled-texel-integer-counter
dEQP-VK.graphicsfuzz.cov-loop-set-vector-components-pow-two
dEQP-VK.graphicsfuzz.cov-loop-start-from-one-switch-case-invalid-color-never-executed
dEQP-VK.graphicsfuzz.cov-loop-start-from-one-switch-case-never-executed
dEQP-VK.graphicsfuzz.cov-loop-struct-array-field-set-value-self-dependency
dEQP-VK.graphicsfuzz.cov-loop-switch-discard-never-hit
dEQP-VK.graphicsfuzz.cov-loop-two-iterators-increment-array-empty-do-while
+dEQP-VK.graphicsfuzz.cov-loop-variable-less-than-itself
dEQP-VK.graphicsfuzz.cov-loop-with-two-integers
dEQP-VK.graphicsfuzz.cov-matching-conditions-break
dEQP-VK.graphicsfuzz.cov-matching-if-always-true-inside-loop
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-float-never-selected
dEQP-VK.graphicsfuzz.cov-mix-uninitialized-vector-select-only-defined-data
dEQP-VK.graphicsfuzz.cov-mod-uint-bits-float
dEQP-VK.graphicsfuzz.cov-modulo-zero-never-executed
dEQP-VK.graphicsfuzz.cov-nested-functions-loop-assign-global-array-element
dEQP-VK.graphicsfuzz.cov-nested-functions-struct-arrays-vector-lengths
dEQP-VK.graphicsfuzz.cov-nested-loop-continue-inner-copy-array-element
+dEQP-VK.graphicsfuzz.cov-nested-loop-decrease-vector-components
dEQP-VK.graphicsfuzz.cov-nested-loop-initializer-value-increased-inside
dEQP-VK.graphicsfuzz.cov-nested-loop-large-array-index-using-vector-components
dEQP-VK.graphicsfuzz.cov-nested-loop-not-greater-than-increment-array-element
dEQP-VK.graphicsfuzz.cov-nested-loops-temporary-copy-output-color-index-matrix
dEQP-VK.graphicsfuzz.cov-nested-loops-while-min-iterator-condition-always-false
dEQP-VK.graphicsfuzz.cov-nested-loops-switch-add-zero-matrix-elements
+dEQP-VK.graphicsfuzz.cov-nested-loops-while-condition-integer-range-increment-variable
dEQP-VK.graphicsfuzz.cov-nested-structs-function-set-inner-struct-field-return
dEQP-VK.graphicsfuzz.cov-nir-array-access
dEQP-VK.graphicsfuzz.cov-nir-opt-large-constants-for-clamp-vector-access
dEQP-VK.graphicsfuzz.cov-two-loops-global-loop-counter-shift-right-zero-increment-array-element
dEQP-VK.graphicsfuzz.cov-two-loops-increment-integer-global-counter-break-square-threshold
dEQP-VK.graphicsfuzz.cov-two-nested-loops-switch-case-matrix-array-increment
+dEQP-VK.graphicsfuzz.cov-uadd-carry-bit-count-index-array
dEQP-VK.graphicsfuzz.cov-ucarryadd-one-and-one
dEQP-VK.graphicsfuzz.cov-uniform-vector-copy
dEQP-VK.graphicsfuzz.cov-uniform-vector-function-argument-mod-increment-integers
dEQP-VK.graphicsfuzz.cov-double-if-true-in-loop
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-enable-bits-pixel-location-negate-not-equal-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-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-and-one-or-same-value
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-fragcoord-integer-loop-reduce-to-range
+dEQP-VK.graphicsfuzz.cov-fragcoord-loop-limit-negative-decrease-sum-first-iteration
dEQP-VK.graphicsfuzz.cov-fragcoord-multiple-conditions-function-global-loop-counter-simplified
dEQP-VK.graphicsfuzz.cov-fragcoord-multiply
dEQP-VK.graphicsfuzz.cov-function-argument-uniform-float-loop-never-return
dEQP-VK.graphicsfuzz.cov-function-clamp-min-identical-shift-right
+dEQP-VK.graphicsfuzz.cov-function-call-twice-clamp-global-variable
dEQP-VK.graphicsfuzz.cov-function-find-lsb-ivec2-one
dEQP-VK.graphicsfuzz.cov-function-fragcoord-condition-always-return
dEQP-VK.graphicsfuzz.cov-function-infinite-loop-always-return
dEQP-VK.graphicsfuzz.cov-function-loop-same-conditions-multiple-times-struct-array
dEQP-VK.graphicsfuzz.cov-function-loop-switch-increment-array-element-return
dEQP-VK.graphicsfuzz.cov-function-min-integer-large-shift-unused
+dEQP-VK.graphicsfuzz.cov-function-loop-variable-multiplied-unused
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-nested-loops-limit-uniform-xor-uniform
dEQP-VK.graphicsfuzz.cov-left-shift-right-shift-compare
dEQP-VK.graphicsfuzz.cov-liveinterval-different-dest
dEQP-VK.graphicsfuzz.cov-loop-abs-multiply-offset
+dEQP-VK.graphicsfuzz.cov-loop-array-element-bitfield-insert-undefined-never-read
dEQP-VK.graphicsfuzz.cov-loop-array-element-copy-index-clamp-sign
dEQP-VK.graphicsfuzz.cov-loop-array-index-decrement-never-negative
dEQP-VK.graphicsfuzz.cov-loop-array-struct-field-index-array-with-uniforms
dEQP-VK.graphicsfuzz.cov-loop-dfdx-constant-divide
dEQP-VK.graphicsfuzz.cov-loop-exit-conditions-sampler-struct-integer-variable
dEQP-VK.graphicsfuzz.cov-loop-divide-uninitialized-vector-min-unused
+dEQP-VK.graphicsfuzz.cov-loop-find-lsb-eight-fragcoord-never-discard
dEQP-VK.graphicsfuzz.cov-loop-findmsb-findlsb
dEQP-VK.graphicsfuzz.cov-loop-fragcoord-identical-condition
dEQP-VK.graphicsfuzz.cov-loop-global-counter-break-set-ivec-elements
dEQP-VK.graphicsfuzz.cov-loop-increment-integer-set-output-color-break
dEQP-VK.graphicsfuzz.cov-loop-increment-matrix-element-break-after-first-iteration
dEQP-VK.graphicsfuzz.cov-loop-increment-or-divide-by-loop-index
+dEQP-VK.graphicsfuzz.cov-loop-index-array-max-negative-zero
dEQP-VK.graphicsfuzz.cov-loop-integer-half-minus-one
dEQP-VK.graphicsfuzz.cov-loop-iterator-plus-one-variable-outside-index-array
dEQP-VK.graphicsfuzz.cov-loop-large-array-index-clamp-negative-value
dEQP-VK.graphicsfuzz.cov-loop-logical-xor
dEQP-VK.graphicsfuzz.cov-loop-multiple-iterator-variables-copy-array-elements
dEQP-VK.graphicsfuzz.cov-loop-read-array-index-from-array-data
+dEQP-VK.graphicsfuzz.cov-loop-max-divide-integer-by-ten
dEQP-VK.graphicsfuzz.cov-loop-replace-output-color-restore-original
dEQP-VK.graphicsfuzz.cov-loop-returns-behind-true-and-false
+dEQP-VK.graphicsfuzz.cov-loop-sampled-texel-integer-counter
dEQP-VK.graphicsfuzz.cov-loop-set-vector-components-pow-two
dEQP-VK.graphicsfuzz.cov-loop-start-from-one-switch-case-invalid-color-never-executed
dEQP-VK.graphicsfuzz.cov-loop-start-from-one-switch-case-never-executed
dEQP-VK.graphicsfuzz.cov-loop-struct-array-field-set-value-self-dependency
dEQP-VK.graphicsfuzz.cov-loop-switch-discard-never-hit
dEQP-VK.graphicsfuzz.cov-loop-two-iterators-increment-array-empty-do-while
+dEQP-VK.graphicsfuzz.cov-loop-variable-less-than-itself
dEQP-VK.graphicsfuzz.cov-loop-with-two-integers
dEQP-VK.graphicsfuzz.cov-machine-scheduler-for-if-pow
dEQP-VK.graphicsfuzz.cov-machine-basic-block-for-for-for-less-than
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-float-never-selected
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-nested-functions-loop-assign-global-array-element
dEQP-VK.graphicsfuzz.cov-nested-functions-struct-arrays-vector-lengths
dEQP-VK.graphicsfuzz.cov-nested-loop-continue-inner-copy-array-element
+dEQP-VK.graphicsfuzz.cov-nested-loop-decrease-vector-components
dEQP-VK.graphicsfuzz.cov-nested-loop-initializer-value-increased-inside
dEQP-VK.graphicsfuzz.cov-nested-loop-large-array-index-using-vector-components
dEQP-VK.graphicsfuzz.cov-nested-loop-not-greater-than-increment-array-element
dEQP-VK.graphicsfuzz.cov-nested-loops-temporary-copy-output-color-index-matrix
dEQP-VK.graphicsfuzz.cov-nested-loops-while-min-iterator-condition-always-false
dEQP-VK.graphicsfuzz.cov-nested-loops-switch-add-zero-matrix-elements
+dEQP-VK.graphicsfuzz.cov-nested-loops-while-condition-integer-range-increment-variable
dEQP-VK.graphicsfuzz.cov-nested-structs-function-set-inner-struct-field-return
dEQP-VK.graphicsfuzz.cov-nir-array-access
dEQP-VK.graphicsfuzz.cov-nir-opt-large-constants-for-clamp-vector-access
dEQP-VK.graphicsfuzz.cov-two-loops-increment-integer-global-counter-break-square-threshold
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-uadd-carry-bit-count-index-array
dEQP-VK.graphicsfuzz.cov-ucarryadd-one-and-one
dEQP-VK.graphicsfuzz.cov-undefined-inversesqrt-reflect
dEQP-VK.graphicsfuzz.cov-uniform-vector-copy
--- /dev/null
+#!amber
+
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+# A test for a coverage-gap found by the GraphicsFuzz project.
+
+# Short description: A fragment shader that covers specific LLVM code paths
+
+# The test passes because the shader always writes red.
+
+SHADER vertex variant_vertex_shader PASSTHROUGH
+
+# variant_fragment_shader is derived from the following GLSL:
+# #version 320 es
+# #define _int_1 _GLF_uniform_int_values[0]
+# #define _int_0 _GLF_uniform_int_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];
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void main()
+# {
+# // Depending on the pixel location a has either all or none bits enabled.
+# int a = (int(gl_FragCoord.x) & 1) != 0 ? 0 : ~0;
+#
+# // When a = 0:
+# // ~(a | 1) = ~1 != 1
+# //
+# // When a = ~0:
+# // ~(a | 1) = ~(~0)) = 0 != 1
+# if(~(a | _int_1) != _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: 62
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %12 %43
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %8 "a"
+ OpName %12 "gl_FragCoord"
+ OpName %29 "buf0"
+ OpMemberName %29 0 "_GLF_uniform_int_values"
+ OpName %31 ""
+ OpName %43 "_GLF_color"
+ OpDecorate %12 BuiltIn FragCoord
+ OpDecorate %28 ArrayStride 16
+ OpMemberDecorate %29 0 Offset 0
+ OpDecorate %29 Block
+ OpDecorate %31 DescriptorSet 0
+ OpDecorate %31 Binding 0
+ OpDecorate %43 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 0
+ %15 = OpTypePointer Input %9
+ %19 = OpConstant %6 1
+ %21 = OpConstant %6 0
+ %22 = OpTypeBool
+ %24 = OpConstant %6 -1
+ %27 = OpConstant %13 2
+ %28 = OpTypeArray %6 %27
+ %29 = OpTypeStruct %28
+ %30 = OpTypePointer Uniform %29
+ %31 = OpVariable %30 Uniform
+ %32 = OpTypePointer Uniform %6
+ %42 = OpTypePointer Output %10
+ %43 = OpVariable %42 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
+ %33 = OpAccessChain %32 %31 %21 %21
+ %34 = OpLoad %6 %33
+ %35 = OpBitwiseOr %6 %26 %34
+ %36 = OpNot %6 %35
+ %37 = OpAccessChain %32 %31 %21 %21
+ %38 = OpLoad %6 %37
+ %39 = OpINotEqual %22 %36 %38
+ OpSelectionMerge %41 None
+ OpBranchConditional %39 %40 %57
+ %40 = OpLabel
+ %44 = OpAccessChain %32 %31 %21 %21
+ %45 = OpLoad %6 %44
+ %46 = OpConvertSToF %9 %45
+ %47 = OpAccessChain %32 %31 %21 %19
+ %48 = OpLoad %6 %47
+ %49 = OpConvertSToF %9 %48
+ %50 = OpAccessChain %32 %31 %21 %19
+ %51 = OpLoad %6 %50
+ %52 = OpConvertSToF %9 %51
+ %53 = OpAccessChain %32 %31 %21 %21
+ %54 = OpLoad %6 %53
+ %55 = OpConvertSToF %9 %54
+ %56 = OpCompositeConstruct %10 %46 %49 %52 %55
+ OpStore %43 %56
+ OpBranch %41
+ %57 = OpLabel
+ %58 = OpAccessChain %32 %31 %21 %19
+ %59 = OpLoad %6 %58
+ %60 = OpConvertSToF %9 %59
+ %61 = OpCompositeConstruct %10 %60 %60 %60 %60
+ OpStore %43 %61
+ OpBranch %41
+ %41 = 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 32 32
+ 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 32 32
+
+EXPECT variant_framebuffer IDX 0 0 SIZE 32 32 EQ_RGBA 255 0 0 255
--- /dev/null
+#!amber
+
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+# A test for a coverage-gap found by the GraphicsFuzz project.
+
+# Short description: A fragment shader that covers specific LLVM code paths
+
+# The test passes because the shader always writes red.
+
+SHADER vertex variant_vertex_shader PASSTHROUGH
+
+# variant_fragment_shader is derived from the following GLSL:
+# #version 320 es
+#
+# #define _int_1 _GLF_uniform_int_values[0]
+# #define _int_0 _GLF_uniform_int_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];
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void main()
+# {
+# int x = int(gl_FragCoord.x);
+# // a becomes 0 or 1.
+# int a = (x & _int_1) | (x & _int_1);
+#
+# // Always selects a color from index 0 or 1.
+# _GLF_color = vec4[4](vec4(_int_1, _int_0, _int_0, _int_1), vec4(_int_1, _int_0, _int_0, _int_1), vec4(_int_0), vec4(_int_0))[a];
+# }
+SHADER fragment variant_fragment_shader SPIRV-ASM TARGET_ENV spv1.0
+; SPIR-V
+; Version: 1.0
+; Generator: Khronos Glslang Reference Front End; 10
+; Bound: 82
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %12 %37
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %8 "x"
+ OpName %12 "gl_FragCoord"
+ OpName %19 "a"
+ OpName %23 "buf0"
+ OpMemberName %23 0 "_GLF_uniform_int_values"
+ OpName %25 ""
+ OpName %37 "_GLF_color"
+ OpName %78 "indexable"
+ OpDecorate %12 BuiltIn FragCoord
+ OpDecorate %22 ArrayStride 16
+ OpMemberDecorate %23 0 Offset 0
+ OpDecorate %23 Block
+ OpDecorate %25 DescriptorSet 0
+ OpDecorate %25 Binding 0
+ OpDecorate %37 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 0
+ %15 = OpTypePointer Input %9
+ %21 = OpConstant %13 2
+ %22 = OpTypeArray %6 %21
+ %23 = OpTypeStruct %22
+ %24 = OpTypePointer Uniform %23
+ %25 = OpVariable %24 Uniform
+ %26 = OpConstant %6 0
+ %27 = OpTypePointer Uniform %6
+ %36 = OpTypePointer Output %10
+ %37 = OpVariable %36 Output
+ %41 = OpConstant %6 1
+ %73 = OpConstant %13 4
+ %74 = OpTypeArray %10 %73
+ %77 = OpTypePointer Function %74
+ %79 = OpTypePointer Function %10
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %8 = OpVariable %7 Function
+ %19 = OpVariable %7 Function
+ %78 = OpVariable %77 Function
+ %16 = OpAccessChain %15 %12 %14
+ %17 = OpLoad %9 %16
+ %18 = OpConvertFToS %6 %17
+ OpStore %8 %18
+ %20 = OpLoad %6 %8
+ %28 = OpAccessChain %27 %25 %26 %26
+ %29 = OpLoad %6 %28
+ %30 = OpBitwiseAnd %6 %20 %29
+ %31 = OpLoad %6 %8
+ %32 = OpAccessChain %27 %25 %26 %26
+ %33 = OpLoad %6 %32
+ %34 = OpBitwiseAnd %6 %31 %33
+ %35 = OpBitwiseOr %6 %30 %34
+ OpStore %19 %35
+ %38 = OpAccessChain %27 %25 %26 %26
+ %39 = OpLoad %6 %38
+ %40 = OpConvertSToF %9 %39
+ %42 = OpAccessChain %27 %25 %26 %41
+ %43 = OpLoad %6 %42
+ %44 = OpConvertSToF %9 %43
+ %45 = OpAccessChain %27 %25 %26 %41
+ %46 = OpLoad %6 %45
+ %47 = OpConvertSToF %9 %46
+ %48 = OpAccessChain %27 %25 %26 %26
+ %49 = OpLoad %6 %48
+ %50 = OpConvertSToF %9 %49
+ %51 = OpCompositeConstruct %10 %40 %44 %47 %50
+ %52 = OpAccessChain %27 %25 %26 %26
+ %53 = OpLoad %6 %52
+ %54 = OpConvertSToF %9 %53
+ %55 = OpAccessChain %27 %25 %26 %41
+ %56 = OpLoad %6 %55
+ %57 = OpConvertSToF %9 %56
+ %58 = OpAccessChain %27 %25 %26 %41
+ %59 = OpLoad %6 %58
+ %60 = OpConvertSToF %9 %59
+ %61 = OpAccessChain %27 %25 %26 %26
+ %62 = OpLoad %6 %61
+ %63 = OpConvertSToF %9 %62
+ %64 = OpCompositeConstruct %10 %54 %57 %60 %63
+ %65 = OpAccessChain %27 %25 %26 %41
+ %66 = OpLoad %6 %65
+ %67 = OpConvertSToF %9 %66
+ %68 = OpCompositeConstruct %10 %67 %67 %67 %67
+ %69 = OpAccessChain %27 %25 %26 %41
+ %70 = OpLoad %6 %69
+ %71 = OpConvertSToF %9 %70
+ %72 = OpCompositeConstruct %10 %71 %71 %71 %71
+ %75 = OpCompositeConstruct %74 %51 %64 %68 %72
+ %76 = OpLoad %6 %19
+ OpStore %78 %75
+ %80 = OpAccessChain %79 %78 %76
+ %81 = OpLoad %10 %80
+ OpStore %37 %81
+ 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 32 32
+ 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 32 32
+
+EXPECT variant_framebuffer IDX 0 0 SIZE 32 32 EQ_RGBA 255 0 0 255
--- /dev/null
+#!amber
+
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+# A test for a coverage-gap found by the GraphicsFuzz project.
+
+# Short description: A fragment shader that covers specific LLVM code paths
+
+# The test passes because the shader always writes red.
+
+SHADER vertex variant_vertex_shader PASSTHROUGH
+
+# variant_fragment_shader is derived from the following GLSL:
+# #version 320 es
+# #define _int_0 _GLF_uniform_int_values[0]
+# #define _int_1 _GLF_uniform_int_values[1]
+# #define _int_18 _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: [0, 1, 18]
+# layout(set = 0, binding = 1) uniform buf1
+# {
+# int _GLF_uniform_int_values[3];
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void main()
+# {
+# int sum = _int_1;
+#
+# // The loop limit is always 20. The first iteration decreases the sum,
+# // and all other iterations increases it.
+# for(int i = 1; i < ((gl_FragCoord.x >= _float_0_0) ? 20 : - 1); i++)
+# {
+# sum += i == _int_1 ? - _int_1 : _int_1;
+# }
+#
+# // Always true.
+# if(sum == _int_18)
+# {
+# _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: 94
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %30 %75
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %8 "sum"
+ OpName %12 "buf1"
+ OpMemberName %12 0 "_GLF_uniform_int_values"
+ OpName %14 ""
+ OpName %20 "i"
+ OpName %30 "gl_FragCoord"
+ OpName %37 "buf0"
+ OpMemberName %37 0 "_GLF_uniform_float_values"
+ OpName %39 ""
+ OpName %75 "_GLF_color"
+ OpDecorate %11 ArrayStride 16
+ OpMemberDecorate %12 0 Offset 0
+ OpDecorate %12 Block
+ OpDecorate %14 DescriptorSet 0
+ OpDecorate %14 Binding 1
+ OpDecorate %30 BuiltIn FragCoord
+ OpDecorate %36 ArrayStride 16
+ OpMemberDecorate %37 0 Offset 0
+ OpDecorate %37 Block
+ OpDecorate %39 DescriptorSet 0
+ OpDecorate %39 Binding 0
+ OpDecorate %75 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeInt 32 1
+ %7 = OpTypePointer Function %6
+ %9 = OpTypeInt 32 0
+ %10 = OpConstant %9 3
+ %11 = OpTypeArray %6 %10
+ %12 = OpTypeStruct %11
+ %13 = OpTypePointer Uniform %12
+ %14 = OpVariable %13 Uniform
+ %15 = OpConstant %6 0
+ %16 = OpConstant %6 1
+ %17 = OpTypePointer Uniform %6
+ %27 = OpTypeFloat 32
+ %28 = OpTypeVector %27 4
+ %29 = OpTypePointer Input %28
+ %30 = OpVariable %29 Input
+ %31 = OpConstant %9 0
+ %32 = OpTypePointer Input %27
+ %35 = OpConstant %9 1
+ %36 = OpTypeArray %27 %35
+ %37 = OpTypeStruct %36
+ %38 = OpTypePointer Uniform %37
+ %39 = OpVariable %38 Uniform
+ %40 = OpTypePointer Uniform %27
+ %43 = OpTypeBool
+ %45 = OpConstant %6 20
+ %46 = OpConstant %6 -1
+ %68 = OpConstant %6 2
+ %74 = OpTypePointer Output %28
+ %75 = OpVariable %74 Output
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %8 = OpVariable %7 Function
+ %20 = OpVariable %7 Function
+ %53 = OpVariable %7 Function
+ %18 = OpAccessChain %17 %14 %15 %16
+ %19 = OpLoad %6 %18
+ OpStore %8 %19
+ OpStore %20 %16
+ OpBranch %21
+ %21 = OpLabel
+ OpLoopMerge %23 %24 None
+ OpBranch %25
+ %25 = OpLabel
+ %26 = OpLoad %6 %20
+ %33 = OpAccessChain %32 %30 %31
+ %34 = OpLoad %27 %33
+ %41 = OpAccessChain %40 %39 %15 %15
+ %42 = OpLoad %27 %41
+ %44 = OpFOrdGreaterThanEqual %43 %34 %42
+ %47 = OpSelect %6 %44 %45 %46
+ %48 = OpSLessThan %43 %26 %47
+ OpBranchConditional %48 %22 %23
+ %22 = OpLabel
+ %49 = OpLoad %6 %20
+ %50 = OpAccessChain %17 %14 %15 %16
+ %51 = OpLoad %6 %50
+ %52 = OpIEqual %43 %49 %51
+ OpSelectionMerge %55 None
+ OpBranchConditional %52 %54 %59
+ %54 = OpLabel
+ %56 = OpAccessChain %17 %14 %15 %16
+ %57 = OpLoad %6 %56
+ %58 = OpSNegate %6 %57
+ OpStore %53 %58
+ OpBranch %55
+ %59 = OpLabel
+ %60 = OpAccessChain %17 %14 %15 %16
+ %61 = OpLoad %6 %60
+ OpStore %53 %61
+ OpBranch %55
+ %55 = OpLabel
+ %62 = OpLoad %6 %53
+ %63 = OpLoad %6 %8
+ %64 = OpIAdd %6 %63 %62
+ OpStore %8 %64
+ OpBranch %24
+ %24 = OpLabel
+ %65 = OpLoad %6 %20
+ %66 = OpIAdd %6 %65 %16
+ OpStore %20 %66
+ OpBranch %21
+ %23 = OpLabel
+ %67 = OpLoad %6 %8
+ %69 = OpAccessChain %17 %14 %15 %68
+ %70 = OpLoad %6 %69
+ %71 = OpIEqual %43 %67 %70
+ OpSelectionMerge %73 None
+ OpBranchConditional %71 %72 %89
+ %72 = OpLabel
+ %76 = OpAccessChain %17 %14 %15 %16
+ %77 = OpLoad %6 %76
+ %78 = OpConvertSToF %27 %77
+ %79 = OpAccessChain %17 %14 %15 %15
+ %80 = OpLoad %6 %79
+ %81 = OpConvertSToF %27 %80
+ %82 = OpAccessChain %17 %14 %15 %15
+ %83 = OpLoad %6 %82
+ %84 = OpConvertSToF %27 %83
+ %85 = OpAccessChain %17 %14 %15 %16
+ %86 = OpLoad %6 %85
+ %87 = OpConvertSToF %27 %86
+ %88 = OpCompositeConstruct %28 %78 %81 %84 %87
+ OpStore %75 %88
+ OpBranch %73
+ %89 = OpLabel
+ %90 = OpAccessChain %17 %14 %15 %15
+ %91 = OpLoad %6 %90
+ %92 = OpConvertSToF %27 %91
+ %93 = OpCompositeConstruct %28 %92 %92 %92 %92
+ OpStore %75 %93
+ OpBranch %73
+ %73 = OpLabel
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# _GLF_uniform_int_values
+BUFFER variant__GLF_uniform_int_values DATA_TYPE int32[] STD140 DATA
+ 0 1 18
+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 32 32
+ 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 32 32
+
+EXPECT variant_framebuffer IDX 0 0 SIZE 32 32 EQ_RGBA 255 0 0 255
--- /dev/null
+#!amber
+
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+# A test for a coverage-gap found by the GraphicsFuzz project.
+
+# Short description: A fragment shader that covers specific LLVM code paths
+
+# The test passes because the shader always writes red.
+
+SHADER vertex variant_vertex_shader PASSTHROUGH
+
+# variant_fragment_shader is derived from the following GLSL:
+# #version 320 es
+# #define _int_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]
+# #define _float_10_0 _GLF_uniform_float_values[2]
+#
+# 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, 10.0]
+# layout(set = 0, binding = 1) uniform buf1
+# {
+# float _GLF_uniform_float_values[3];
+# };
+#
+# const int _GLF_global_loop_bound = 10;
+# int _GLF_global_loop_count = 0;
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# float a = 1.0;
+# float b = 1.0;
+#
+# void func()
+# {
+# // Always true.
+# if(gl_FragCoord.y > _float_0_0)
+# {
+# // Always true.
+# if(gl_FragCoord.y > _float_0_0)
+# {
+# while(_GLF_global_loop_count < _GLF_global_loop_bound)
+# {
+# _GLF_global_loop_count++;
+# }
+#
+# a = 256.0;
+# }
+#
+# // c becomes b = 1.
+# float c = 256.0 - a + b;
+# // Clamps 10.0 between 0 and 1.0 resulting in 1.0.
+# b = clamp(_float_10_0, _float_0_0, c);
+# }
+# }
+#
+# void main()
+# {
+# func();
+# func();
+#
+# // Always true.
+# if(b == _float_1_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: 103
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %19 %78
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %6 "func("
+ OpName %10 "_GLF_global_loop_count"
+ OpName %14 "a"
+ OpName %16 "b"
+ OpName %19 "gl_FragCoord"
+ OpName %27 "buf1"
+ OpMemberName %27 0 "_GLF_uniform_float_values"
+ OpName %29 ""
+ OpName %57 "c"
+ OpName %78 "_GLF_color"
+ OpName %81 "buf0"
+ OpMemberName %81 0 "_GLF_uniform_int_values"
+ OpName %83 ""
+ OpDecorate %19 BuiltIn FragCoord
+ OpDecorate %26 ArrayStride 16
+ OpMemberDecorate %27 0 Offset 0
+ OpDecorate %27 Block
+ OpDecorate %29 DescriptorSet 0
+ OpDecorate %29 Binding 1
+ OpDecorate %78 Location 0
+ OpDecorate %80 ArrayStride 16
+ OpMemberDecorate %81 0 Offset 0
+ OpDecorate %81 Block
+ OpDecorate %83 DescriptorSet 0
+ OpDecorate %83 Binding 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %8 = OpTypeInt 32 1
+ %9 = OpTypePointer Private %8
+ %10 = OpVariable %9 Private
+ %11 = OpConstant %8 0
+ %12 = OpTypeFloat 32
+ %13 = OpTypePointer Private %12
+ %14 = OpVariable %13 Private
+ %15 = OpConstant %12 1
+ %16 = OpVariable %13 Private
+ %17 = OpTypeVector %12 4
+ %18 = OpTypePointer Input %17
+ %19 = OpVariable %18 Input
+ %20 = OpTypeInt 32 0
+ %21 = OpConstant %20 1
+ %22 = OpTypePointer Input %12
+ %25 = OpConstant %20 3
+ %26 = OpTypeArray %12 %25
+ %27 = OpTypeStruct %26
+ %28 = OpTypePointer Uniform %27
+ %29 = OpVariable %28 Uniform
+ %30 = OpTypePointer Uniform %12
+ %33 = OpTypeBool
+ %50 = OpConstant %8 10
+ %53 = OpConstant %8 1
+ %55 = OpConstant %12 256
+ %56 = OpTypePointer Function %12
+ %62 = OpConstant %8 2
+ %77 = OpTypePointer Output %17
+ %78 = OpVariable %77 Output
+ %79 = OpConstant %20 2
+ %80 = OpTypeArray %8 %79
+ %81 = OpTypeStruct %80
+ %82 = OpTypePointer Uniform %81
+ %83 = OpVariable %82 Uniform
+ %84 = OpTypePointer Uniform %8
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ OpStore %10 %11
+ OpStore %14 %15
+ OpStore %16 %15
+ %69 = OpFunctionCall %2 %6
+ %70 = OpFunctionCall %2 %6
+ %71 = OpLoad %12 %16
+ %72 = OpAccessChain %30 %29 %11 %53
+ %73 = OpLoad %12 %72
+ %74 = OpFOrdEqual %33 %71 %73
+ OpSelectionMerge %76 None
+ OpBranchConditional %74 %75 %98
+ %75 = OpLabel
+ %85 = OpAccessChain %84 %83 %11 %11
+ %86 = OpLoad %8 %85
+ %87 = OpConvertSToF %12 %86
+ %88 = OpAccessChain %84 %83 %11 %53
+ %89 = OpLoad %8 %88
+ %90 = OpConvertSToF %12 %89
+ %91 = OpAccessChain %84 %83 %11 %53
+ %92 = OpLoad %8 %91
+ %93 = OpConvertSToF %12 %92
+ %94 = OpAccessChain %84 %83 %11 %11
+ %95 = OpLoad %8 %94
+ %96 = OpConvertSToF %12 %95
+ %97 = OpCompositeConstruct %17 %87 %90 %93 %96
+ OpStore %78 %97
+ OpBranch %76
+ %98 = OpLabel
+ %99 = OpAccessChain %84 %83 %11 %53
+ %100 = OpLoad %8 %99
+ %101 = OpConvertSToF %12 %100
+ %102 = OpCompositeConstruct %17 %101 %101 %101 %101
+ OpStore %78 %102
+ OpBranch %76
+ %76 = OpLabel
+ OpReturn
+ OpFunctionEnd
+ %6 = OpFunction %2 None %3
+ %7 = OpLabel
+ %57 = OpVariable %56 Function
+ %23 = OpAccessChain %22 %19 %21
+ %24 = OpLoad %12 %23
+ %31 = OpAccessChain %30 %29 %11 %11
+ %32 = OpLoad %12 %31
+ %34 = OpFOrdGreaterThan %33 %24 %32
+ OpSelectionMerge %36 None
+ OpBranchConditional %34 %35 %36
+ %35 = OpLabel
+ %37 = OpAccessChain %22 %19 %21
+ %38 = OpLoad %12 %37
+ %39 = OpAccessChain %30 %29 %11 %11
+ %40 = OpLoad %12 %39
+ %41 = OpFOrdGreaterThan %33 %38 %40
+ OpSelectionMerge %43 None
+ OpBranchConditional %41 %42 %43
+ %42 = OpLabel
+ OpBranch %44
+ %44 = OpLabel
+ OpLoopMerge %46 %47 None
+ OpBranch %48
+ %48 = OpLabel
+ %49 = OpLoad %8 %10
+ %51 = OpSLessThan %33 %49 %50
+ OpBranchConditional %51 %45 %46
+ %45 = OpLabel
+ %52 = OpLoad %8 %10
+ %54 = OpIAdd %8 %52 %53
+ OpStore %10 %54
+ OpBranch %47
+ %47 = OpLabel
+ OpBranch %44
+ %46 = OpLabel
+ OpStore %14 %55
+ OpBranch %43
+ %43 = OpLabel
+ %58 = OpLoad %12 %14
+ %59 = OpFSub %12 %55 %58
+ %60 = OpLoad %12 %16
+ %61 = OpFAdd %12 %59 %60
+ OpStore %57 %61
+ %63 = OpAccessChain %30 %29 %11 %62
+ %64 = OpLoad %12 %63
+ %65 = OpAccessChain %30 %29 %11 %11
+ %66 = OpLoad %12 %65
+ %67 = OpLoad %12 %57
+ %68 = OpExtInst %12 %1 FClamp %64 %66 %67
+ OpStore %16 %68
+ OpBranch %36
+ %36 = 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 10.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 32 32
+ 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 32 32
+
+EXPECT variant_framebuffer IDX 0 0 SIZE 32 32 EQ_RGBA 255 0 0 255
--- /dev/null
+#!amber
+
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+# A test for a coverage-gap found by the GraphicsFuzz project.
+
+# Short description: A fragment shader that covers specific LLVM code paths
+
+# The test passes because the shader always writes red.
+
+# Optimized using spirv-opt with the following arguments:
+# '--copy-propagate-arrays'
+# '--eliminate-local-multi-store'
+# '--if-conversion'
+# '--if-conversion'
+# '--combine-access-chains'
+# '--redundancy-elimination'
+# '--eliminate-dead-branches'
+# '--eliminate-dead-branches'
+# '--merge-blocks'
+# 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_1 _GLF_uniform_int_values[0]
+# #define _int_0 _GLF_uniform_int_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];
+# };
+#
+# const int _GLF_global_loop_bound = 10;
+# int _GLF_global_loop_count = 0;
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# int func()
+# {
+# int a = 1;
+# int i = 1;
+#
+# // Iterated once.
+# while(_GLF_global_loop_count < _GLF_global_loop_bound)
+# {
+# _GLF_global_loop_count++;
+#
+# // Iterated nine times. 2 * a has no effect.
+# for( i = _int_1; _GLF_global_loop_count < _GLF_global_loop_bound; 2 * a)
+# {
+# _GLF_global_loop_count++;
+# i++;
+# }
+# }
+#
+# // Returns 10.
+# return i;
+# }
+#
+# void main()
+# {
+# // Always true.
+# if(func() == 10)
+# {
+# _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: 84
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %61
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %8 "func("
+ OpName %11 "_GLF_global_loop_count"
+ OpName %14 "a"
+ OpName %16 "i"
+ OpName %31 "buf0"
+ OpMemberName %31 0 "_GLF_uniform_int_values"
+ OpName %33 ""
+ OpName %61 "_GLF_color"
+ OpDecorate %30 ArrayStride 16
+ OpMemberDecorate %31 0 Offset 0
+ OpDecorate %31 Block
+ OpDecorate %33 DescriptorSet 0
+ OpDecorate %33 Binding 0
+ OpDecorate %61 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeInt 32 1
+ %7 = OpTypeFunction %6
+ %10 = OpTypePointer Private %6
+ %11 = OpVariable %10 Private
+ %12 = OpConstant %6 0
+ %13 = OpTypePointer Function %6
+ %15 = OpConstant %6 1
+ %23 = OpConstant %6 10
+ %24 = OpTypeBool
+ %28 = OpTypeInt 32 0
+ %29 = OpConstant %28 2
+ %30 = OpTypeArray %6 %29
+ %31 = OpTypeStruct %30
+ %32 = OpTypePointer Uniform %31
+ %33 = OpVariable %32 Uniform
+ %34 = OpTypePointer Uniform %6
+ %48 = OpConstant %6 2
+ %58 = OpTypeFloat 32
+ %59 = OpTypeVector %58 4
+ %60 = OpTypePointer Output %59
+ %61 = OpVariable %60 Output
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ OpStore %11 %12
+ %54 = OpFunctionCall %6 %8
+ %55 = OpIEqual %24 %54 %23
+ OpSelectionMerge %57 None
+ OpBranchConditional %55 %56 %75
+ %56 = OpLabel
+ %62 = OpAccessChain %34 %33 %12 %12
+ %63 = OpLoad %6 %62
+ %64 = OpConvertSToF %58 %63
+ %65 = OpAccessChain %34 %33 %12 %15
+ %66 = OpLoad %6 %65
+ %67 = OpConvertSToF %58 %66
+ %74 = OpCompositeConstruct %59 %64 %67 %67 %64
+ OpStore %61 %74
+ OpBranch %57
+ %75 = OpLabel
+ %76 = OpAccessChain %34 %33 %12 %15
+ %77 = OpLoad %6 %76
+ %78 = OpConvertSToF %58 %77
+ %79 = OpCompositeConstruct %59 %78 %78 %78 %78
+ OpStore %61 %79
+ OpBranch %57
+ %57 = OpLabel
+ OpReturn
+ OpFunctionEnd
+ %8 = OpFunction %6 None %7
+ %9 = OpLabel
+ %14 = OpVariable %13 Function
+ %16 = OpVariable %13 Function
+ OpStore %14 %15
+ OpStore %16 %15
+ OpBranch %17
+ %17 = OpLabel
+ %80 = OpPhi %6 %15 %9 %81 %20
+ %83 = OpPhi %6 %15 %9 %83 %20
+ %22 = OpLoad %6 %11
+ %25 = OpSLessThan %24 %22 %23
+ OpLoopMerge %19 %20 None
+ OpBranchConditional %25 %18 %19
+ %18 = OpLabel
+ %26 = OpLoad %6 %11
+ %27 = OpIAdd %6 %26 %15
+ OpStore %11 %27
+ %35 = OpAccessChain %34 %33 %12 %12
+ %36 = OpLoad %6 %35
+ OpStore %16 %36
+ OpBranch %37
+ %37 = OpLabel
+ %81 = OpPhi %6 %36 %18 %47 %38
+ %42 = OpLoad %6 %11
+ %43 = OpSLessThan %24 %42 %23
+ OpLoopMerge %39 %38 None
+ OpBranchConditional %43 %38 %39
+ %38 = OpLabel
+ %44 = OpLoad %6 %11
+ %45 = OpIAdd %6 %44 %15
+ OpStore %11 %45
+ %47 = OpIAdd %6 %81 %15
+ OpStore %16 %47
+ %50 = OpIMul %6 %48 %83
+ OpBranch %37
+ %39 = OpLabel
+ OpBranch %20
+ %20 = OpLabel
+ OpBranch %17
+ %19 = OpLabel
+ OpReturnValue %80
+ 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 32 32
+ 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 32 32
+
+EXPECT variant_framebuffer IDX 0 0 SIZE 32 32 EQ_RGBA 255 0 0 255
--- /dev/null
+#!amber
+
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+# A test for a coverage-gap found by the GraphicsFuzz project.
+
+# Short description: A fragment shader that covers specific LLVM code paths
+
+# The test passes because the shader always writes red.
+
+SHADER vertex variant_vertex_shader PASSTHROUGH
+
+# variant_fragment_shader is derived from the following GLSL:
+# #version 320 es
+#
+# #define _int_1 _GLF_uniform_int_values[0]
+# #define _int_5 _GLF_uniform_int_values[1]
+# #define _int_4 _GLF_uniform_int_values[2]
+# #define _int_0 _GLF_uniform_int_values[3]
+#
+# precision highp float;
+# precision highp int;
+#
+# // Contents of _GLF_uniform_int_values: [1, 5, 4, 0]
+# layout(set = 0, binding = 0) uniform buf0
+# {
+# int _GLF_uniform_int_values[4];
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void main()
+# {
+# int arr0[10] = int[10](_int_0, _int_0, _int_0, _int_0, _int_0, _int_0, _int_0, _int_0, _int_0, _int_0);
+# int a = _int_4;
+# int idx = _int_1;
+# // arr0[1] becomes one.
+# arr0[idx] = _int_1;
+#
+# for(int i = _int_0; i < _int_5; i++)
+# {
+# int b = _int_1;
+#
+# // Always true.
+# if(arr0[_int_1] == _int_1)
+# {
+# b++;
+# }
+#
+# // bitfieldInsert return value is undefined but also unused.
+# int arr1[10] = int[10](_int_1, _int_1, _int_1, a, _int_1, _int_1, _int_1, _int_1, _int_1, bitfieldInsert(b, _int_1, 50, _int_1));
+# int c = _int_1;
+#
+# // Always true.
+# if(arr1[c] >= _int_1)
+# {
+# a = _int_1;
+# }
+# }
+#
+# // Always true.
+# if(a == _int_1)
+# {
+# _GLF_color = vec4(_int_1, _int_0, _int_0, _int_1);
+# }
+# else
+# {
+# _GLF_color = vec4(_int_0);
+# }
+# }
+SHADER fragment variant_fragment_shader SPIRV-ASM TARGET_ENV spv1.0
+; SPIR-V
+; Version: 1.0
+; Generator: Khronos Glslang Reference Front End; 10
+; Bound: 150
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %131
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %11 "arr0"
+ OpName %14 "buf0"
+ OpMemberName %14 0 "_GLF_uniform_int_values"
+ OpName %16 ""
+ OpName %42 "a"
+ OpName %46 "idx"
+ OpName %53 "i"
+ OpName %67 "b"
+ OpName %81 "arr1"
+ OpName %107 "c"
+ OpName %131 "_GLF_color"
+ OpDecorate %13 ArrayStride 16
+ OpMemberDecorate %14 0 Offset 0
+ OpDecorate %14 Block
+ OpDecorate %16 DescriptorSet 0
+ OpDecorate %16 Binding 0
+ OpDecorate %131 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 Function %9
+ %12 = OpConstant %7 4
+ %13 = OpTypeArray %6 %12
+ %14 = OpTypeStruct %13
+ %15 = OpTypePointer Uniform %14
+ %16 = OpVariable %15 Uniform
+ %17 = OpConstant %6 0
+ %18 = OpConstant %6 3
+ %19 = OpTypePointer Uniform %6
+ %41 = OpTypePointer Function %6
+ %43 = OpConstant %6 2
+ %62 = OpConstant %6 1
+ %65 = OpTypeBool
+ %102 = OpConstant %6 50
+ %128 = OpTypeFloat 32
+ %129 = OpTypeVector %128 4
+ %130 = OpTypePointer Output %129
+ %131 = OpVariable %130 Output
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %11 = OpVariable %10 Function
+ %42 = OpVariable %41 Function
+ %46 = OpVariable %41 Function
+ %53 = OpVariable %41 Function
+ %67 = OpVariable %41 Function
+ %81 = OpVariable %10 Function
+ %107 = OpVariable %41 Function
+ %20 = OpAccessChain %19 %16 %17 %18
+ %21 = OpLoad %6 %20
+ %22 = OpAccessChain %19 %16 %17 %18
+ %23 = OpLoad %6 %22
+ %24 = OpAccessChain %19 %16 %17 %18
+ %25 = OpLoad %6 %24
+ %26 = OpAccessChain %19 %16 %17 %18
+ %27 = OpLoad %6 %26
+ %28 = OpAccessChain %19 %16 %17 %18
+ %29 = OpLoad %6 %28
+ %30 = OpAccessChain %19 %16 %17 %18
+ %31 = OpLoad %6 %30
+ %32 = OpAccessChain %19 %16 %17 %18
+ %33 = OpLoad %6 %32
+ %34 = OpAccessChain %19 %16 %17 %18
+ %35 = OpLoad %6 %34
+ %36 = OpAccessChain %19 %16 %17 %18
+ %37 = OpLoad %6 %36
+ %38 = OpAccessChain %19 %16 %17 %18
+ %39 = OpLoad %6 %38
+ %40 = OpCompositeConstruct %9 %21 %23 %25 %27 %29 %31 %33 %35 %37 %39
+ OpStore %11 %40
+ %44 = OpAccessChain %19 %16 %17 %43
+ %45 = OpLoad %6 %44
+ OpStore %42 %45
+ %47 = OpAccessChain %19 %16 %17 %17
+ %48 = OpLoad %6 %47
+ OpStore %46 %48
+ %49 = OpLoad %6 %46
+ %50 = OpAccessChain %19 %16 %17 %17
+ %51 = OpLoad %6 %50
+ %52 = OpAccessChain %41 %11 %49
+ OpStore %52 %51
+ %54 = OpAccessChain %19 %16 %17 %18
+ %55 = OpLoad %6 %54
+ OpStore %53 %55
+ OpBranch %56
+ %56 = OpLabel
+ OpLoopMerge %58 %59 None
+ OpBranch %60
+ %60 = OpLabel
+ %61 = OpLoad %6 %53
+ %63 = OpAccessChain %19 %16 %17 %62
+ %64 = OpLoad %6 %63
+ %66 = OpSLessThan %65 %61 %64
+ OpBranchConditional %66 %57 %58
+ %57 = OpLabel
+ %68 = OpAccessChain %19 %16 %17 %17
+ %69 = OpLoad %6 %68
+ OpStore %67 %69
+ %70 = OpAccessChain %19 %16 %17 %17
+ %71 = OpLoad %6 %70
+ %72 = OpAccessChain %41 %11 %71
+ %73 = OpLoad %6 %72
+ %74 = OpAccessChain %19 %16 %17 %17
+ %75 = OpLoad %6 %74
+ %76 = OpIEqual %65 %73 %75
+ OpSelectionMerge %78 None
+ OpBranchConditional %76 %77 %78
+ %77 = OpLabel
+ %79 = OpLoad %6 %67
+ %80 = OpIAdd %6 %79 %62
+ OpStore %67 %80
+ OpBranch %78
+ %78 = OpLabel
+ %82 = OpAccessChain %19 %16 %17 %17
+ %83 = OpLoad %6 %82
+ %84 = OpAccessChain %19 %16 %17 %17
+ %85 = OpLoad %6 %84
+ %86 = OpAccessChain %19 %16 %17 %17
+ %87 = OpLoad %6 %86
+ %88 = OpLoad %6 %42
+ %89 = OpAccessChain %19 %16 %17 %17
+ %90 = OpLoad %6 %89
+ %91 = OpAccessChain %19 %16 %17 %17
+ %92 = OpLoad %6 %91
+ %93 = OpAccessChain %19 %16 %17 %17
+ %94 = OpLoad %6 %93
+ %95 = OpAccessChain %19 %16 %17 %17
+ %96 = OpLoad %6 %95
+ %97 = OpAccessChain %19 %16 %17 %17
+ %98 = OpLoad %6 %97
+ %99 = OpLoad %6 %67
+ %100 = OpAccessChain %19 %16 %17 %17
+ %101 = OpLoad %6 %100
+ %103 = OpAccessChain %19 %16 %17 %17
+ %104 = OpLoad %6 %103
+ %105 = OpBitFieldInsert %6 %99 %101 %102 %104
+ %106 = OpCompositeConstruct %9 %83 %85 %87 %88 %90 %92 %94 %96 %98 %105
+ OpStore %81 %106
+ %108 = OpAccessChain %19 %16 %17 %17
+ %109 = OpLoad %6 %108
+ OpStore %107 %109
+ %110 = OpLoad %6 %107
+ %111 = OpAccessChain %41 %81 %110
+ %112 = OpLoad %6 %111
+ %113 = OpAccessChain %19 %16 %17 %17
+ %114 = OpLoad %6 %113
+ %115 = OpSGreaterThanEqual %65 %112 %114
+ OpSelectionMerge %117 None
+ OpBranchConditional %115 %116 %117
+ %116 = OpLabel
+ %118 = OpAccessChain %19 %16 %17 %17
+ %119 = OpLoad %6 %118
+ OpStore %42 %119
+ OpBranch %117
+ %117 = OpLabel
+ OpBranch %59
+ %59 = OpLabel
+ %120 = OpLoad %6 %53
+ %121 = OpIAdd %6 %120 %62
+ OpStore %53 %121
+ OpBranch %56
+ %58 = OpLabel
+ %122 = OpLoad %6 %42
+ %123 = OpAccessChain %19 %16 %17 %17
+ %124 = OpLoad %6 %123
+ %125 = OpIEqual %65 %122 %124
+ OpSelectionMerge %127 None
+ OpBranchConditional %125 %126 %145
+ %126 = OpLabel
+ %132 = OpAccessChain %19 %16 %17 %17
+ %133 = OpLoad %6 %132
+ %134 = OpConvertSToF %128 %133
+ %135 = OpAccessChain %19 %16 %17 %18
+ %136 = OpLoad %6 %135
+ %137 = OpConvertSToF %128 %136
+ %138 = OpAccessChain %19 %16 %17 %18
+ %139 = OpLoad %6 %138
+ %140 = OpConvertSToF %128 %139
+ %141 = OpAccessChain %19 %16 %17 %17
+ %142 = OpLoad %6 %141
+ %143 = OpConvertSToF %128 %142
+ %144 = OpCompositeConstruct %129 %134 %137 %140 %143
+ OpStore %131 %144
+ OpBranch %127
+ %145 = OpLabel
+ %146 = OpAccessChain %19 %16 %17 %18
+ %147 = OpLoad %6 %146
+ %148 = OpConvertSToF %128 %147
+ %149 = OpCompositeConstruct %129 %148 %148 %148 %148
+ OpStore %131 %149
+ OpBranch %127
+ %127 = OpLabel
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# _GLF_uniform_int_values
+BUFFER variant__GLF_uniform_int_values DATA_TYPE int32[] STD140 DATA
+ 1 5 4 0
+END
+
+BUFFER variant_framebuffer FORMAT B8G8R8A8_UNORM
+
+PIPELINE graphics variant_pipeline
+ ATTACH variant_vertex_shader
+ ATTACH variant_fragment_shader
+ FRAMEBUFFER_SIZE 32 32
+ 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 32 32
+
+EXPECT variant_framebuffer IDX 0 0 SIZE 32 32 EQ_RGBA 255 0 0 255
--- /dev/null
+#!amber
+
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+# A test for a coverage-gap found by the GraphicsFuzz project.
+
+# Short description: A fragment shader that covers specific LLVM code paths
+
+# The test passes because the shader always writes red.
+
+# 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]
+# #define _int_64 _GLF_uniform_int_values[2]
+#
+# precision highp float;
+# precision highp int;
+#
+# // Contents of _GLF_uniform_int_values: [0, 1, 64]
+# layout(set = 0, binding = 0) uniform buf0
+# {
+# int _GLF_uniform_int_values[3];
+# };
+#
+# // Contents of injectionSwitch: [0.0, 1.0]
+# layout(set = 0, binding = 1) uniform buf1
+# {
+# vec2 injectionSwitch;
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void main()
+# {
+# // Always false.
+# if(injectionSwitch.x > injectionSwitch.y)
+# {
+# return;
+# }
+#
+# int a = 0;
+#
+# do
+# {
+# // Iterates twice but has no effect.
+# for(int i = 1; i < findLSB(8); i++)
+# {
+# if(i < a)
+# {
+# continue;
+# }
+#
+# // Always false.
+# if(injectionSwitch.x > injectionSwitch.y)
+# {
+# }
+# else
+# {
+# // Always false.
+# if(gl_FragCoord.y < 0.0)
+# {
+# discard;
+# }
+# }
+# }
+#
+# a++;
+# }
+# while(a < 64);
+#
+# // Always true.
+# if(a == _int_64)
+# {
+# _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: 117
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %59 %89
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %8 "buf1"
+ OpMemberName %8 0 "injectionSwitch"
+ OpName %10 ""
+ OpName %59 "gl_FragCoord"
+ OpName %78 "buf0"
+ OpMemberName %78 0 "_GLF_uniform_int_values"
+ OpName %80 ""
+ OpName %89 "_GLF_color"
+ OpMemberDecorate %8 0 Offset 0
+ OpDecorate %8 Block
+ OpDecorate %10 DescriptorSet 0
+ OpDecorate %10 Binding 1
+ OpDecorate %41 RelaxedPrecision
+ OpDecorate %59 BuiltIn FragCoord
+ OpDecorate %77 ArrayStride 16
+ OpMemberDecorate %78 0 Offset 0
+ OpDecorate %78 Block
+ OpDecorate %80 DescriptorSet 0
+ OpDecorate %80 Binding 0
+ OpDecorate %89 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeFloat 32
+ %7 = OpTypeVector %6 2
+ %8 = OpTypeStruct %7
+ %9 = OpTypePointer Uniform %8
+ %10 = OpVariable %9 Uniform
+ %11 = OpTypeInt 32 1
+ %12 = OpConstant %11 0
+ %13 = OpTypeInt 32 0
+ %14 = OpConstant %13 0
+ %15 = OpTypePointer Uniform %6
+ %18 = OpConstant %13 1
+ %21 = OpTypeBool
+ %33 = OpConstant %11 1
+ %40 = OpConstant %11 8
+ %57 = OpTypeVector %6 4
+ %58 = OpTypePointer Input %57
+ %59 = OpVariable %58 Input
+ %60 = OpTypePointer Input %6
+ %63 = OpConstant %6 0
+ %73 = OpConstant %11 64
+ %76 = OpConstant %13 3
+ %77 = OpTypeArray %11 %76
+ %78 = OpTypeStruct %77
+ %79 = OpTypePointer Uniform %78
+ %80 = OpVariable %79 Uniform
+ %81 = OpConstant %11 2
+ %82 = OpTypePointer Uniform %11
+ %88 = OpTypePointer Output %57
+ %89 = OpVariable %88 Output
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ OpSelectionMerge %108 None
+ OpSwitch %14 %109
+ %109 = OpLabel
+ %16 = OpAccessChain %15 %10 %12 %14
+ %17 = OpLoad %6 %16
+ %19 = OpAccessChain %15 %10 %12 %18
+ %20 = OpLoad %6 %19
+ %22 = OpFOrdGreaterThan %21 %17 %20
+ OpSelectionMerge %24 None
+ OpBranchConditional %22 %23 %24
+ %23 = OpLabel
+ OpBranch %108
+ %24 = OpLabel
+ OpBranch %28
+ %28 = OpLabel
+ %116 = OpPhi %11 %12 %24 %71 %31
+ OpLoopMerge %30 %31 None
+ OpBranch %34
+ %34 = OpLabel
+ %114 = OpPhi %11 %33 %28 %69 %37
+ %41 = OpExtInst %11 %1 FindILsb %40
+ %42 = OpSLessThan %21 %114 %41
+ OpLoopMerge %36 %37 None
+ OpBranchConditional %42 %35 %36
+ %35 = OpLabel
+ %45 = OpSLessThan %21 %114 %116
+ OpSelectionMerge %47 None
+ OpBranchConditional %45 %46 %47
+ %46 = OpLabel
+ OpBranch %37
+ %47 = OpLabel
+ OpSelectionMerge %55 None
+ OpBranchConditional %22 %54 %56
+ %54 = OpLabel
+ OpBranch %55
+ %56 = OpLabel
+ %61 = OpAccessChain %60 %59 %18
+ %62 = OpLoad %6 %61
+ %64 = OpFOrdLessThan %21 %62 %63
+ OpSelectionMerge %66 None
+ OpBranchConditional %64 %65 %66
+ %65 = OpLabel
+ OpKill
+ %66 = OpLabel
+ OpBranch %55
+ %55 = OpLabel
+ OpBranch %37
+ %37 = OpLabel
+ %69 = OpIAdd %11 %114 %33
+ OpBranch %34
+ %36 = OpLabel
+ %71 = OpIAdd %11 %116 %33
+ OpBranch %31
+ %31 = OpLabel
+ %74 = OpSLessThan %21 %71 %73
+ OpBranchConditional %74 %28 %30
+ %30 = OpLabel
+ %83 = OpAccessChain %82 %80 %12 %81
+ %84 = OpLoad %11 %83
+ %85 = OpIEqual %21 %71 %84
+ OpSelectionMerge %87 None
+ OpBranchConditional %85 %86 %103
+ %86 = OpLabel
+ %90 = OpAccessChain %82 %80 %12 %33
+ %91 = OpLoad %11 %90
+ %92 = OpConvertSToF %6 %91
+ %93 = OpAccessChain %82 %80 %12 %12
+ %94 = OpLoad %11 %93
+ %95 = OpConvertSToF %6 %94
+ %102 = OpCompositeConstruct %57 %92 %95 %95 %92
+ OpStore %89 %102
+ OpBranch %87
+ %103 = OpLabel
+ %104 = OpAccessChain %82 %80 %12 %12
+ %105 = OpLoad %11 %104
+ %106 = OpConvertSToF %6 %105
+ %107 = OpCompositeConstruct %57 %106 %106 %106 %106
+ OpStore %89 %107
+ OpBranch %87
+ %87 = OpLabel
+ OpBranch %108
+ %108 = 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 1 64
+END
+
+BUFFER variant_framebuffer FORMAT B8G8R8A8_UNORM
+
+PIPELINE graphics variant_pipeline
+ ATTACH variant_vertex_shader
+ ATTACH variant_fragment_shader
+ FRAMEBUFFER_SIZE 32 32
+ BIND BUFFER variant_framebuffer AS color LOCATION 0
+ BIND BUFFER variant_injectionSwitch 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 32 32
+
+EXPECT variant_framebuffer IDX 0 0 SIZE 32 32 EQ_RGBA 255 0 0 255
--- /dev/null
+#!amber
+
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+# A test for a coverage-gap found by the GraphicsFuzz project.
+
+# Short description: A fragment shader that covers specific LLVM code paths
+
+# The test passes because the shader always writes red.
+
+SHADER vertex variant_vertex_shader PASSTHROUGH
+
+# variant_fragment_shader is derived from the following GLSL:
+# #version 320 es
+# #define _int_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;
+#
+# void main()
+# {
+# int idx = -87256;
+# int arr[3] = int[3](_int_0, _int_1, _int_2);
+#
+# for(int i = 0; i < 10; i++)
+# {
+# // Always true.
+# if(arr[_int_1] <= _int_1)
+# {
+# // The array index is always zero.
+# arr[max(idx++, 0)] = _int_1;
+# }
+# }
+#
+# // Always true.
+# if(arr[_int_0] == _int_1 && arr[_int_1] == _int_1 && 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: 108
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %89
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %8 "idx"
+ OpName %14 "arr"
+ OpName %16 "buf0"
+ OpMemberName %16 0 "_GLF_uniform_int_values"
+ OpName %18 ""
+ OpName %30 "i"
+ OpName %89 "_GLF_color"
+ OpDecorate %15 ArrayStride 16
+ OpMemberDecorate %16 0 Offset 0
+ OpDecorate %16 Block
+ OpDecorate %18 DescriptorSet 0
+ OpDecorate %18 Binding 0
+ OpDecorate %89 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeInt 32 1
+ %7 = OpTypePointer Function %6
+ %9 = OpConstant %6 -87256
+ %10 = OpTypeInt 32 0
+ %11 = OpConstant %10 3
+ %12 = OpTypeArray %6 %11
+ %13 = OpTypePointer Function %12
+ %15 = OpTypeArray %6 %11
+ %16 = OpTypeStruct %15
+ %17 = OpTypePointer Uniform %16
+ %18 = OpVariable %17 Uniform
+ %19 = OpConstant %6 0
+ %20 = OpConstant %6 2
+ %21 = OpTypePointer Uniform %6
+ %24 = OpConstant %6 1
+ %37 = OpConstant %6 10
+ %38 = OpTypeBool
+ %86 = OpTypeFloat 32
+ %87 = OpTypeVector %86 4
+ %88 = OpTypePointer Output %87
+ %89 = OpVariable %88 Output
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %8 = OpVariable %7 Function
+ %14 = OpVariable %13 Function
+ %30 = OpVariable %7 Function
+ OpStore %8 %9
+ %22 = OpAccessChain %21 %18 %19 %20
+ %23 = OpLoad %6 %22
+ %25 = OpAccessChain %21 %18 %19 %24
+ %26 = OpLoad %6 %25
+ %27 = OpAccessChain %21 %18 %19 %19
+ %28 = OpLoad %6 %27
+ %29 = OpCompositeConstruct %12 %23 %26 %28
+ OpStore %14 %29
+ OpStore %30 %19
+ OpBranch %31
+ %31 = OpLabel
+ OpLoopMerge %33 %34 None
+ OpBranch %35
+ %35 = OpLabel
+ %36 = OpLoad %6 %30
+ %39 = OpSLessThan %38 %36 %37
+ OpBranchConditional %39 %32 %33
+ %32 = OpLabel
+ %40 = OpAccessChain %21 %18 %19 %24
+ %41 = OpLoad %6 %40
+ %42 = OpAccessChain %7 %14 %41
+ %43 = OpLoad %6 %42
+ %44 = OpAccessChain %21 %18 %19 %24
+ %45 = OpLoad %6 %44
+ %46 = OpSLessThanEqual %38 %43 %45
+ OpSelectionMerge %48 None
+ OpBranchConditional %46 %47 %48
+ %47 = OpLabel
+ %49 = OpLoad %6 %8
+ %50 = OpIAdd %6 %49 %24
+ OpStore %8 %50
+ %51 = OpExtInst %6 %1 SMax %49 %19
+ %52 = OpAccessChain %21 %18 %19 %24
+ %53 = OpLoad %6 %52
+ %54 = OpAccessChain %7 %14 %51
+ OpStore %54 %53
+ OpBranch %48
+ %48 = OpLabel
+ OpBranch %34
+ %34 = OpLabel
+ %55 = OpLoad %6 %30
+ %56 = OpIAdd %6 %55 %24
+ OpStore %30 %56
+ OpBranch %31
+ %33 = OpLabel
+ %57 = OpAccessChain %21 %18 %19 %20
+ %58 = OpLoad %6 %57
+ %59 = OpAccessChain %7 %14 %58
+ %60 = OpLoad %6 %59
+ %61 = OpAccessChain %21 %18 %19 %24
+ %62 = OpLoad %6 %61
+ %63 = OpIEqual %38 %60 %62
+ OpSelectionMerge %65 None
+ OpBranchConditional %63 %64 %65
+ %64 = OpLabel
+ %66 = OpAccessChain %21 %18 %19 %24
+ %67 = OpLoad %6 %66
+ %68 = OpAccessChain %7 %14 %67
+ %69 = OpLoad %6 %68
+ %70 = OpAccessChain %21 %18 %19 %24
+ %71 = OpLoad %6 %70
+ %72 = OpIEqual %38 %69 %71
+ OpBranch %65
+ %65 = OpLabel
+ %73 = OpPhi %38 %63 %33 %72 %64
+ OpSelectionMerge %75 None
+ OpBranchConditional %73 %74 %75
+ %74 = OpLabel
+ %76 = OpAccessChain %21 %18 %19 %19
+ %77 = OpLoad %6 %76
+ %78 = OpAccessChain %7 %14 %77
+ %79 = OpLoad %6 %78
+ %80 = OpAccessChain %21 %18 %19 %19
+ %81 = OpLoad %6 %80
+ %82 = OpIEqual %38 %79 %81
+ OpBranch %75
+ %75 = OpLabel
+ %83 = OpPhi %38 %73 %65 %82 %74
+ OpSelectionMerge %85 None
+ OpBranchConditional %83 %84 %103
+ %84 = OpLabel
+ %90 = OpAccessChain %21 %18 %19 %24
+ %91 = OpLoad %6 %90
+ %92 = OpConvertSToF %86 %91
+ %93 = OpAccessChain %21 %18 %19 %20
+ %94 = OpLoad %6 %93
+ %95 = OpConvertSToF %86 %94
+ %96 = OpAccessChain %21 %18 %19 %20
+ %97 = OpLoad %6 %96
+ %98 = OpConvertSToF %86 %97
+ %99 = OpAccessChain %21 %18 %19 %24
+ %100 = OpLoad %6 %99
+ %101 = OpConvertSToF %86 %100
+ %102 = OpCompositeConstruct %87 %92 %95 %98 %101
+ OpStore %89 %102
+ OpBranch %85
+ %103 = OpLabel
+ %104 = OpAccessChain %21 %18 %19 %20
+ %105 = OpLoad %6 %104
+ %106 = OpConvertSToF %86 %105
+ %107 = OpCompositeConstruct %87 %106 %106 %106 %106
+ OpStore %89 %107
+ OpBranch %85
+ %85 = 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 32 32
+ 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 32 32
+
+EXPECT variant_framebuffer IDX 0 0 SIZE 32 32 EQ_RGBA 255 0 0 255
--- /dev/null
+#!amber
+
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+# A test for a coverage-gap found by the GraphicsFuzz project.
+
+# Short description: A fragment shader that covers specific LLVM code paths
+
+# The test passes because the shader always writes red.
+
+SHADER vertex variant_vertex_shader PASSTHROUGH
+
+# variant_fragment_shader is derived from the following GLSL:
+# #version 320 es
+# #define _int_3 _GLF_uniform_int_values[0]
+# #define _int_10 _GLF_uniform_int_values[1]
+# #define _int_10000 _GLF_uniform_int_values[2]
+# #define _int_0 _GLF_uniform_int_values[3]
+# #define _int_1 _GLF_uniform_int_values[4]
+#
+# precision highp float;
+# precision highp int;
+#
+# // Contents of _GLF_uniform_int_values: [3, 10, 10000, 0, 1]
+# layout(set = 0, binding = 0) uniform buf0
+# {
+# int _GLF_uniform_int_values[5];
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void main()
+# {
+# int a = _int_10000;
+#
+# // Divides a by 10 three times.
+# for(int i = _int_0; i < _int_3; i++)
+# {
+# a = max(a / _int_10, a / _int_10);
+# }
+#
+# // Always true.
+# if(a == _int_10)
+# {
+# _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" %55
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %8 "a"
+ OpName %12 "buf0"
+ OpMemberName %12 0 "_GLF_uniform_int_values"
+ OpName %14 ""
+ OpName %20 "i"
+ OpName %55 "_GLF_color"
+ OpDecorate %11 ArrayStride 16
+ OpMemberDecorate %12 0 Offset 0
+ OpDecorate %12 Block
+ OpDecorate %14 DescriptorSet 0
+ OpDecorate %14 Binding 0
+ OpDecorate %55 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeInt 32 1
+ %7 = OpTypePointer Function %6
+ %9 = OpTypeInt 32 0
+ %10 = OpConstant %9 5
+ %11 = OpTypeArray %6 %10
+ %12 = OpTypeStruct %11
+ %13 = OpTypePointer Uniform %12
+ %14 = OpVariable %13 Uniform
+ %15 = OpConstant %6 0
+ %16 = OpConstant %6 2
+ %17 = OpTypePointer Uniform %6
+ %21 = OpConstant %6 3
+ %32 = OpTypeBool
+ %35 = OpConstant %6 1
+ %52 = OpTypeFloat 32
+ %53 = OpTypeVector %52 4
+ %54 = OpTypePointer Output %53
+ %55 = OpVariable %54 Output
+ %56 = OpConstant %6 4
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %8 = OpVariable %7 Function
+ %20 = OpVariable %7 Function
+ %18 = OpAccessChain %17 %14 %15 %16
+ %19 = OpLoad %6 %18
+ OpStore %8 %19
+ %22 = OpAccessChain %17 %14 %15 %21
+ %23 = OpLoad %6 %22
+ OpStore %20 %23
+ OpBranch %24
+ %24 = OpLabel
+ OpLoopMerge %26 %27 None
+ OpBranch %28
+ %28 = OpLabel
+ %29 = OpLoad %6 %20
+ %30 = OpAccessChain %17 %14 %15 %15
+ %31 = OpLoad %6 %30
+ %33 = OpSLessThan %32 %29 %31
+ OpBranchConditional %33 %25 %26
+ %25 = OpLabel
+ %34 = OpLoad %6 %8
+ %36 = OpAccessChain %17 %14 %15 %35
+ %37 = OpLoad %6 %36
+ %38 = OpSDiv %6 %34 %37
+ %39 = OpLoad %6 %8
+ %40 = OpAccessChain %17 %14 %15 %35
+ %41 = OpLoad %6 %40
+ %42 = OpSDiv %6 %39 %41
+ %43 = OpExtInst %6 %1 SMax %38 %42
+ OpStore %8 %43
+ OpBranch %27
+ %27 = OpLabel
+ %44 = OpLoad %6 %20
+ %45 = OpIAdd %6 %44 %35
+ OpStore %20 %45
+ OpBranch %24
+ %26 = OpLabel
+ %46 = OpLoad %6 %8
+ %47 = OpAccessChain %17 %14 %15 %35
+ %48 = OpLoad %6 %47
+ %49 = OpIEqual %32 %46 %48
+ OpSelectionMerge %51 None
+ OpBranchConditional %49 %50 %70
+ %50 = OpLabel
+ %57 = OpAccessChain %17 %14 %15 %56
+ %58 = OpLoad %6 %57
+ %59 = OpConvertSToF %52 %58
+ %60 = OpAccessChain %17 %14 %15 %21
+ %61 = OpLoad %6 %60
+ %62 = OpConvertSToF %52 %61
+ %63 = OpAccessChain %17 %14 %15 %21
+ %64 = OpLoad %6 %63
+ %65 = OpConvertSToF %52 %64
+ %66 = OpAccessChain %17 %14 %15 %56
+ %67 = OpLoad %6 %66
+ %68 = OpConvertSToF %52 %67
+ %69 = OpCompositeConstruct %53 %59 %62 %65 %68
+ OpStore %55 %69
+ OpBranch %51
+ %70 = OpLabel
+ %71 = OpAccessChain %17 %14 %15 %21
+ %72 = OpLoad %6 %71
+ %73 = OpConvertSToF %52 %72
+ %74 = OpCompositeConstruct %53 %73 %73 %73 %73
+ OpStore %55 %74
+ OpBranch %51
+ %51 = OpLabel
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# _GLF_uniform_int_values
+BUFFER variant__GLF_uniform_int_values DATA_TYPE int32[] STD140 DATA
+ 3 10 10000 0 1
+END
+
+BUFFER variant_framebuffer FORMAT B8G8R8A8_UNORM
+
+PIPELINE graphics variant_pipeline
+ ATTACH variant_vertex_shader
+ ATTACH variant_fragment_shader
+ FRAMEBUFFER_SIZE 32 32
+ 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 32 32
+
+EXPECT variant_framebuffer IDX 0 0 SIZE 32 32 EQ_RGBA 255 0 0 255
--- /dev/null
+#!amber
+
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+# A test for a coverage-gap found by the GraphicsFuzz project.
+
+# Short description: A fragment shader that covers specific LLVM code paths
+
+# The test passes because the shader always writes red.
+
+SHADER vertex 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(
+ floor(gl_FragCoord.x) * (1.0 / 255.0),
+ (int(gl_FragCoord.x) ^ int(gl_FragCoord.y)) * (1.0 / 255.0),
+ floor(gl_FragCoord.y) * (1.0 / 255.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
+# #define _int_1 _GLF_uniform_int_values[0]
+# #define _int_0 _GLF_uniform_int_values[1]
+# #define _int_4 _GLF_uniform_int_values[2]
+# #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: [1, 0, 4]
+# layout(set = 0, binding = 1) uniform buf1
+# {
+# int _GLF_uniform_int_values[3];
+# };
+#
+# layout(set = 0, binding = 2) uniform sampler2D tex;
+#
+# // Contents of zero: 0.0
+# layout(set = 0, binding = 3) uniform buf3
+# {
+# float zero;
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void main()
+# {
+# int i = 0;
+# float f = texture(tex, vec2(_float_1_0)).y;
+#
+# // Sampled texel components are always <= 1. The loop will run until i is four.
+# while(f <= _float_1_0 && i < 4)
+# {
+# // Always false.
+# if(zero < _float_0_0)
+# {
+# continue;
+# }
+#
+# i++;
+# }
+#
+# // Always true.
+# if(i == _int_4)
+# {
+# _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: 94
+; 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 %8 "i"
+ OpName %12 "f"
+ OpName %16 "tex"
+ OpName %21 "buf0"
+ OpMemberName %21 0 "_GLF_uniform_float_values"
+ OpName %23 ""
+ OpName %47 "buf3"
+ OpMemberName %47 0 "zero"
+ OpName %49 ""
+ OpName %64 "buf1"
+ OpMemberName %64 0 "_GLF_uniform_int_values"
+ OpName %66 ""
+ OpName %75 "_GLF_color"
+ OpDecorate %16 RelaxedPrecision
+ OpDecorate %16 DescriptorSet 0
+ OpDecorate %16 Binding 2
+ OpDecorate %17 RelaxedPrecision
+ OpDecorate %20 ArrayStride 16
+ OpMemberDecorate %21 0 Offset 0
+ OpDecorate %21 Block
+ OpDecorate %23 DescriptorSet 0
+ OpDecorate %23 Binding 0
+ OpDecorate %28 RelaxedPrecision
+ OpDecorate %30 RelaxedPrecision
+ OpDecorate %32 RelaxedPrecision
+ OpMemberDecorate %47 0 Offset 0
+ OpDecorate %47 Block
+ OpDecorate %49 DescriptorSet 0
+ OpDecorate %49 Binding 3
+ OpDecorate %63 ArrayStride 16
+ OpMemberDecorate %64 0 Offset 0
+ OpDecorate %64 Block
+ OpDecorate %66 DescriptorSet 0
+ OpDecorate %66 Binding 1
+ OpDecorate %75 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeInt 32 1
+ %7 = OpTypePointer Function %6
+ %9 = OpConstant %6 0
+ %10 = OpTypeFloat 32
+ %11 = OpTypePointer Function %10
+ %13 = OpTypeImage %10 2D 0 0 0 1 Unknown
+ %14 = OpTypeSampledImage %13
+ %15 = OpTypePointer UniformConstant %14
+ %16 = OpVariable %15 UniformConstant
+ %18 = OpTypeInt 32 0
+ %19 = OpConstant %18 2
+ %20 = OpTypeArray %10 %19
+ %21 = OpTypeStruct %20
+ %22 = OpTypePointer Uniform %21
+ %23 = OpVariable %22 Uniform
+ %24 = OpTypePointer Uniform %10
+ %27 = OpTypeVector %10 2
+ %29 = OpTypeVector %10 4
+ %31 = OpConstant %18 1
+ %41 = OpTypeBool
+ %44 = OpConstant %6 4
+ %47 = OpTypeStruct %10
+ %48 = OpTypePointer Uniform %47
+ %49 = OpVariable %48 Uniform
+ %52 = OpConstant %6 1
+ %62 = OpConstant %18 3
+ %63 = OpTypeArray %6 %62
+ %64 = OpTypeStruct %63
+ %65 = OpTypePointer Uniform %64
+ %66 = OpVariable %65 Uniform
+ %67 = OpConstant %6 2
+ %68 = OpTypePointer Uniform %6
+ %74 = OpTypePointer Output %29
+ %75 = OpVariable %74 Output
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %8 = OpVariable %7 Function
+ %12 = OpVariable %11 Function
+ OpStore %8 %9
+ %17 = OpLoad %14 %16
+ %25 = OpAccessChain %24 %23 %9 %9
+ %26 = OpLoad %10 %25
+ %28 = OpCompositeConstruct %27 %26 %26
+ %30 = OpImageSampleImplicitLod %29 %17 %28
+ %32 = OpCompositeExtract %10 %30 1
+ OpStore %12 %32
+ OpBranch %33
+ %33 = OpLabel
+ OpLoopMerge %35 %36 None
+ OpBranch %37
+ %37 = OpLabel
+ %38 = OpLoad %10 %12
+ %39 = OpAccessChain %24 %23 %9 %9
+ %40 = OpLoad %10 %39
+ %42 = OpFOrdLessThanEqual %41 %38 %40
+ %43 = OpLoad %6 %8
+ %45 = OpSLessThan %41 %43 %44
+ %46 = OpLogicalAnd %41 %42 %45
+ OpBranchConditional %46 %34 %35
+ %34 = OpLabel
+ %50 = OpAccessChain %24 %49 %9
+ %51 = OpLoad %10 %50
+ %53 = OpAccessChain %24 %23 %9 %52
+ %54 = OpLoad %10 %53
+ %55 = OpFOrdLessThan %41 %51 %54
+ OpSelectionMerge %57 None
+ OpBranchConditional %55 %56 %57
+ %56 = OpLabel
+ OpBranch %36
+ %57 = OpLabel
+ %59 = OpLoad %6 %8
+ %60 = OpIAdd %6 %59 %52
+ OpStore %8 %60
+ OpBranch %36
+ %36 = OpLabel
+ OpBranch %33
+ %35 = OpLabel
+ %61 = OpLoad %6 %8
+ %69 = OpAccessChain %68 %66 %9 %67
+ %70 = OpLoad %6 %69
+ %71 = OpIEqual %41 %61 %70
+ OpSelectionMerge %73 None
+ OpBranchConditional %71 %72 %89
+ %72 = OpLabel
+ %76 = OpAccessChain %68 %66 %9 %9
+ %77 = OpLoad %6 %76
+ %78 = OpConvertSToF %10 %77
+ %79 = OpAccessChain %68 %66 %9 %52
+ %80 = OpLoad %6 %79
+ %81 = OpConvertSToF %10 %80
+ %82 = OpAccessChain %68 %66 %9 %52
+ %83 = OpLoad %6 %82
+ %84 = OpConvertSToF %10 %83
+ %85 = OpAccessChain %68 %66 %9 %9
+ %86 = OpLoad %6 %85
+ %87 = OpConvertSToF %10 %86
+ %88 = OpCompositeConstruct %29 %78 %81 %84 %87
+ OpStore %75 %88
+ OpBranch %73
+ %89 = OpLabel
+ %90 = OpAccessChain %68 %66 %9 %52
+ %91 = OpLoad %6 %90
+ %92 = OpConvertSToF %10 %91
+ %93 = OpCompositeConstruct %29 %92 %92 %92 %92
+ OpStore %75 %93
+ OpBranch %73
+ %73 = OpLabel
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# tex
+SAMPLER variant_tex
+
+# zero
+BUFFER variant_zero DATA_TYPE float STD140 DATA
+ 0.0
+END
+# _GLF_uniform_int_values
+BUFFER variant__GLF_uniform_int_values DATA_TYPE int32[] STD140 DATA
+ 1 0 4
+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 32 32
+ BIND BUFFER variant_framebuffer AS color LOCATION 0
+ BIND BUFFER default_texture AS combined_image_sampler SAMPLER variant_tex DESCRIPTOR_SET 0 BINDING 2
+ BIND BUFFER variant_zero AS uniform DESCRIPTOR_SET 0 BINDING 3
+ 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 32 32
+
+EXPECT variant_framebuffer IDX 0 0 SIZE 32 32 EQ_RGBA 255 0 0 255
--- /dev/null
+#!amber
+
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+# A test for a coverage-gap found by the GraphicsFuzz project.
+
+# Short description: A fragment shader that covers specific LLVM code paths
+
+# The test passes because the shader always writes red.
+
+SHADER vertex variant_vertex_shader PASSTHROUGH
+
+# variant_fragment_shader is derived from the following GLSL:
+# #version 320 es
+# #define _int_1 _GLF_uniform_int_values[0]
+# #define _int_0 _GLF_uniform_int_values[1]
+# #define _float_0_0 _GLF_uniform_float_values[0]
+#
+# precision highp float;
+# precision highp int;
+#
+# // Contents of _GLF_uniform_float_values: 0.0
+# layout(set = 0, binding = 0) uniform buf0
+# {
+# float _GLF_uniform_float_values[1];
+# };
+#
+# // Contents of _GLF_uniform_int_values: [1, 0]
+# layout(set = 0, binding = 1) uniform buf1
+# {
+# int _GLF_uniform_int_values[2];
+# };
+#
+# // Contents of one: [1.0]
+# layout(set = 0, binding = 2) uniform buf2
+# {
+# float one;
+# };
+#
+# 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;
+#
+# do
+# {
+# _GLF_global_loop_count++;
+#
+# if(one > _float_0_0)
+# {
+# // a < a is always false.
+# for(a = 0; a < a && _GLF_global_loop_count < _GLF_global_loop_bound; a++)
+# {
+# _GLF_global_loop_count ++;
+# }
+# }
+#
+# // Always false: a is 0.
+# if(a + a > _int_1)
+# {
+# break;
+# }
+# }
+# while(_GLF_global_loop_count < _GLF_global_loop_bound);
+#
+# // 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: 100
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %81
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %8 "_GLF_global_loop_count"
+ OpName %11 "a"
+ OpName %15 "buf1"
+ OpMemberName %15 0 "_GLF_uniform_int_values"
+ OpName %17 ""
+ OpName %29 "buf2"
+ OpMemberName %29 0 "one"
+ OpName %31 ""
+ OpName %37 "buf0"
+ OpMemberName %37 0 "_GLF_uniform_float_values"
+ OpName %39 ""
+ OpName %81 "_GLF_color"
+ OpDecorate %14 ArrayStride 16
+ OpMemberDecorate %15 0 Offset 0
+ OpDecorate %15 Block
+ OpDecorate %17 DescriptorSet 0
+ OpDecorate %17 Binding 1
+ OpMemberDecorate %29 0 Offset 0
+ OpDecorate %29 Block
+ OpDecorate %31 DescriptorSet 0
+ OpDecorate %31 Binding 2
+ OpDecorate %36 ArrayStride 16
+ OpMemberDecorate %37 0 Offset 0
+ OpDecorate %37 Block
+ OpDecorate %39 DescriptorSet 0
+ OpDecorate %39 Binding 0
+ OpDecorate %81 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 2
+ %14 = OpTypeArray %6 %13
+ %15 = OpTypeStruct %14
+ %16 = OpTypePointer Uniform %15
+ %17 = OpVariable %16 Uniform
+ %18 = OpTypePointer Uniform %6
+ %26 = OpConstant %6 1
+ %28 = OpTypeFloat 32
+ %29 = OpTypeStruct %28
+ %30 = OpTypePointer Uniform %29
+ %31 = OpVariable %30 Uniform
+ %32 = OpTypePointer Uniform %28
+ %35 = OpConstant %12 1
+ %36 = OpTypeArray %28 %35
+ %37 = OpTypeStruct %36
+ %38 = OpTypePointer Uniform %37
+ %39 = OpVariable %38 Uniform
+ %42 = OpTypeBool
+ %55 = OpConstant %6 10
+ %79 = OpTypeVector %28 4
+ %80 = OpTypePointer Output %79
+ %81 = OpVariable %80 Output
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %11 = 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 %22
+ %22 = OpLabel
+ %25 = OpLoad %6 %8
+ %27 = OpIAdd %6 %25 %26
+ OpStore %8 %27
+ %33 = OpAccessChain %32 %31 %9
+ %34 = OpLoad %28 %33
+ %40 = OpAccessChain %32 %39 %9 %9
+ %41 = OpLoad %28 %40
+ %43 = OpFOrdGreaterThan %42 %34 %41
+ OpSelectionMerge %45 None
+ OpBranchConditional %43 %44 %45
+ %44 = OpLabel
+ OpStore %11 %9
+ OpBranch %46
+ %46 = OpLabel
+ OpLoopMerge %48 %49 None
+ OpBranch %50
+ %50 = OpLabel
+ %51 = OpLoad %6 %11
+ %52 = OpLoad %6 %11
+ %53 = OpSLessThan %42 %51 %52
+ %54 = OpLoad %6 %8
+ %56 = OpSLessThan %42 %54 %55
+ %57 = OpLogicalAnd %42 %53 %56
+ OpBranchConditional %57 %47 %48
+ %47 = OpLabel
+ %58 = OpLoad %6 %8
+ %59 = OpIAdd %6 %58 %26
+ OpStore %8 %59
+ OpBranch %49
+ %49 = OpLabel
+ %60 = OpLoad %6 %11
+ %61 = OpIAdd %6 %60 %26
+ OpStore %11 %61
+ OpBranch %46
+ %48 = OpLabel
+ OpBranch %45
+ %45 = OpLabel
+ %62 = OpLoad %6 %11
+ %63 = OpLoad %6 %11
+ %64 = OpIAdd %6 %62 %63
+ %65 = OpAccessChain %18 %17 %9 %9
+ %66 = OpLoad %6 %65
+ %67 = OpSGreaterThan %42 %64 %66
+ OpSelectionMerge %69 None
+ OpBranchConditional %67 %68 %69
+ %68 = OpLabel
+ OpBranch %23
+ %69 = OpLabel
+ OpBranch %24
+ %24 = OpLabel
+ %71 = OpLoad %6 %8
+ %72 = OpSLessThan %42 %71 %55
+ OpBranchConditional %72 %21 %23
+ %23 = OpLabel
+ %73 = OpLoad %6 %11
+ %74 = OpAccessChain %18 %17 %9 %26
+ %75 = OpLoad %6 %74
+ %76 = OpIEqual %42 %73 %75
+ OpSelectionMerge %78 None
+ OpBranchConditional %76 %77 %95
+ %77 = OpLabel
+ %82 = OpAccessChain %18 %17 %9 %9
+ %83 = OpLoad %6 %82
+ %84 = OpConvertSToF %28 %83
+ %85 = OpAccessChain %18 %17 %9 %26
+ %86 = OpLoad %6 %85
+ %87 = OpConvertSToF %28 %86
+ %88 = OpAccessChain %18 %17 %9 %26
+ %89 = OpLoad %6 %88
+ %90 = OpConvertSToF %28 %89
+ %91 = OpAccessChain %18 %17 %9 %9
+ %92 = OpLoad %6 %91
+ %93 = OpConvertSToF %28 %92
+ %94 = OpCompositeConstruct %79 %84 %87 %90 %93
+ OpStore %81 %94
+ OpBranch %78
+ %95 = OpLabel
+ %96 = OpAccessChain %18 %17 %9 %26
+ %97 = OpLoad %6 %96
+ %98 = OpConvertSToF %28 %97
+ %99 = OpCompositeConstruct %79 %98 %98 %98 %98
+ OpStore %81 %99
+ OpBranch %78
+ %78 = OpLabel
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# one
+BUFFER variant_one DATA_TYPE float STD140 DATA
+ 1.0
+END
+# _GLF_uniform_int_values
+BUFFER variant__GLF_uniform_int_values DATA_TYPE int32[] STD140 DATA
+ 1 0
+END
+# _GLF_uniform_float_values
+BUFFER variant__GLF_uniform_float_values DATA_TYPE float[] STD140 DATA
+ 0.0
+END
+
+BUFFER variant_framebuffer FORMAT B8G8R8A8_UNORM
+
+PIPELINE graphics variant_pipeline
+ ATTACH variant_vertex_shader
+ ATTACH variant_fragment_shader
+ FRAMEBUFFER_SIZE 32 32
+ BIND BUFFER variant_framebuffer AS color LOCATION 0
+ BIND BUFFER variant_one 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 32 32
+
+EXPECT variant_framebuffer IDX 0 0 SIZE 32 32 EQ_RGBA 255 0 0 255
--- /dev/null
+#!amber
+
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+# A test for a coverage-gap found by the GraphicsFuzz project.
+
+# Short description: A fragment shader that covers specific LLVM code paths
+
+# The test passes because the shader always writes red.
+
+SHADER vertex variant_vertex_shader PASSTHROUGH
+
+# variant_fragment_shader is derived from the following GLSL:
+# #version 320 es
+# #define _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];
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void main()
+# {
+# float f;
+#
+# // f is uninitialized, but 1.0 is selected from the first vector.
+# _GLF_color = mix(vec4(1.0), vec4(f, 0.0, 0.0, 1.0), bvec4(gl_FragCoord.y < _float_0_0, true, true, true));
+# }
+SHADER fragment variant_fragment_shader SPIRV-ASM TARGET_ENV spv1.0
+; SPIR-V
+; Version: 1.0
+; Generator: Khronos Glslang Reference Front End; 10
+; Bound: 39
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %9 %18
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %9 "_GLF_color"
+ OpName %13 "f"
+ OpName %18 "gl_FragCoord"
+ OpName %25 "buf0"
+ OpMemberName %25 0 "_GLF_uniform_float_values"
+ OpName %27 ""
+ OpDecorate %9 Location 0
+ OpDecorate %18 BuiltIn FragCoord
+ OpDecorate %24 ArrayStride 16
+ OpMemberDecorate %25 0 Offset 0
+ OpDecorate %25 Block
+ OpDecorate %27 DescriptorSet 0
+ OpDecorate %27 Binding 0
+ %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 = OpConstantComposite %7 %10 %10 %10 %10
+ %12 = OpTypePointer Function %6
+ %15 = OpConstant %6 0
+ %17 = OpTypePointer Input %7
+ %18 = OpVariable %17 Input
+ %19 = OpTypeInt 32 0
+ %20 = OpConstant %19 1
+ %21 = OpTypePointer Input %6
+ %24 = OpTypeArray %6 %20
+ %25 = OpTypeStruct %24
+ %26 = OpTypePointer Uniform %25
+ %27 = OpVariable %26 Uniform
+ %28 = OpTypeInt 32 1
+ %29 = OpConstant %28 0
+ %30 = OpTypePointer Uniform %6
+ %33 = OpTypeBool
+ %35 = OpConstantTrue %33
+ %36 = OpTypeVector %33 4
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %13 = OpVariable %12 Function
+ %14 = OpLoad %6 %13
+ %16 = OpCompositeConstruct %7 %14 %15 %15 %10
+ %22 = OpAccessChain %21 %18 %20
+ %23 = OpLoad %6 %22
+ %31 = OpAccessChain %30 %27 %29 %29
+ %32 = OpLoad %6 %31
+ %34 = OpFOrdLessThan %33 %23 %32
+ %37 = OpCompositeConstruct %36 %34 %35 %35 %35
+ %38 = OpSelect %7 %37 %16 %11
+ OpStore %9 %38
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# _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 32 32
+ BIND BUFFER variant_framebuffer AS color LOCATION 0
+ 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 32 32
+
+EXPECT variant_framebuffer IDX 0 0 SIZE 32 32 EQ_RGBA 255 0 0 255
--- /dev/null
+#!amber
+
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+# A test for a coverage-gap found by the GraphicsFuzz project.
+
+# Short description: A fragment shader that covers specific LLVM code paths
+
+# The test passes because the shader always writes red.
+
+SHADER vertex variant_vertex_shader PASSTHROUGH
+
+# variant_fragment_shader is derived from the following GLSL:
+# #version 320 es
+#
+# #define _int_1 _GLF_uniform_int_values[0]
+# #define _int_2 _GLF_uniform_int_values[1]
+# #define _int_3 _GLF_uniform_int_values[2]
+# #define _int_4 _GLF_uniform_int_values[3]
+# #define _int_0 _GLF_uniform_int_values[4]
+# #define _float_0_0 _GLF_uniform_float_values[0]
+#
+# precision highp float;
+# precision highp int;
+#
+# // Contents of _GLF_uniform_int_values: [1, 2, 3, 4, 0]
+# layout(set = 0, binding = 0) uniform buf0
+# {
+# int _GLF_uniform_int_values[5];
+# };
+#
+# // Contents of _GLF_uniform_float_values: 0.0
+# layout(set = 0, binding = 1) uniform buf1
+# {
+# float _GLF_uniform_float_values[1];
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void main()
+# {
+# ivec4 v = ivec4(_int_1, _int_2, _int_3, _int_4);
+#
+# // Iterates i = 1, 0.
+# for(int i = 1; i >= 0; i--)
+# {
+# // Iterates j = 1 when i = 1, and j = 1, 0 when i = 0.
+# for(int j = (gl_FragCoord.y >= _float_0_0) ? 1 : i; j >= i; j--)
+# {
+# // v[0] gets decreased twice and v[1] once.
+# v[i]--;
+# }
+# }
+#
+# // Always true.
+# if(v == ivec4(-_int_1, _int_1, _int_3, _int_4))
+# {
+# _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: 112
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %44 %92
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %9 "v"
+ OpName %13 "buf0"
+ OpMemberName %13 0 "_GLF_uniform_int_values"
+ OpName %15 ""
+ OpName %31 "i"
+ OpName %40 "j"
+ OpName %44 "gl_FragCoord"
+ OpName %50 "buf1"
+ OpMemberName %50 0 "_GLF_uniform_float_values"
+ OpName %52 ""
+ OpName %92 "_GLF_color"
+ OpDecorate %12 ArrayStride 16
+ OpMemberDecorate %13 0 Offset 0
+ OpDecorate %13 Block
+ OpDecorate %15 DescriptorSet 0
+ OpDecorate %15 Binding 0
+ OpDecorate %44 BuiltIn FragCoord
+ OpDecorate %49 ArrayStride 16
+ OpMemberDecorate %50 0 Offset 0
+ OpDecorate %50 Block
+ OpDecorate %52 DescriptorSet 0
+ OpDecorate %52 Binding 1
+ OpDecorate %92 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeInt 32 1
+ %7 = OpTypeVector %6 4
+ %8 = OpTypePointer Function %7
+ %10 = OpTypeInt 32 0
+ %11 = OpConstant %10 5
+ %12 = OpTypeArray %6 %11
+ %13 = OpTypeStruct %12
+ %14 = OpTypePointer Uniform %13
+ %15 = OpVariable %14 Uniform
+ %16 = OpConstant %6 0
+ %17 = OpTypePointer Uniform %6
+ %20 = OpConstant %6 1
+ %23 = OpConstant %6 2
+ %26 = OpConstant %6 3
+ %30 = OpTypePointer Function %6
+ %38 = OpTypeBool
+ %41 = OpTypeFloat 32
+ %42 = OpTypeVector %41 4
+ %43 = OpTypePointer Input %42
+ %44 = OpVariable %43 Input
+ %45 = OpConstant %10 1
+ %46 = OpTypePointer Input %41
+ %49 = OpTypeArray %41 %45
+ %50 = OpTypeStruct %49
+ %51 = OpTypePointer Uniform %50
+ %52 = OpVariable %51 Uniform
+ %53 = OpTypePointer Uniform %41
+ %86 = OpTypeVector %38 4
+ %91 = OpTypePointer Output %42
+ %92 = OpVariable %91 Output
+ %96 = OpConstant %6 4
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %9 = OpVariable %8 Function
+ %31 = OpVariable %30 Function
+ %40 = OpVariable %30 Function
+ %18 = OpAccessChain %17 %15 %16 %16
+ %19 = OpLoad %6 %18
+ %21 = OpAccessChain %17 %15 %16 %20
+ %22 = OpLoad %6 %21
+ %24 = OpAccessChain %17 %15 %16 %23
+ %25 = OpLoad %6 %24
+ %27 = OpAccessChain %17 %15 %16 %26
+ %28 = OpLoad %6 %27
+ %29 = OpCompositeConstruct %7 %19 %22 %25 %28
+ OpStore %9 %29
+ OpStore %31 %20
+ OpBranch %32
+ %32 = OpLabel
+ OpLoopMerge %34 %35 None
+ OpBranch %36
+ %36 = OpLabel
+ %37 = OpLoad %6 %31
+ %39 = OpSGreaterThanEqual %38 %37 %16
+ OpBranchConditional %39 %33 %34
+ %33 = OpLabel
+ %47 = OpAccessChain %46 %44 %45
+ %48 = OpLoad %41 %47
+ %54 = OpAccessChain %53 %52 %16 %16
+ %55 = OpLoad %41 %54
+ %56 = OpFOrdGreaterThanEqual %38 %48 %55
+ %57 = OpLoad %6 %31
+ %58 = OpSelect %6 %56 %20 %57
+ OpStore %40 %58
+ OpBranch %59
+ %59 = OpLabel
+ OpLoopMerge %61 %62 None
+ OpBranch %63
+ %63 = OpLabel
+ %64 = OpLoad %6 %40
+ %65 = OpLoad %6 %31
+ %66 = OpSGreaterThanEqual %38 %64 %65
+ OpBranchConditional %66 %60 %61
+ %60 = OpLabel
+ %67 = OpLoad %6 %31
+ %68 = OpAccessChain %30 %9 %67
+ %69 = OpLoad %6 %68
+ %70 = OpISub %6 %69 %20
+ OpStore %68 %70
+ OpBranch %62
+ %62 = OpLabel
+ %71 = OpLoad %6 %40
+ %72 = OpISub %6 %71 %20
+ OpStore %40 %72
+ OpBranch %59
+ %61 = OpLabel
+ OpBranch %35
+ %35 = OpLabel
+ %73 = OpLoad %6 %31
+ %74 = OpISub %6 %73 %20
+ OpStore %31 %74
+ OpBranch %32
+ %34 = OpLabel
+ %75 = OpLoad %7 %9
+ %76 = OpAccessChain %17 %15 %16 %16
+ %77 = OpLoad %6 %76
+ %78 = OpSNegate %6 %77
+ %79 = OpAccessChain %17 %15 %16 %16
+ %80 = OpLoad %6 %79
+ %81 = OpAccessChain %17 %15 %16 %23
+ %82 = OpLoad %6 %81
+ %83 = OpAccessChain %17 %15 %16 %26
+ %84 = OpLoad %6 %83
+ %85 = OpCompositeConstruct %7 %78 %80 %82 %84
+ %87 = OpIEqual %86 %75 %85
+ %88 = OpAll %38 %87
+ OpSelectionMerge %90 None
+ OpBranchConditional %88 %89 %107
+ %89 = OpLabel
+ %93 = OpAccessChain %17 %15 %16 %16
+ %94 = OpLoad %6 %93
+ %95 = OpConvertSToF %41 %94
+ %97 = OpAccessChain %17 %15 %16 %96
+ %98 = OpLoad %6 %97
+ %99 = OpConvertSToF %41 %98
+ %100 = OpAccessChain %17 %15 %16 %96
+ %101 = OpLoad %6 %100
+ %102 = OpConvertSToF %41 %101
+ %103 = OpAccessChain %17 %15 %16 %16
+ %104 = OpLoad %6 %103
+ %105 = OpConvertSToF %41 %104
+ %106 = OpCompositeConstruct %42 %95 %99 %102 %105
+ OpStore %92 %106
+ OpBranch %90
+ %107 = OpLabel
+ %108 = OpAccessChain %17 %15 %16 %96
+ %109 = OpLoad %6 %108
+ %110 = OpConvertSToF %41 %109
+ %111 = OpCompositeConstruct %42 %110 %110 %110 %110
+ OpStore %92 %111
+ OpBranch %90
+ %90 = OpLabel
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# _GLF_uniform_float_values
+BUFFER variant__GLF_uniform_float_values DATA_TYPE float[] STD140 DATA
+ 0.0
+END
+# _GLF_uniform_int_values
+BUFFER variant__GLF_uniform_int_values DATA_TYPE int32[] STD140 DATA
+ 1 2 3 4 0
+END
+
+BUFFER variant_framebuffer FORMAT B8G8R8A8_UNORM
+
+PIPELINE graphics variant_pipeline
+ ATTACH variant_vertex_shader
+ ATTACH variant_fragment_shader
+ FRAMEBUFFER_SIZE 32 32
+ 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 32 32
+
+EXPECT variant_framebuffer IDX 0 0 SIZE 32 32 EQ_RGBA 255 0 0 255
--- /dev/null
+#!amber
+
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+# A test for a coverage-gap found by the GraphicsFuzz project.
+
+# Short description: A fragment shader that covers specific LLVM code paths
+
+# The test passes because the shader always writes red.
+
+SHADER vertex variant_vertex_shader PASSTHROUGH
+
+# variant_fragment_shader is derived from the following GLSL:
+# #version 320 es
+# #define _int_1 _GLF_uniform_int_values[0]
+# #define _int_0 _GLF_uniform_int_values[1]
+# #define _int_8 _GLF_uniform_int_values[2]
+# #define _float_0_0 _GLF_uniform_float_values[0]
+#
+# precision highp float;
+# precision highp int;
+#
+# // Contents of _GLF_uniform_int_values: [1, 0, 8]
+# layout(set = 0, binding = 0) uniform buf0
+# {
+# int _GLF_uniform_int_values[3];
+# };
+#
+# // Contents of _GLF_uniform_float_values: 0.0
+# layout(set = 0, binding = 1) uniform buf1
+# {
+# float _GLF_uniform_float_values[1];
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void main()
+# {
+# int a = _int_0;
+#
+# // Iterates i = 1, 2, 4, 8.
+# for(int i = 1; i <= 10; i *= 2)
+# {
+# for(int j = 0; j < 10; j += i)
+# {
+# int b = j + i - 1;
+# // For the last iteration of the outer loop i = 8 and j iterates values 0 and 8.
+# // The last assignment to a is 8.
+# a = j;
+#
+#
+# // The condition of the while loop below can be opened as follows:
+# // a <= b <= 1
+# // j <= j + i - 1 <= 1
+# //
+# // Because j <= 1 the values for j can be 0 and 1.
+# // Therefore j + i - 1 <= 1 gives us:
+# // 0 + i - 1 <= 1
+# // i <= 2
+# // and
+# // 1 + i - 1 <= 1
+# // i <= 1
+# //
+# // i starts at one so the condition is true when i = 1 or 2 and j = 0 or 1.
+#
+# // This condition is false during the last iteration of i = 8 and j = 8.
+# while(a <= b && b <= 1)
+# {
+# // Always false.
+# if(gl_FragCoord.x < _float_0_0)
+# {
+# discard;
+# }
+# a++;
+# }
+# }
+# }
+#
+# // Always true. The last iteration assigned i = 8 but didn't increment it in a while loop.
+# if(a == _int_8)
+# {
+# _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: 109
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %58 %90
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %8 "a"
+ OpName %12 "buf0"
+ OpMemberName %12 0 "_GLF_uniform_int_values"
+ OpName %14 ""
+ OpName %20 "i"
+ OpName %30 "j"
+ OpName %38 "b"
+ OpName %58 "gl_FragCoord"
+ OpName %65 "buf1"
+ OpMemberName %65 0 "_GLF_uniform_float_values"
+ OpName %67 ""
+ OpName %90 "_GLF_color"
+ OpDecorate %11 ArrayStride 16
+ OpMemberDecorate %12 0 Offset 0
+ OpDecorate %12 Block
+ OpDecorate %14 DescriptorSet 0
+ OpDecorate %14 Binding 0
+ OpDecorate %58 BuiltIn FragCoord
+ OpDecorate %64 ArrayStride 16
+ OpMemberDecorate %65 0 Offset 0
+ OpDecorate %65 Block
+ OpDecorate %67 DescriptorSet 0
+ OpDecorate %67 Binding 1
+ OpDecorate %90 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeInt 32 1
+ %7 = OpTypePointer Function %6
+ %9 = OpTypeInt 32 0
+ %10 = OpConstant %9 3
+ %11 = OpTypeArray %6 %10
+ %12 = OpTypeStruct %11
+ %13 = OpTypePointer Uniform %12
+ %14 = OpVariable %13 Uniform
+ %15 = OpConstant %6 0
+ %16 = OpConstant %6 1
+ %17 = OpTypePointer Uniform %6
+ %27 = OpConstant %6 10
+ %28 = OpTypeBool
+ %55 = OpTypeFloat 32
+ %56 = OpTypeVector %55 4
+ %57 = OpTypePointer Input %56
+ %58 = OpVariable %57 Input
+ %59 = OpConstant %9 0
+ %60 = OpTypePointer Input %55
+ %63 = OpConstant %9 1
+ %64 = OpTypeArray %55 %63
+ %65 = OpTypeStruct %64
+ %66 = OpTypePointer Uniform %65
+ %67 = OpVariable %66 Uniform
+ %68 = OpTypePointer Uniform %55
+ %80 = OpConstant %6 2
+ %89 = OpTypePointer Output %56
+ %90 = OpVariable %89 Output
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %8 = OpVariable %7 Function
+ %20 = OpVariable %7 Function
+ %30 = OpVariable %7 Function
+ %38 = OpVariable %7 Function
+ %18 = OpAccessChain %17 %14 %15 %16
+ %19 = OpLoad %6 %18
+ OpStore %8 %19
+ OpStore %20 %16
+ OpBranch %21
+ %21 = OpLabel
+ OpLoopMerge %23 %24 None
+ OpBranch %25
+ %25 = OpLabel
+ %26 = OpLoad %6 %20
+ %29 = OpSLessThanEqual %28 %26 %27
+ OpBranchConditional %29 %22 %23
+ %22 = OpLabel
+ OpStore %30 %15
+ OpBranch %31
+ %31 = OpLabel
+ OpLoopMerge %33 %34 None
+ OpBranch %35
+ %35 = OpLabel
+ %36 = OpLoad %6 %30
+ %37 = OpSLessThan %28 %36 %27
+ OpBranchConditional %37 %32 %33
+ %32 = OpLabel
+ %39 = OpLoad %6 %30
+ %40 = OpLoad %6 %20
+ %41 = OpIAdd %6 %39 %40
+ %42 = OpISub %6 %41 %16
+ OpStore %38 %42
+ %43 = OpLoad %6 %30
+ OpStore %8 %43
+ OpBranch %44
+ %44 = OpLabel
+ OpLoopMerge %46 %47 None
+ OpBranch %48
+ %48 = OpLabel
+ %49 = OpLoad %6 %8
+ %50 = OpLoad %6 %38
+ %51 = OpSLessThanEqual %28 %49 %50
+ %52 = OpLoad %6 %38
+ %53 = OpSLessThanEqual %28 %52 %16
+ %54 = OpLogicalAnd %28 %51 %53
+ OpBranchConditional %54 %45 %46
+ %45 = OpLabel
+ %61 = OpAccessChain %60 %58 %59
+ %62 = OpLoad %55 %61
+ %69 = OpAccessChain %68 %67 %15 %15
+ %70 = OpLoad %55 %69
+ %71 = OpFOrdLessThan %28 %62 %70
+ OpSelectionMerge %73 None
+ OpBranchConditional %71 %72 %73
+ %72 = OpLabel
+ OpKill
+ %73 = OpLabel
+ %75 = OpLoad %6 %8
+ %76 = OpIAdd %6 %75 %16
+ OpStore %8 %76
+ OpBranch %47
+ %47 = OpLabel
+ OpBranch %44
+ %46 = OpLabel
+ OpBranch %34
+ %34 = OpLabel
+ %77 = OpLoad %6 %20
+ %78 = OpLoad %6 %30
+ %79 = OpIAdd %6 %78 %77
+ OpStore %30 %79
+ OpBranch %31
+ %33 = OpLabel
+ OpBranch %24
+ %24 = OpLabel
+ %81 = OpLoad %6 %20
+ %82 = OpIMul %6 %81 %80
+ OpStore %20 %82
+ OpBranch %21
+ %23 = OpLabel
+ %83 = OpLoad %6 %8
+ %84 = OpAccessChain %17 %14 %15 %80
+ %85 = OpLoad %6 %84
+ %86 = OpIEqual %28 %83 %85
+ OpSelectionMerge %88 None
+ OpBranchConditional %86 %87 %104
+ %87 = OpLabel
+ %91 = OpAccessChain %17 %14 %15 %15
+ %92 = OpLoad %6 %91
+ %93 = OpConvertSToF %55 %92
+ %94 = OpAccessChain %17 %14 %15 %16
+ %95 = OpLoad %6 %94
+ %96 = OpConvertSToF %55 %95
+ %97 = OpAccessChain %17 %14 %15 %16
+ %98 = OpLoad %6 %97
+ %99 = OpConvertSToF %55 %98
+ %100 = OpAccessChain %17 %14 %15 %15
+ %101 = OpLoad %6 %100
+ %102 = OpConvertSToF %55 %101
+ %103 = OpCompositeConstruct %56 %93 %96 %99 %102
+ OpStore %90 %103
+ OpBranch %88
+ %104 = OpLabel
+ %105 = OpAccessChain %17 %14 %15 %16
+ %106 = OpLoad %6 %105
+ %107 = OpConvertSToF %55 %106
+ %108 = OpCompositeConstruct %56 %107 %107 %107 %107
+ OpStore %90 %108
+ OpBranch %88
+ %88 = OpLabel
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# _GLF_uniform_float_values
+BUFFER variant__GLF_uniform_float_values DATA_TYPE float[] STD140 DATA
+ 0.0
+END
+# _GLF_uniform_int_values
+BUFFER variant__GLF_uniform_int_values DATA_TYPE int32[] STD140 DATA
+ 1 0 8
+END
+
+BUFFER variant_framebuffer FORMAT B8G8R8A8_UNORM
+
+PIPELINE graphics variant_pipeline
+ ATTACH variant_vertex_shader
+ ATTACH variant_fragment_shader
+ FRAMEBUFFER_SIZE 32 32
+ 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 32 32
+
+EXPECT variant_framebuffer IDX 0 0 SIZE 32 32 EQ_RGBA 255 0 0 255
--- /dev/null
+#!amber
+
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+# A test for a coverage-gap found by the GraphicsFuzz project.
+
+# Short description: A fragment shader that covers specific LLVM code paths
+
+# The test passes because the shader always writes red.
+
+SHADER vertex variant_vertex_shader PASSTHROUGH
+
+# variant_fragment_shader is derived from the following GLSL:
+# #version 320 es
+#
+# #define _GLF_MAKE_IN_BOUNDS_INT(IDX, SZ) clamp(IDX, 0, SZ - 1)
+# #define _int_0 _GLF_uniform_int_values[0]
+# #define _int_1 _GLF_uniform_int_values[1]
+# #define _uint_1 _GLF_uniform_uint_values[0]
+# #define _uint_0 _GLF_uniform_uint_values[1]
+# #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_int_values: [0, 1]
+# layout(set = 0, binding = 0) uniform buf0 {
+# int _GLF_uniform_int_values[2];
+# };
+# // Contents of _GLF_uniform_uint_values: [1, 0]
+# layout(set = 0, binding = 1) uniform buf1 {
+# uint _GLF_uniform_uint_values[2];
+# };
+# // Contents of _GLF_uniform_float_values: [1.0, 0.0]
+# layout(set = 0, binding = 2) uniform buf2 {
+# float _GLF_uniform_float_values[2];
+# };
+# layout(location = 0) out vec4 _GLF_color;
+#
+# // Contents of zero: 0
+# layout(set = 0, binding = 3) uniform buf3 {
+# uint zero;
+# };
+# void main()
+# {
+# uint a = _uint_1;
+# // b becomes one and a becomes zero.
+# uint b = uaddCarry(zero, _uint_1, a);
+# vec4 v = vec4(_float_0_0);
+#
+# // bitCount(a) = 0.
+# v[_GLF_MAKE_IN_BOUNDS_INT(bitCount(a), 4)] = _float_1_0;
+#
+# // Always true.
+# if(a == _uint_0 && b == _uint_1 && v == vec4(_int_1, _int_0, _int_0, _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: 111
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %92
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %8 "a"
+ OpName %11 "buf1"
+ OpMemberName %11 0 "_GLF_uniform_uint_values"
+ OpName %13 ""
+ OpName %19 "b"
+ OpName %20 "buf3"
+ OpMemberName %20 0 "zero"
+ OpName %22 ""
+ OpName %27 "ResType"
+ OpName %34 "v"
+ OpName %36 "buf2"
+ OpMemberName %36 0 "_GLF_uniform_float_values"
+ OpName %38 ""
+ OpName %68 "buf0"
+ OpMemberName %68 0 "_GLF_uniform_int_values"
+ OpName %70 ""
+ OpName %92 "_GLF_color"
+ OpDecorate %10 ArrayStride 16
+ OpMemberDecorate %11 0 Offset 0
+ OpDecorate %11 Block
+ OpDecorate %13 DescriptorSet 0
+ OpDecorate %13 Binding 1
+ OpMemberDecorate %20 0 Offset 0
+ OpDecorate %20 Block
+ OpDecorate %22 DescriptorSet 0
+ OpDecorate %22 Binding 3
+ OpDecorate %35 ArrayStride 16
+ OpMemberDecorate %36 0 Offset 0
+ OpDecorate %36 Block
+ OpDecorate %38 DescriptorSet 0
+ OpDecorate %38 Binding 2
+ OpDecorate %47 RelaxedPrecision
+ OpDecorate %67 ArrayStride 16
+ OpMemberDecorate %68 0 Offset 0
+ OpDecorate %68 Block
+ OpDecorate %70 DescriptorSet 0
+ OpDecorate %70 Binding 0
+ OpDecorate %92 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeInt 32 0
+ %7 = OpTypePointer Function %6
+ %9 = OpConstant %6 2
+ %10 = OpTypeArray %6 %9
+ %11 = OpTypeStruct %10
+ %12 = OpTypePointer Uniform %11
+ %13 = OpVariable %12 Uniform
+ %14 = OpTypeInt 32 1
+ %15 = OpConstant %14 0
+ %16 = OpTypePointer Uniform %6
+ %20 = OpTypeStruct %6
+ %21 = OpTypePointer Uniform %20
+ %22 = OpVariable %21 Uniform
+ %27 = OpTypeStruct %6 %6
+ %31 = OpTypeFloat 32
+ %32 = OpTypeVector %31 4
+ %33 = OpTypePointer Function %32
+ %35 = OpTypeArray %31 %9
+ %36 = OpTypeStruct %35
+ %37 = OpTypePointer Uniform %36
+ %38 = OpVariable %37 Uniform
+ %39 = OpConstant %14 1
+ %40 = OpTypePointer Uniform %31
+ %46 = OpConstant %14 3
+ %50 = OpTypePointer Function %31
+ %52 = OpTypeBool
+ %67 = OpTypeArray %14 %9
+ %68 = OpTypeStruct %67
+ %69 = OpTypePointer Uniform %68
+ %70 = OpVariable %69 Uniform
+ %71 = OpTypePointer Uniform %14
+ %85 = OpTypeVector %52 4
+ %91 = OpTypePointer Output %32
+ %92 = OpVariable %91 Output
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %8 = OpVariable %7 Function
+ %19 = OpVariable %7 Function
+ %34 = OpVariable %33 Function
+ %17 = OpAccessChain %16 %13 %15 %15
+ %18 = OpLoad %6 %17
+ OpStore %8 %18
+ %23 = OpAccessChain %16 %22 %15
+ %24 = OpLoad %6 %23
+ %25 = OpAccessChain %16 %13 %15 %15
+ %26 = OpLoad %6 %25
+ %28 = OpIAddCarry %27 %24 %26
+ %29 = OpCompositeExtract %6 %28 1
+ OpStore %8 %29
+ %30 = OpCompositeExtract %6 %28 0
+ OpStore %19 %30
+ %41 = OpAccessChain %40 %38 %15 %39
+ %42 = OpLoad %31 %41
+ %43 = OpCompositeConstruct %32 %42 %42 %42 %42
+ OpStore %34 %43
+ %44 = OpLoad %6 %8
+ %45 = OpBitCount %14 %44
+ %47 = OpExtInst %14 %1 SClamp %45 %15 %46
+ %48 = OpAccessChain %40 %38 %15 %15
+ %49 = OpLoad %31 %48
+ %51 = OpAccessChain %50 %34 %47
+ OpStore %51 %49
+ %53 = OpLoad %6 %8
+ %54 = OpAccessChain %16 %13 %15 %39
+ %55 = OpLoad %6 %54
+ %56 = OpIEqual %52 %53 %55
+ OpSelectionMerge %58 None
+ OpBranchConditional %56 %57 %58
+ %57 = OpLabel
+ %59 = OpLoad %6 %19
+ %60 = OpAccessChain %16 %13 %15 %15
+ %61 = OpLoad %6 %60
+ %62 = OpIEqual %52 %59 %61
+ OpBranch %58
+ %58 = OpLabel
+ %63 = OpPhi %52 %56 %5 %62 %57
+ OpSelectionMerge %65 None
+ OpBranchConditional %63 %64 %65
+ %64 = OpLabel
+ %66 = OpLoad %32 %34
+ %72 = OpAccessChain %71 %70 %15 %39
+ %73 = OpLoad %14 %72
+ %74 = OpConvertSToF %31 %73
+ %75 = OpAccessChain %71 %70 %15 %15
+ %76 = OpLoad %14 %75
+ %77 = OpConvertSToF %31 %76
+ %78 = OpAccessChain %71 %70 %15 %15
+ %79 = OpLoad %14 %78
+ %80 = OpConvertSToF %31 %79
+ %81 = OpAccessChain %71 %70 %15 %15
+ %82 = OpLoad %14 %81
+ %83 = OpConvertSToF %31 %82
+ %84 = OpCompositeConstruct %32 %74 %77 %80 %83
+ %86 = OpFOrdEqual %85 %66 %84
+ %87 = OpAll %52 %86
+ OpBranch %65
+ %65 = OpLabel
+ %88 = OpPhi %52 %63 %58 %87 %64
+ OpSelectionMerge %90 None
+ OpBranchConditional %88 %89 %106
+ %89 = OpLabel
+ %93 = OpAccessChain %71 %70 %15 %39
+ %94 = OpLoad %14 %93
+ %95 = OpConvertSToF %31 %94
+ %96 = OpAccessChain %71 %70 %15 %15
+ %97 = OpLoad %14 %96
+ %98 = OpConvertSToF %31 %97
+ %99 = OpAccessChain %71 %70 %15 %15
+ %100 = OpLoad %14 %99
+ %101 = OpConvertSToF %31 %100
+ %102 = OpAccessChain %71 %70 %15 %39
+ %103 = OpLoad %14 %102
+ %104 = OpConvertSToF %31 %103
+ %105 = OpCompositeConstruct %32 %95 %98 %101 %104
+ OpStore %92 %105
+ OpBranch %90
+ %106 = OpLabel
+ %107 = OpAccessChain %71 %70 %15 %15
+ %108 = OpLoad %14 %107
+ %109 = OpConvertSToF %31 %108
+ %110 = OpCompositeConstruct %32 %109 %109 %109 %109
+ OpStore %92 %110
+ OpBranch %90
+ %90 = OpLabel
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# zero
+BUFFER variant_zero DATA_TYPE uint32 STD140 DATA
+ 0
+END
+# _GLF_uniform_float_values
+BUFFER variant__GLF_uniform_float_values DATA_TYPE float[] STD140 DATA
+ 1.0 0.0
+END
+# _GLF_uniform_uint_values
+BUFFER variant__GLF_uniform_uint_values DATA_TYPE int32[] STD140 DATA
+ 1 0
+END
+# _GLF_uniform_int_values
+BUFFER variant__GLF_uniform_int_values DATA_TYPE int32[] STD140 DATA
+ 0 1
+END
+
+BUFFER variant_framebuffer FORMAT B8G8R8A8_UNORM
+
+PIPELINE graphics variant_pipeline
+ ATTACH variant_vertex_shader
+ ATTACH variant_fragment_shader
+ FRAMEBUFFER_SIZE 32 32
+ BIND BUFFER variant_framebuffer AS color LOCATION 0
+ BIND BUFFER variant_zero AS uniform DESCRIPTOR_SET 0 BINDING 3
+ BIND BUFFER variant__GLF_uniform_float_values AS uniform DESCRIPTOR_SET 0 BINDING 2
+ BIND BUFFER variant__GLF_uniform_uint_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 32 32
+
+EXPECT variant_framebuffer IDX 0 0 SIZE 32 32 EQ_RGBA 255 0 0 255
{ "cov-double-if-true-in-loop.amber", "cov-double-if-true-in-loop", "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-enable-bits-pixel-location-negate-not-equal-one.amber", "cov-enable-bits-pixel-location-negate-not-equal-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-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-and-one-or-same-value.amber", "cov-fragcoord-and-one-or-same-value", "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-fragcoord-integer-loop-reduce-to-range.amber", "cov-fragcoord-integer-loop-reduce-to-range", "A fragment shader that covers specific LLVM code paths" },
+{ "cov-fragcoord-loop-limit-negative-decrease-sum-first-iteration.amber", "cov-fragcoord-loop-limit-negative-decrease-sum-first-iteration", "A fragment shader that covers specific LLVM code paths" },
{ "cov-fragcoord-multiple-conditions-function-global-loop-counter-simplified.amber", "cov-fragcoord-multiple-conditions-function-global-loop-counter-simplified", "A fragment shader that covers specific LLVM code paths" },
{ "cov-fragcoord-multiply.amber", "cov-fragcoord-multiply", "A fragment shader that covers specific NIR code paths" },
{ "cov-function-argument-uniform-float-loop-never-return.amber", "cov-function-argument-uniform-float-loop-never-return", "A fragment shader that covers specific LLVM code paths" },
{ "cov-function-clamp-min-identical-shift-right.amber", "cov-function-clamp-min-identical-shift-right", "A fragment shader that covers specific LLVM code paths" },
+{ "cov-function-call-twice-clamp-global-variable.amber", "cov-function-call-twice-clamp-global-variable", "A fragment shader that covers specific LLVM code paths" },
{ "cov-function-find-lsb-ivec2-one.amber", "cov-function-find-lsb-ivec2-one", "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-infinite-loop-always-return.amber", "cov-function-infinite-loop-always-return", "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-loop-switch-increment-array-element-return.amber", "cov-function-loop-switch-increment-array-element-return", "A fragment shader that covers specific LLVM code paths" },
{ "cov-function-min-integer-large-shift-unused.amber", "cov-function-min-integer-large-shift-unused", "A fragment shader that covers specific LLVM code paths" },
+{ "cov-function-loop-variable-multiplied-unused.amber", "cov-function-loop-variable-multiplied-unused", "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-nested-loops-limit-uniform-xor-uniform.amber", "cov-function-nested-loops-limit-uniform-xor-uniform", "A fragment shader that covers specific LLVM code paths" },
{ "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-liveinterval-different-dest.amber", "cov-liveinterval-different-dest", "A fragment shader that covers a specific live interval code path." },
{ "cov-loop-abs-multiply-offset.amber", "cov-loop-abs-multiply-offset", "A fragment shader that covers specific NIR code paths" },
+{ "cov-loop-array-element-bitfield-insert-undefined-never-read.amber", "cov-loop-array-element-bitfield-insert-undefined-never-read", "A fragment shader that covers specific LLVM code paths" },
{ "cov-loop-array-element-copy-index-clamp-sign.amber", "cov-loop-array-element-copy-index-clamp-sign", "A fragment shader that covers specific LLVM code paths" },
{ "cov-loop-array-index-decrement-never-negative.amber", "cov-loop-array-index-decrement-never-negative", "A fragment shader that covers specific LLVM code paths" },
{ "cov-loop-array-struct-field-index-array-with-uniforms.amber", "cov-loop-array-struct-field-index-array-with-uniforms", "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-divide-uninitialized-vector-min-unused.amber", "cov-loop-divide-uninitialized-vector-min-unused", "A fragment shader that covers specific LLVM code paths" },
+{ "cov-loop-find-lsb-eight-fragcoord-never-discard.amber", "cov-loop-find-lsb-eight-fragcoord-never-discard", "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-global-counter-break-set-ivec-elements.amber", "cov-loop-global-counter-break-set-ivec-elements", "A fragment shader that covers specific LLVM code paths" },
{ "cov-loop-increment-integer-set-output-color-break.amber", "cov-loop-increment-integer-set-output-color-break", "A fragment shader that covers specific LLVM code paths" },
{ "cov-loop-increment-matrix-element-break-after-first-iteration.amber", "cov-loop-increment-matrix-element-break-after-first-iteration", "A fragment shader that covers specific NIR code paths" },
{ "cov-loop-increment-or-divide-by-loop-index.amber", "cov-loop-increment-or-divide-by-loop-index", "A fragment shader that covers specific NIR code paths" },
+{ "cov-loop-index-array-max-negative-zero.amber", "cov-loop-index-array-max-negative-zero", "A fragment shader that covers specific LLVM code paths" },
{ "cov-loop-integer-half-minus-one.amber", "cov-loop-integer-half-minus-one", "A fragment shader that covers specific LLVM code paths" },
{ "cov-loop-iterator-plus-one-variable-outside-index-array.amber", "cov-loop-iterator-plus-one-variable-outside-index-array", "A fragment shader that covers specific LLVM code paths" },
{ "cov-loop-large-array-index-clamp-negative-value.amber", "cov-loop-large-array-index-clamp-negative-value", "A fragment shader that covers specific LLVM code paths" },
{ "cov-loop-logical-xor.amber", "cov-loop-logical-xor", "A fragment shader that covers specific NIR code paths" },
{ "cov-loop-multiple-iterator-variables-copy-array-elements.amber", "cov-loop-multiple-iterator-variables-copy-array-elements", "A fragment shader that covers specific LLVM code paths" },
{ "cov-loop-read-array-index-from-array-data.amber", "cov-loop-read-array-index-from-array-data", "A fragment shader that covers specific LLVM code paths" },
+{ "cov-loop-max-divide-integer-by-ten.amber", "cov-loop-max-divide-integer-by-ten", "A fragment shader that covers specific LLVM code paths" },
{ "cov-loop-replace-output-color-restore-original.amber", "cov-loop-replace-output-color-restore-original", "A fragment shader that covers specific LLVM code paths" },
{ "cov-loop-returns-behind-true-and-false.amber", "cov-loop-returns-behind-true-and-false", "A fragment shader that covers specific NIR code paths" },
+{ "cov-loop-sampled-texel-integer-counter.amber", "cov-loop-sampled-texel-integer-counter", "A fragment shader that covers specific LLVM code paths" },
{ "cov-loop-set-vector-components-pow-two.amber", "cov-loop-set-vector-components-pow-two", "A fragment shader that covers specific LLVM code paths" },
{ "cov-loop-start-from-one-switch-case-invalid-color-never-executed.amber", "cov-loop-start-from-one-switch-case-invalid-color-never-executed", "A fragment shader that covers specific LLVM code paths" },
{ "cov-loop-start-from-one-switch-case-never-executed.amber", "cov-loop-start-from-one-switch-case-never-executed", "A fragment shader that covers specific LLVM code paths" },
{ "cov-loop-struct-array-field-set-value-self-dependency.amber", "cov-loop-struct-array-field-set-value-self-dependency", "A fragment shader that covers specific LLVM code paths" },
{ "cov-loop-switch-discard-never-hit.amber", "cov-loop-switch-discard-never-hit", "A fragment shader that covers specific LLVM code paths" },
{ "cov-loop-two-iterators-increment-array-empty-do-while.amber", "cov-loop-two-iterators-increment-array-empty-do-while", "A fragment shader that covers specific LLVM code paths" },
+{ "cov-loop-variable-less-than-itself.amber", "cov-loop-variable-less-than-itself", "A fragment shader that covers specific LLVM code paths" },
{ "cov-loop-with-two-integers.amber", "cov-loop-with-two-integers", "A fragment shader that covers specific NIR code paths" },
{ "cov-machine-scheduler-for-if-pow.amber", "cov-machine-scheduler-for-if-pow", "A fragment shader that covers a specific machine scheduler path" },
{ "cov-machine-basic-block-for-for-for-less-than.amber", "cov-machine-basic-block-for-for-for-less-than", "A fragment shader that covers a specific machine basic block 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-float-never-selected.amber", "cov-mix-uninitialized-float-never-selected", "A fragment shader that covers specific LLVM 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-nested-functions-loop-assign-global-array-element.amber", "cov-nested-functions-loop-assign-global-array-element", "A fragment shader that covers specific LLVM code paths" },
{ "cov-nested-functions-struct-arrays-vector-lengths.amber", "cov-nested-functions-struct-arrays-vector-lengths", "A fragment shader that covers specific LLVM code paths" },
{ "cov-nested-loop-continue-inner-copy-array-element.amber", "cov-nested-loop-continue-inner-copy-array-element", "A fragment shader that covers specific LLVM code paths" },
+{ "cov-nested-loop-decrease-vector-components.amber", "cov-nested-loop-decrease-vector-components", "A fragment shader that covers specific LLVM code paths" },
{ "cov-nested-loop-initializer-value-increased-inside.amber", "cov-nested-loop-initializer-value-increased-inside", "A fragment shader that covers specific LLVM code paths" },
{ "cov-nested-loop-large-array-index-using-vector-components.amber", "cov-nested-loop-large-array-index-using-vector-components", "A fragment shader that covers specific LLVM code paths" },
{ "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-loops-temporary-copy-output-color-index-matrix.amber", "cov-nested-loops-temporary-copy-output-color-index-matrix", "A fragment shader that covers specific LLVM code paths" },
{ "cov-nested-loops-while-min-iterator-condition-always-false.amber", "cov-nested-loops-while-min-iterator-condition-always-false", "A fragment shader that covers specific LLVM code paths" },
{ "cov-nested-loops-switch-add-zero-matrix-elements.amber", "cov-nested-loops-switch-add-zero-matrix-elements", "A fragment shader that covers specific LLVM code paths" },
+{ "cov-nested-loops-while-condition-integer-range-increment-variable.amber", "cov-nested-loops-while-condition-integer-range-increment-variable", "A fragment shader that covers specific LLVM code paths" },
{ "cov-nested-structs-function-set-inner-struct-field-return.amber", "cov-nested-structs-function-set-inner-struct-field-return", "A fragment shader that covers specific LLVM 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-two-loops-increment-integer-global-counter-break-square-threshold.amber", "cov-two-loops-increment-integer-global-counter-break-square-threshold", "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-uadd-carry-bit-count-index-array.amber", "cov-uadd-carry-bit-count-index-array", "A fragment shader that covers specific LLVM code paths" },
{ "cov-ucarryadd-one-and-one.amber", "cov-ucarryadd-one-and-one", "A fragment shader that covers specific LLVM code paths" },
{ "cov-undefined-inversesqrt-reflect.amber", "cov-undefined-inversesqrt-reflect", "A fragment shader that covers a specific APFloat code path" },
{ "cov-uniform-vector-copy.amber", "cov-uniform-vector-copy", "A fragment shader that covers specific NIR code paths" },
dEQP-VK.graphicsfuzz.cov-double-if-true-in-loop
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-enable-bits-pixel-location-negate-not-equal-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-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-and-one-or-same-value
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-fragcoord-integer-loop-reduce-to-range
+dEQP-VK.graphicsfuzz.cov-fragcoord-loop-limit-negative-decrease-sum-first-iteration
dEQP-VK.graphicsfuzz.cov-fragcoord-multiple-conditions-function-global-loop-counter-simplified
dEQP-VK.graphicsfuzz.cov-fragcoord-multiply
dEQP-VK.graphicsfuzz.cov-function-argument-uniform-float-loop-never-return
dEQP-VK.graphicsfuzz.cov-function-clamp-min-identical-shift-right
+dEQP-VK.graphicsfuzz.cov-function-call-twice-clamp-global-variable
dEQP-VK.graphicsfuzz.cov-function-find-lsb-ivec2-one
dEQP-VK.graphicsfuzz.cov-function-fragcoord-condition-always-return
dEQP-VK.graphicsfuzz.cov-function-infinite-loop-always-return
dEQP-VK.graphicsfuzz.cov-function-loop-same-conditions-multiple-times-struct-array
dEQP-VK.graphicsfuzz.cov-function-loop-switch-increment-array-element-return
dEQP-VK.graphicsfuzz.cov-function-min-integer-large-shift-unused
+dEQP-VK.graphicsfuzz.cov-function-loop-variable-multiplied-unused
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-nested-loops-limit-uniform-xor-uniform
dEQP-VK.graphicsfuzz.cov-left-shift-right-shift-compare
dEQP-VK.graphicsfuzz.cov-liveinterval-different-dest
dEQP-VK.graphicsfuzz.cov-loop-abs-multiply-offset
+dEQP-VK.graphicsfuzz.cov-loop-array-element-bitfield-insert-undefined-never-read
dEQP-VK.graphicsfuzz.cov-loop-array-element-copy-index-clamp-sign
dEQP-VK.graphicsfuzz.cov-loop-array-index-decrement-never-negative
dEQP-VK.graphicsfuzz.cov-loop-array-struct-field-index-array-with-uniforms
dEQP-VK.graphicsfuzz.cov-loop-dfdx-constant-divide
dEQP-VK.graphicsfuzz.cov-loop-exit-conditions-sampler-struct-integer-variable
dEQP-VK.graphicsfuzz.cov-loop-divide-uninitialized-vector-min-unused
+dEQP-VK.graphicsfuzz.cov-loop-find-lsb-eight-fragcoord-never-discard
dEQP-VK.graphicsfuzz.cov-loop-findmsb-findlsb
dEQP-VK.graphicsfuzz.cov-loop-fragcoord-identical-condition
dEQP-VK.graphicsfuzz.cov-loop-global-counter-break-set-ivec-elements
dEQP-VK.graphicsfuzz.cov-loop-increment-integer-set-output-color-break
dEQP-VK.graphicsfuzz.cov-loop-increment-matrix-element-break-after-first-iteration
dEQP-VK.graphicsfuzz.cov-loop-increment-or-divide-by-loop-index
+dEQP-VK.graphicsfuzz.cov-loop-index-array-max-negative-zero
dEQP-VK.graphicsfuzz.cov-loop-integer-half-minus-one
dEQP-VK.graphicsfuzz.cov-loop-iterator-plus-one-variable-outside-index-array
dEQP-VK.graphicsfuzz.cov-loop-large-array-index-clamp-negative-value
dEQP-VK.graphicsfuzz.cov-loop-logical-xor
dEQP-VK.graphicsfuzz.cov-loop-multiple-iterator-variables-copy-array-elements
dEQP-VK.graphicsfuzz.cov-loop-read-array-index-from-array-data
+dEQP-VK.graphicsfuzz.cov-loop-max-divide-integer-by-ten
dEQP-VK.graphicsfuzz.cov-loop-replace-output-color-restore-original
dEQP-VK.graphicsfuzz.cov-loop-returns-behind-true-and-false
+dEQP-VK.graphicsfuzz.cov-loop-sampled-texel-integer-counter
dEQP-VK.graphicsfuzz.cov-loop-set-vector-components-pow-two
dEQP-VK.graphicsfuzz.cov-loop-start-from-one-switch-case-invalid-color-never-executed
dEQP-VK.graphicsfuzz.cov-loop-start-from-one-switch-case-never-executed
dEQP-VK.graphicsfuzz.cov-loop-struct-array-field-set-value-self-dependency
dEQP-VK.graphicsfuzz.cov-loop-switch-discard-never-hit
dEQP-VK.graphicsfuzz.cov-loop-two-iterators-increment-array-empty-do-while
+dEQP-VK.graphicsfuzz.cov-loop-variable-less-than-itself
dEQP-VK.graphicsfuzz.cov-loop-with-two-integers
dEQP-VK.graphicsfuzz.cov-machine-scheduler-for-if-pow
dEQP-VK.graphicsfuzz.cov-machine-basic-block-for-for-for-less-than
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-float-never-selected
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-nested-functions-loop-assign-global-array-element
dEQP-VK.graphicsfuzz.cov-nested-functions-struct-arrays-vector-lengths
dEQP-VK.graphicsfuzz.cov-nested-loop-continue-inner-copy-array-element
+dEQP-VK.graphicsfuzz.cov-nested-loop-decrease-vector-components
dEQP-VK.graphicsfuzz.cov-nested-loop-initializer-value-increased-inside
dEQP-VK.graphicsfuzz.cov-nested-loop-large-array-index-using-vector-components
dEQP-VK.graphicsfuzz.cov-nested-loop-not-greater-than-increment-array-element
dEQP-VK.graphicsfuzz.cov-nested-loops-temporary-copy-output-color-index-matrix
dEQP-VK.graphicsfuzz.cov-nested-loops-while-min-iterator-condition-always-false
dEQP-VK.graphicsfuzz.cov-nested-loops-switch-add-zero-matrix-elements
+dEQP-VK.graphicsfuzz.cov-nested-loops-while-condition-integer-range-increment-variable
dEQP-VK.graphicsfuzz.cov-nested-structs-function-set-inner-struct-field-return
dEQP-VK.graphicsfuzz.cov-nir-array-access
dEQP-VK.graphicsfuzz.cov-nir-opt-large-constants-for-clamp-vector-access
dEQP-VK.graphicsfuzz.cov-two-loops-increment-integer-global-counter-break-square-threshold
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-uadd-carry-bit-count-index-array
dEQP-VK.graphicsfuzz.cov-ucarryadd-one-and-one
dEQP-VK.graphicsfuzz.cov-undefined-inversesqrt-reflect
dEQP-VK.graphicsfuzz.cov-uniform-vector-copy
projects / platform / upstream / VK-GL-CTS.git / commitdiff