This commit adds a batch of GraphicsFuzz coverage tests.
Components: Vulkan
New Tests:
dEQP-VK.graphicsfuzz.cov-array-cast-bool-float-div-by-zero-no-effect
dEQP-VK.graphicsfuzz.cov-array-set-element-condition-negative-modulus
dEQP-VK.graphicsfuzz.cov-clamp-min-bitcount-uniform
dEQP-VK.graphicsfuzz.cov-condition-clamp-min-from-uniform-never-larger
dEQP-VK.graphicsfuzz.cov-function-clamp-min-identical-shift-right
dEQP-VK.graphicsfuzz.cov-function-infinite-loop-always-return
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-loop-decrease-integer-never-break
dEQP-VK.graphicsfuzz.cov-loop-global-counter-break-set-ivec-elements
dEQP-VK.graphicsfuzz.cov-nested-loops-inner-loop-min-copy-array-elements
dEQP-VK.graphicsfuzz.cov-nested-loops-return-inside-while-never-executed
dEQP-VK.graphicsfuzz.cov-nested-loops-substract-matrix-element-change-float
dEQP-VK.graphicsfuzz.cov-nested-loops-switch-case-fallthrough-increment-array-element
dEQP-VK.graphicsfuzz.cov-two-loops-increment-integer-global-counter-break-square-threshold
Change-Id: Id55832113b3ebcd48fc4e6a2a8e0502725766944
dEQP-VK.graphicsfuzz.cov-and-even-numbers-from-fragcoord
dEQP-VK.graphicsfuzz.cov-apfloat-module-small-number
dEQP-VK.graphicsfuzz.cov-array-accesses-clamp
+dEQP-VK.graphicsfuzz.cov-array-cast-bool-float-div-by-zero-no-effect
dEQP-VK.graphicsfuzz.cov-array-copies-loops-with-limiters
+dEQP-VK.graphicsfuzz.cov-array-set-element-condition-negative-modulus
dEQP-VK.graphicsfuzz.cov-atan-trunc-vec4
dEQP-VK.graphicsfuzz.cov-bitcount
dEQP-VK.graphicsfuzz.cov-bitfieldreverse-loop-limit-underflow
dEQP-VK.graphicsfuzz.cov-cast-float-to-int-and-back
dEQP-VK.graphicsfuzz.cov-clamp-loop-limit-increment-float-array
dEQP-VK.graphicsfuzz.cov-clamp-lower-limit-from-always-false
+dEQP-VK.graphicsfuzz.cov-clamp-min-bitcount-uniform
dEQP-VK.graphicsfuzz.cov-clamp-vector-component-condition-using-matrix
dEQP-VK.graphicsfuzz.cov-clamp-vector-element-ceil-negative
dEQP-VK.graphicsfuzz.cov-clamp-vector-variable-negative-offset
dEQP-VK.graphicsfuzz.cov-clear-yz-inside-condition
dEQP-VK.graphicsfuzz.cov-color-output-undefined-in-unexecuted-branch
dEQP-VK.graphicsfuzz.cov-condition-bitfield-extract-integer
+dEQP-VK.graphicsfuzz.cov-condition-clamp-min-from-uniform-never-larger
dEQP-VK.graphicsfuzz.cov-condition-increment-zero-to-one-divide-by-two
dEQP-VK.graphicsfuzz.cov-condition-loop-index-bitwise-not
dEQP-VK.graphicsfuzz.cov-condition-matrix-determinant-uniform
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-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-large-array-max-clamp
dEQP-VK.graphicsfuzz.cov-function-loop-condition-uniform-shift-right
dEQP-VK.graphicsfuzz.cov-function-loop-condition-variable-less-than-min-itself
dEQP-VK.graphicsfuzz.cov-function-loop-copy-array-elements-based-on-arguments
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-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-loop-condition-double-negate
dEQP-VK.graphicsfuzz.cov-loop-condition-filter-some-iterations-never-discard
dEQP-VK.graphicsfuzz.cov-loop-condition-logical-or-never-iterated
+dEQP-VK.graphicsfuzz.cov-loop-decrease-integer-never-break
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-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-array-elements-clamp-index
dEQP-VK.graphicsfuzz.cov-loop-increment-integer-findmsb-minus-uniform
dEQP-VK.graphicsfuzz.cov-nested-loops-global-loop-counter-output-color-from-backup
dEQP-VK.graphicsfuzz.cov-nested-loops-identical-iterator-names-multiply-divide
dEQP-VK.graphicsfuzz.cov-nested-loops-increase-integer-dot-product
+dEQP-VK.graphicsfuzz.cov-nested-loops-inner-loop-min-copy-array-elements
dEQP-VK.graphicsfuzz.cov-nested-loops-redundant-condition
+dEQP-VK.graphicsfuzz.cov-nested-loops-return-inside-while-never-executed
dEQP-VK.graphicsfuzz.cov-nested-loops-sample-opposite-corners
dEQP-VK.graphicsfuzz.cov-nested-loops-set-struct-data-verify-in-function
+dEQP-VK.graphicsfuzz.cov-nested-loops-substract-matrix-element-change-float
+dEQP-VK.graphicsfuzz.cov-nested-loops-switch-case-fallthrough-increment-array-element
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-trunc-fract-always-zero
dEQP-VK.graphicsfuzz.cov-two-functions-modify-struct-array-element-return-from-loop
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-ucarryadd-one-and-one
dEQP-VK.graphicsfuzz.cov-uniform-vector-copy
dEQP-VK.graphicsfuzz.cov-apfloat-reflect-denorm
dEQP-VK.graphicsfuzz.cov-apfloat-unpackunorm-loop
dEQP-VK.graphicsfuzz.cov-array-accesses-clamp
+dEQP-VK.graphicsfuzz.cov-array-cast-bool-float-div-by-zero-no-effect
dEQP-VK.graphicsfuzz.cov-array-copies-loops-with-limiters
+dEQP-VK.graphicsfuzz.cov-array-set-element-condition-negative-modulus
dEQP-VK.graphicsfuzz.cov-asin-undefined-smoothstep
dEQP-VK.graphicsfuzz.cov-atan-trunc-vec4
dEQP-VK.graphicsfuzz.cov-basic-block-discard-in-function
dEQP-VK.graphicsfuzz.cov-cast-float-to-int-and-back
dEQP-VK.graphicsfuzz.cov-clamp-loop-limit-increment-float-array
dEQP-VK.graphicsfuzz.cov-clamp-lower-limit-from-always-false
+dEQP-VK.graphicsfuzz.cov-clamp-min-bitcount-uniform
dEQP-VK.graphicsfuzz.cov-clamp-vector-component-condition-using-matrix
dEQP-VK.graphicsfuzz.cov-clamp-vector-element-ceil-negative
dEQP-VK.graphicsfuzz.cov-clamp-vector-variable-negative-offset
dEQP-VK.graphicsfuzz.cov-color-output-undefined-in-unexecuted-branch
dEQP-VK.graphicsfuzz.cov-combine-and-or-xor-gt-lt
dEQP-VK.graphicsfuzz.cov-condition-bitfield-extract-integer
+dEQP-VK.graphicsfuzz.cov-condition-clamp-min-from-uniform-never-larger
dEQP-VK.graphicsfuzz.cov-condition-increment-zero-to-one-divide-by-two
dEQP-VK.graphicsfuzz.cov-condition-loop-index-bitwise-not
dEQP-VK.graphicsfuzz.cov-condition-matrix-determinant-uniform
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-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-large-array-max-clamp
dEQP-VK.graphicsfuzz.cov-function-loop-condition-uniform-shift-right
dEQP-VK.graphicsfuzz.cov-function-loop-condition-variable-less-than-min-itself
dEQP-VK.graphicsfuzz.cov-function-loop-copy-array-elements-based-on-arguments
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-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-loop-condition-double-negate
dEQP-VK.graphicsfuzz.cov-loop-condition-filter-some-iterations-never-discard
dEQP-VK.graphicsfuzz.cov-loop-condition-logical-or-never-iterated
+dEQP-VK.graphicsfuzz.cov-loop-decrease-integer-never-break
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-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-increase-iterator-condition-uniform-copy-array-elements
dEQP-VK.graphicsfuzz.cov-loop-increment-array-elements-clamp-index
dEQP-VK.graphicsfuzz.cov-loop-increment-integer-findmsb-minus-uniform
dEQP-VK.graphicsfuzz.cov-nested-loops-global-loop-counter-output-color-from-backup
dEQP-VK.graphicsfuzz.cov-nested-loops-identical-iterator-names-multiply-divide
dEQP-VK.graphicsfuzz.cov-nested-loops-increase-integer-dot-product
+dEQP-VK.graphicsfuzz.cov-nested-loops-inner-loop-min-copy-array-elements
dEQP-VK.graphicsfuzz.cov-nested-loops-redundant-condition
+dEQP-VK.graphicsfuzz.cov-nested-loops-return-inside-while-never-executed
dEQP-VK.graphicsfuzz.cov-nested-loops-sample-opposite-corners
dEQP-VK.graphicsfuzz.cov-nested-loops-set-struct-data-verify-in-function
+dEQP-VK.graphicsfuzz.cov-nested-loops-substract-matrix-element-change-float
+dEQP-VK.graphicsfuzz.cov-nested-loops-switch-case-fallthrough-increment-array-element
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-trunc-fract-always-zero
dEQP-VK.graphicsfuzz.cov-two-functions-modify-struct-array-element-return-from-loop
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-types-return-in-main-never-hit
dEQP-VK.graphicsfuzz.cov-ucarryadd-one-and-one
--- /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 _float_1_0 _GLF_uniform_float_values[0]
+# #define _float_0_0 _GLF_uniform_float_values[1]
+#
+# precision highp float;
+# precision highp int;
+#
+# // Contents of _GLF_uniform_float_values: [1.0, 0.0]
+# layout(set = 0, binding = 0) uniform buf0
+# {
+# float _GLF_uniform_float_values[2];
+# };
+#
+# // Contents of _GLF_uniform_int_values: [0, 1]
+# layout(set = 0, binding = 1) uniform buf1
+# {
+# int _GLF_uniform_int_values[2];
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void main()
+# {
+# // 1.0 / float(false) = 1.0 / 0.0. This value has no effect on the output color.
+# float arr[5] = float[5](_float_1_0, _float_0_0, _float_0_0, (1.0 / float(false)), _float_0_0);
+#
+# for(int i = 0; i < 5; i++)
+# {
+# if(arr[_int_0] > arr[i])
+# {
+# arr[i] = _float_1_0;
+# }
+# }
+#
+# // Always true.
+# if(arr[_int_0] == _float_1_0 && arr[_int_1] == _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: 104
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %85
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %11 "arr"
+ OpName %14 "buf0"
+ OpMemberName %14 0 "_GLF_uniform_float_values"
+ OpName %16 ""
+ OpName %32 "i"
+ OpName %43 "buf1"
+ OpMemberName %43 0 "_GLF_uniform_int_values"
+ OpName %45 ""
+ OpName %85 "_GLF_color"
+ OpDecorate %13 ArrayStride 16
+ OpMemberDecorate %14 0 Offset 0
+ OpDecorate %14 Block
+ OpDecorate %16 DescriptorSet 0
+ OpDecorate %16 Binding 0
+ OpDecorate %42 ArrayStride 16
+ OpMemberDecorate %43 0 Offset 0
+ OpDecorate %43 Block
+ OpDecorate %45 DescriptorSet 0
+ OpDecorate %45 Binding 1
+ OpDecorate %85 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeFloat 32
+ %7 = OpTypeInt 32 0
+ %8 = OpConstant %7 5
+ %9 = OpTypeArray %6 %8
+ %10 = OpTypePointer Function %9
+ %12 = OpConstant %7 2
+ %13 = OpTypeArray %6 %12
+ %14 = OpTypeStruct %13
+ %15 = OpTypePointer Uniform %14
+ %16 = OpVariable %15 Uniform
+ %17 = OpTypeInt 32 1
+ %18 = OpConstant %17 0
+ %19 = OpTypePointer Uniform %6
+ %22 = OpConstant %17 1
+ %27 = OpConstant %6 0x1p+128
+ %31 = OpTypePointer Function %17
+ %39 = OpConstant %17 5
+ %40 = OpTypeBool
+ %42 = OpTypeArray %17 %12
+ %43 = OpTypeStruct %42
+ %44 = OpTypePointer Uniform %43
+ %45 = OpVariable %44 Uniform
+ %46 = OpTypePointer Uniform %17
+ %49 = OpTypePointer Function %6
+ %83 = OpTypeVector %6 4
+ %84 = OpTypePointer Output %83
+ %85 = OpVariable %84 Output
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %11 = OpVariable %10 Function
+ %32 = OpVariable %31 Function
+ %20 = OpAccessChain %19 %16 %18 %18
+ %21 = OpLoad %6 %20
+ %23 = OpAccessChain %19 %16 %18 %22
+ %24 = OpLoad %6 %23
+ %25 = OpAccessChain %19 %16 %18 %22
+ %26 = OpLoad %6 %25
+ %28 = OpAccessChain %19 %16 %18 %22
+ %29 = OpLoad %6 %28
+ %30 = OpCompositeConstruct %9 %21 %24 %26 %27 %29
+ OpStore %11 %30
+ OpStore %32 %18
+ OpBranch %33
+ %33 = OpLabel
+ OpLoopMerge %35 %36 None
+ OpBranch %37
+ %37 = OpLabel
+ %38 = OpLoad %17 %32
+ %41 = OpSLessThan %40 %38 %39
+ OpBranchConditional %41 %34 %35
+ %34 = OpLabel
+ %47 = OpAccessChain %46 %45 %18 %18
+ %48 = OpLoad %17 %47
+ %50 = OpAccessChain %49 %11 %48
+ %51 = OpLoad %6 %50
+ %52 = OpLoad %17 %32
+ %53 = OpAccessChain %49 %11 %52
+ %54 = OpLoad %6 %53
+ %55 = OpFOrdGreaterThan %40 %51 %54
+ OpSelectionMerge %57 None
+ OpBranchConditional %55 %56 %57
+ %56 = OpLabel
+ %58 = OpLoad %17 %32
+ %59 = OpAccessChain %19 %16 %18 %18
+ %60 = OpLoad %6 %59
+ %61 = OpAccessChain %49 %11 %58
+ OpStore %61 %60
+ OpBranch %57
+ %57 = OpLabel
+ OpBranch %36
+ %36 = OpLabel
+ %62 = OpLoad %17 %32
+ %63 = OpIAdd %17 %62 %22
+ OpStore %32 %63
+ OpBranch %33
+ %35 = OpLabel
+ %64 = OpAccessChain %46 %45 %18 %18
+ %65 = OpLoad %17 %64
+ %66 = OpAccessChain %49 %11 %65
+ %67 = OpLoad %6 %66
+ %68 = OpAccessChain %19 %16 %18 %18
+ %69 = OpLoad %6 %68
+ %70 = OpFOrdEqual %40 %67 %69
+ OpSelectionMerge %72 None
+ OpBranchConditional %70 %71 %72
+ %71 = OpLabel
+ %73 = OpAccessChain %46 %45 %18 %22
+ %74 = OpLoad %17 %73
+ %75 = OpAccessChain %49 %11 %74
+ %76 = OpLoad %6 %75
+ %77 = OpAccessChain %19 %16 %18 %18
+ %78 = OpLoad %6 %77
+ %79 = OpFOrdEqual %40 %76 %78
+ OpBranch %72
+ %72 = OpLabel
+ %80 = OpPhi %40 %70 %35 %79 %71
+ OpSelectionMerge %82 None
+ OpBranchConditional %80 %81 %99
+ %81 = OpLabel
+ %86 = OpAccessChain %46 %45 %18 %22
+ %87 = OpLoad %17 %86
+ %88 = OpConvertSToF %6 %87
+ %89 = OpAccessChain %46 %45 %18 %18
+ %90 = OpLoad %17 %89
+ %91 = OpConvertSToF %6 %90
+ %92 = OpAccessChain %46 %45 %18 %18
+ %93 = OpLoad %17 %92
+ %94 = OpConvertSToF %6 %93
+ %95 = OpAccessChain %46 %45 %18 %22
+ %96 = OpLoad %17 %95
+ %97 = OpConvertSToF %6 %96
+ %98 = OpCompositeConstruct %83 %88 %91 %94 %97
+ OpStore %85 %98
+ OpBranch %82
+ %99 = OpLabel
+ %100 = OpAccessChain %46 %45 %18 %18
+ %101 = OpLoad %17 %100
+ %102 = OpConvertSToF %6 %101
+ %103 = OpCompositeConstruct %83 %102 %102 %102 %102
+ OpStore %85 %103
+ OpBranch %82
+ %82 = OpLabel
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# _GLF_uniform_int_values
+BUFFER variant__GLF_uniform_int_values DATA_TYPE int32[] STD140 DATA
+ 0 1
+END
+# _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 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 _int_2 _GLF_uniform_int_values[2]
+#
+# precision highp float;
+# precision highp int;
+#
+# // Contents of _GLF_uniform_int_values: [1, 0, 2]
+# layout(set = 0, binding = 0) uniform buf0
+# {
+# int _GLF_uniform_int_values[3];
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void main()
+# {
+# int arr[10] = int[10](_int_1, _int_1, _int_1, _int_1, _int_1, _int_1, _int_1, _int_1, _int_1, _int_1);
+# ivec2 v = ivec2(_int_1);
+# int a = 1;
+#
+# // Always true.
+# if(arr[_int_1] == _int_1)
+# {
+# a++;
+# }
+#
+# // Always false.
+# if (_int_1 == 0)
+# {
+# // Modulus of a negative value is undefined, but this is never executed.
+# if(-5 % a >= _int_1)
+# {
+# arr[v.x + v.y] = _int_0;
+# }
+# }
+# else
+# {
+# // arr[2] becomes two.
+# arr[v.x + v.y] = _int_2;
+# }
+#
+# // Always true.
+# if(a == _int_2 && 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: 132
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %113
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %11 "arr"
+ OpName %14 "buf0"
+ OpMemberName %14 0 "_GLF_uniform_int_values"
+ OpName %16 ""
+ OpName %42 "v"
+ OpName %47 "a"
+ OpName %113 "_GLF_color"
+ OpDecorate %13 ArrayStride 16
+ OpMemberDecorate %14 0 Offset 0
+ OpDecorate %14 Block
+ OpDecorate %16 DescriptorSet 0
+ OpDecorate %16 Binding 0
+ OpDecorate %113 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 3
+ %13 = OpTypeArray %6 %12
+ %14 = OpTypeStruct %13
+ %15 = OpTypePointer Uniform %14
+ %16 = OpVariable %15 Uniform
+ %17 = OpConstant %6 0
+ %18 = OpTypePointer Uniform %6
+ %40 = OpTypeVector %6 2
+ %41 = OpTypePointer Function %40
+ %46 = OpTypePointer Function %6
+ %48 = OpConstant %6 1
+ %55 = OpTypeBool
+ %66 = OpConstant %6 -5
+ %74 = OpConstant %7 0
+ %77 = OpConstant %7 1
+ %90 = OpConstant %6 2
+ %110 = OpTypeFloat 32
+ %111 = OpTypeVector %110 4
+ %112 = OpTypePointer Output %111
+ %113 = OpVariable %112 Output
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %11 = OpVariable %10 Function
+ %42 = OpVariable %41 Function
+ %47 = OpVariable %46 Function
+ %19 = OpAccessChain %18 %16 %17 %17
+ %20 = OpLoad %6 %19
+ %21 = OpAccessChain %18 %16 %17 %17
+ %22 = OpLoad %6 %21
+ %23 = OpAccessChain %18 %16 %17 %17
+ %24 = OpLoad %6 %23
+ %25 = OpAccessChain %18 %16 %17 %17
+ %26 = OpLoad %6 %25
+ %27 = OpAccessChain %18 %16 %17 %17
+ %28 = OpLoad %6 %27
+ %29 = OpAccessChain %18 %16 %17 %17
+ %30 = OpLoad %6 %29
+ %31 = OpAccessChain %18 %16 %17 %17
+ %32 = OpLoad %6 %31
+ %33 = OpAccessChain %18 %16 %17 %17
+ %34 = OpLoad %6 %33
+ %35 = OpAccessChain %18 %16 %17 %17
+ %36 = OpLoad %6 %35
+ %37 = OpAccessChain %18 %16 %17 %17
+ %38 = OpLoad %6 %37
+ %39 = OpCompositeConstruct %9 %20 %22 %24 %26 %28 %30 %32 %34 %36 %38
+ OpStore %11 %39
+ %43 = OpAccessChain %18 %16 %17 %17
+ %44 = OpLoad %6 %43
+ %45 = OpCompositeConstruct %40 %44 %44
+ OpStore %42 %45
+ OpStore %47 %48
+ %49 = OpAccessChain %18 %16 %17 %17
+ %50 = OpLoad %6 %49
+ %51 = OpAccessChain %46 %11 %50
+ %52 = OpLoad %6 %51
+ %53 = OpAccessChain %18 %16 %17 %17
+ %54 = OpLoad %6 %53
+ %56 = OpIEqual %55 %52 %54
+ OpSelectionMerge %58 None
+ OpBranchConditional %56 %57 %58
+ %57 = OpLabel
+ %59 = OpLoad %6 %47
+ %60 = OpIAdd %6 %59 %48
+ OpStore %47 %60
+ OpBranch %58
+ %58 = OpLabel
+ %61 = OpAccessChain %18 %16 %17 %17
+ %62 = OpLoad %6 %61
+ %63 = OpIEqual %55 %62 %17
+ OpSelectionMerge %65 None
+ OpBranchConditional %63 %64 %84
+ %64 = OpLabel
+ %67 = OpLoad %6 %47
+ %68 = OpSMod %6 %66 %67
+ %69 = OpAccessChain %18 %16 %17 %17
+ %70 = OpLoad %6 %69
+ %71 = OpSGreaterThanEqual %55 %68 %70
+ OpSelectionMerge %73 None
+ OpBranchConditional %71 %72 %73
+ %72 = OpLabel
+ %75 = OpAccessChain %46 %42 %74
+ %76 = OpLoad %6 %75
+ %78 = OpAccessChain %46 %42 %77
+ %79 = OpLoad %6 %78
+ %80 = OpIAdd %6 %76 %79
+ %81 = OpAccessChain %18 %16 %17 %48
+ %82 = OpLoad %6 %81
+ %83 = OpAccessChain %46 %11 %80
+ OpStore %83 %82
+ OpBranch %73
+ %73 = OpLabel
+ OpBranch %65
+ %84 = OpLabel
+ %85 = OpAccessChain %46 %42 %74
+ %86 = OpLoad %6 %85
+ %87 = OpAccessChain %46 %42 %77
+ %88 = OpLoad %6 %87
+ %89 = OpIAdd %6 %86 %88
+ %91 = OpAccessChain %18 %16 %17 %90
+ %92 = OpLoad %6 %91
+ %93 = OpAccessChain %46 %11 %89
+ OpStore %93 %92
+ OpBranch %65
+ %65 = OpLabel
+ %94 = OpLoad %6 %47
+ %95 = OpAccessChain %18 %16 %17 %90
+ %96 = OpLoad %6 %95
+ %97 = OpIEqual %55 %94 %96
+ OpSelectionMerge %99 None
+ OpBranchConditional %97 %98 %99
+ %98 = OpLabel
+ %100 = OpAccessChain %18 %16 %17 %90
+ %101 = OpLoad %6 %100
+ %102 = OpAccessChain %46 %11 %101
+ %103 = OpLoad %6 %102
+ %104 = OpAccessChain %18 %16 %17 %90
+ %105 = OpLoad %6 %104
+ %106 = OpIEqual %55 %103 %105
+ OpBranch %99
+ %99 = OpLabel
+ %107 = OpPhi %55 %97 %65 %106 %98
+ OpSelectionMerge %109 None
+ OpBranchConditional %107 %108 %127
+ %108 = OpLabel
+ %114 = OpAccessChain %18 %16 %17 %17
+ %115 = OpLoad %6 %114
+ %116 = OpConvertSToF %110 %115
+ %117 = OpAccessChain %18 %16 %17 %48
+ %118 = OpLoad %6 %117
+ %119 = OpConvertSToF %110 %118
+ %120 = OpAccessChain %18 %16 %17 %48
+ %121 = OpLoad %6 %120
+ %122 = OpConvertSToF %110 %121
+ %123 = OpAccessChain %18 %16 %17 %17
+ %124 = OpLoad %6 %123
+ %125 = OpConvertSToF %110 %124
+ %126 = OpCompositeConstruct %111 %116 %119 %122 %125
+ OpStore %113 %126
+ OpBranch %109
+ %127 = OpLabel
+ %128 = OpAccessChain %18 %16 %17 %48
+ %129 = OpLoad %6 %128
+ %130 = OpConvertSToF %110 %129
+ %131 = OpCompositeConstruct %111 %130 %130 %130 %130
+ OpStore %113 %131
+ OpBranch %109
+ %109 = OpLabel
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# _GLF_uniform_int_values
+BUFFER variant__GLF_uniform_int_values DATA_TYPE int32[] STD140 DATA
+ 1 0 2
+END
+
+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]
+# #define _float_2_0 _GLF_uniform_float_values[0]
+# #define _float_5_0 _GLF_uniform_float_values[1]
+# #define _float_0_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: [2.0, 5.0, 0.0]
+# layout(set = 0, binding = 1) uniform buf1
+# {
+# float _GLF_uniform_float_values[3];
+# };
+#
+# // Contents of three: 3
+# layout(set = 0, binding = 2) uniform buf2
+# {
+# int three;
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void main()
+# {
+# // f = clamp(5.0, 0.0, min(bitcount(3), bitcount(3))) = clamp(5.0, 0.0, 2.0) = 2.0
+# float f = clamp(_float_5_0, _float_0_0, float(min(bitCount(three), bitCount(three))));
+#
+# // Always true.
+# if(f == _float_2_0)
+# {
+# _GLF_color = vec4(_int_1, _int_0, _int_0, _int_1);
+# }
+# else
+# {
+# _GLF_color = vec4(_int_0);
+# }
+# }
+SHADER fragment variant_fragment_shader SPIRV-ASM TARGET_ENV spv1.0
+; SPIR-V
+; Version: 1.0
+; Generator: Khronos Glslang Reference Front End; 10
+; Bound: 70
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %46
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %8 "f"
+ OpName %12 "buf1"
+ OpMemberName %12 0 "_GLF_uniform_float_values"
+ OpName %14 ""
+ OpName %24 "buf2"
+ OpMemberName %24 0 "three"
+ OpName %26 ""
+ OpName %46 "_GLF_color"
+ OpName %49 "buf0"
+ OpMemberName %49 0 "_GLF_uniform_int_values"
+ OpName %51 ""
+ OpDecorate %11 ArrayStride 16
+ OpMemberDecorate %12 0 Offset 0
+ OpDecorate %12 Block
+ OpDecorate %14 DescriptorSet 0
+ OpDecorate %14 Binding 1
+ OpMemberDecorate %24 0 Offset 0
+ OpDecorate %24 Block
+ OpDecorate %26 DescriptorSet 0
+ OpDecorate %26 Binding 2
+ OpDecorate %34 RelaxedPrecision
+ OpDecorate %46 Location 0
+ OpDecorate %48 ArrayStride 16
+ OpMemberDecorate %49 0 Offset 0
+ OpDecorate %49 Block
+ OpDecorate %51 DescriptorSet 0
+ OpDecorate %51 Binding 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeFloat 32
+ %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 = OpTypeInt 32 1
+ %16 = OpConstant %15 0
+ %17 = OpConstant %15 1
+ %18 = OpTypePointer Uniform %6
+ %21 = OpConstant %15 2
+ %24 = OpTypeStruct %15
+ %25 = OpTypePointer Uniform %24
+ %26 = OpVariable %25 Uniform
+ %27 = OpTypePointer Uniform %15
+ %40 = OpTypeBool
+ %44 = OpTypeVector %6 4
+ %45 = OpTypePointer Output %44
+ %46 = OpVariable %45 Output
+ %47 = OpConstant %9 2
+ %48 = OpTypeArray %15 %47
+ %49 = OpTypeStruct %48
+ %50 = OpTypePointer Uniform %49
+ %51 = OpVariable %50 Uniform
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %8 = OpVariable %7 Function
+ %19 = OpAccessChain %18 %14 %16 %17
+ %20 = OpLoad %6 %19
+ %22 = OpAccessChain %18 %14 %16 %21
+ %23 = OpLoad %6 %22
+ %28 = OpAccessChain %27 %26 %16
+ %29 = OpLoad %15 %28
+ %30 = OpBitCount %15 %29
+ %31 = OpAccessChain %27 %26 %16
+ %32 = OpLoad %15 %31
+ %33 = OpBitCount %15 %32
+ %34 = OpExtInst %15 %1 SMin %30 %33
+ %35 = OpConvertSToF %6 %34
+ %36 = OpExtInst %6 %1 FClamp %20 %23 %35
+ OpStore %8 %36
+ %37 = OpLoad %6 %8
+ %38 = OpAccessChain %18 %14 %16 %16
+ %39 = OpLoad %6 %38
+ %41 = OpFOrdEqual %40 %37 %39
+ OpSelectionMerge %43 None
+ OpBranchConditional %41 %42 %65
+ %42 = OpLabel
+ %52 = OpAccessChain %27 %51 %16 %16
+ %53 = OpLoad %15 %52
+ %54 = OpConvertSToF %6 %53
+ %55 = OpAccessChain %27 %51 %16 %17
+ %56 = OpLoad %15 %55
+ %57 = OpConvertSToF %6 %56
+ %58 = OpAccessChain %27 %51 %16 %17
+ %59 = OpLoad %15 %58
+ %60 = OpConvertSToF %6 %59
+ %61 = OpAccessChain %27 %51 %16 %16
+ %62 = OpLoad %15 %61
+ %63 = OpConvertSToF %6 %62
+ %64 = OpCompositeConstruct %44 %54 %57 %60 %63
+ OpStore %46 %64
+ OpBranch %43
+ %65 = OpLabel
+ %66 = OpAccessChain %27 %51 %16 %17
+ %67 = OpLoad %15 %66
+ %68 = OpConvertSToF %6 %67
+ %69 = OpCompositeConstruct %44 %68 %68 %68 %68
+ OpStore %46 %69
+ OpBranch %43
+ %43 = OpLabel
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# three
+BUFFER variant_three DATA_TYPE int32 STD140 DATA
+ 3
+END
+# _GLF_uniform_float_values
+BUFFER variant__GLF_uniform_float_values DATA_TYPE float[] STD140 DATA
+ 2.0 5.0 0.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_three AS uniform DESCRIPTOR_SET 0 BINDING 2
+ BIND BUFFER variant__GLF_uniform_float_values AS uniform DESCRIPTOR_SET 0 BINDING 1
+ BIND BUFFER variant__GLF_uniform_int_values AS uniform DESCRIPTOR_SET 0 BINDING 0
+END
+CLEAR_COLOR variant_pipeline 0 0 0 255
+
+CLEAR variant_pipeline
+RUN variant_pipeline DRAW_RECT POS 0 0 SIZE 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_1_0 _GLF_uniform_float_values[0]
+#
+# precision highp float;
+# precision highp int;
+#
+# // Contents of _GLF_uniform_float_values: 1.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 two: 2.0
+# layout(push_constant) uniform buf_push
+# {
+# float two;
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void main()
+# {
+# // Always true: regardless of the condition a value of one can never become larger by clamping.
+# if(clamp(1, _float_1_0 > two ? 1 : 0, 1) <= 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: 59
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %34
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %12 "buf0"
+ OpMemberName %12 0 "_GLF_uniform_float_values"
+ OpName %14 ""
+ OpName %19 "buf_push"
+ OpMemberName %19 0 "two"
+ OpName %21 ""
+ OpName %34 "_GLF_color"
+ OpName %37 "buf1"
+ OpMemberName %37 0 "_GLF_uniform_int_values"
+ OpName %39 ""
+ OpDecorate %11 ArrayStride 16
+ OpMemberDecorate %12 0 Offset 0
+ OpDecorate %12 Block
+ OpDecorate %14 DescriptorSet 0
+ OpDecorate %14 Binding 0
+ OpMemberDecorate %19 0 Offset 0
+ OpDecorate %19 Block
+ OpDecorate %34 Location 0
+ OpDecorate %36 ArrayStride 16
+ OpMemberDecorate %37 0 Offset 0
+ OpDecorate %37 Block
+ OpDecorate %39 DescriptorSet 0
+ OpDecorate %39 Binding 1
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeInt 32 1
+ %7 = OpConstant %6 1
+ %8 = OpTypeFloat 32
+ %9 = OpTypeInt 32 0
+ %10 = OpConstant %9 1
+ %11 = OpTypeArray %8 %10
+ %12 = OpTypeStruct %11
+ %13 = OpTypePointer Uniform %12
+ %14 = OpVariable %13 Uniform
+ %15 = OpConstant %6 0
+ %16 = OpTypePointer Uniform %8
+ %19 = OpTypeStruct %8
+ %20 = OpTypePointer PushConstant %19
+ %21 = OpVariable %20 PushConstant
+ %22 = OpTypePointer PushConstant %8
+ %25 = OpTypeBool
+ %32 = OpTypeVector %8 4
+ %33 = OpTypePointer Output %32
+ %34 = OpVariable %33 Output
+ %35 = OpConstant %9 2
+ %36 = OpTypeArray %6 %35
+ %37 = OpTypeStruct %36
+ %38 = OpTypePointer Uniform %37
+ %39 = OpVariable %38 Uniform
+ %40 = OpTypePointer Uniform %6
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %17 = OpAccessChain %16 %14 %15 %15
+ %18 = OpLoad %8 %17
+ %23 = OpAccessChain %22 %21 %15
+ %24 = OpLoad %8 %23
+ %26 = OpFOrdGreaterThan %25 %18 %24
+ %27 = OpSelect %6 %26 %7 %15
+ %28 = OpExtInst %6 %1 SClamp %7 %27 %7
+ %29 = OpSLessThanEqual %25 %28 %7
+ OpSelectionMerge %31 None
+ OpBranchConditional %29 %30 %54
+ %30 = OpLabel
+ %41 = OpAccessChain %40 %39 %15 %15
+ %42 = OpLoad %6 %41
+ %43 = OpConvertSToF %8 %42
+ %44 = OpAccessChain %40 %39 %15 %7
+ %45 = OpLoad %6 %44
+ %46 = OpConvertSToF %8 %45
+ %47 = OpAccessChain %40 %39 %15 %7
+ %48 = OpLoad %6 %47
+ %49 = OpConvertSToF %8 %48
+ %50 = OpAccessChain %40 %39 %15 %15
+ %51 = OpLoad %6 %50
+ %52 = OpConvertSToF %8 %51
+ %53 = OpCompositeConstruct %32 %43 %46 %49 %52
+ OpStore %34 %53
+ OpBranch %31
+ %54 = OpLabel
+ %55 = OpAccessChain %40 %39 %15 %7
+ %56 = OpLoad %6 %55
+ %57 = OpConvertSToF %8 %56
+ %58 = OpCompositeConstruct %32 %57 %57 %57 %57
+ OpStore %34 %58
+ OpBranch %31
+ %31 = OpLabel
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# two
+BUFFER variant_two DATA_TYPE float STD140 DATA
+ 2.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
+ 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_two AS push_constant
+ BIND BUFFER variant__GLF_uniform_int_values AS uniform DESCRIPTOR_SET 0 BINDING 1
+ BIND BUFFER variant__GLF_uniform_float_values AS uniform DESCRIPTOR_SET 0 BINDING 0
+END
+CLEAR_COLOR variant_pipeline 0 0 0 255
+
+CLEAR variant_pipeline
+RUN variant_pipeline DRAW_RECT POS 0 0 SIZE 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_4 _GLF_uniform_int_values[0]
+# #define _int_2 _GLF_uniform_int_values[1]
+# #define _int_5 _GLF_uniform_int_values[2]
+# #define _int_1 _GLF_uniform_int_values[3]
+# #define _int_6 _GLF_uniform_int_values[4]
+# #define _int_0 _GLF_uniform_int_values[5]
+#
+# precision highp float;
+# precision highp int;
+#
+# // Contents of _GLF_uniform_int_values: [4, 2, 5, 1, 6, 0]
+# layout(set = 0, binding = 0) uniform buf0
+# {
+# int _GLF_uniform_int_values[6];
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# int func()
+# {
+# int a = _int_1 << _int_6;
+# // Returns 2.
+# return clamp(a >> _int_5, a >> _int_5, _int_4);
+# }
+#
+# void main()
+# {
+# // Always true.
+# if(func() == _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: 72
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %52
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %8 "func("
+ OpName %11 "a"
+ OpName %15 "buf0"
+ OpMemberName %15 0 "_GLF_uniform_int_values"
+ OpName %17 ""
+ OpName %52 "_GLF_color"
+ OpDecorate %14 ArrayStride 16
+ OpMemberDecorate %15 0 Offset 0
+ OpDecorate %15 Block
+ OpDecorate %17 DescriptorSet 0
+ OpDecorate %17 Binding 0
+ OpDecorate %52 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeInt 32 1
+ %7 = OpTypeFunction %6
+ %10 = OpTypePointer Function %6
+ %12 = OpTypeInt 32 0
+ %13 = OpConstant %12 6
+ %14 = OpTypeArray %6 %13
+ %15 = OpTypeStruct %14
+ %16 = OpTypePointer Uniform %15
+ %17 = OpVariable %16 Uniform
+ %18 = OpConstant %6 0
+ %19 = OpConstant %6 3
+ %20 = OpTypePointer Uniform %6
+ %23 = OpConstant %6 4
+ %28 = OpConstant %6 2
+ %42 = OpConstant %6 1
+ %45 = OpTypeBool
+ %49 = OpTypeFloat 32
+ %50 = OpTypeVector %49 4
+ %51 = OpTypePointer Output %50
+ %52 = OpVariable %51 Output
+ %56 = OpConstant %6 5
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %41 = OpFunctionCall %6 %8
+ %43 = OpAccessChain %20 %17 %18 %42
+ %44 = OpLoad %6 %43
+ %46 = OpIEqual %45 %41 %44
+ OpSelectionMerge %48 None
+ OpBranchConditional %46 %47 %67
+ %47 = OpLabel
+ %53 = OpAccessChain %20 %17 %18 %19
+ %54 = OpLoad %6 %53
+ %55 = OpConvertSToF %49 %54
+ %57 = OpAccessChain %20 %17 %18 %56
+ %58 = OpLoad %6 %57
+ %59 = OpConvertSToF %49 %58
+ %60 = OpAccessChain %20 %17 %18 %56
+ %61 = OpLoad %6 %60
+ %62 = OpConvertSToF %49 %61
+ %63 = OpAccessChain %20 %17 %18 %19
+ %64 = OpLoad %6 %63
+ %65 = OpConvertSToF %49 %64
+ %66 = OpCompositeConstruct %50 %55 %59 %62 %65
+ OpStore %52 %66
+ OpBranch %48
+ %67 = OpLabel
+ %68 = OpAccessChain %20 %17 %18 %56
+ %69 = OpLoad %6 %68
+ %70 = OpConvertSToF %49 %69
+ %71 = OpCompositeConstruct %50 %70 %70 %70 %70
+ OpStore %52 %71
+ OpBranch %48
+ %48 = OpLabel
+ OpReturn
+ OpFunctionEnd
+ %8 = OpFunction %6 None %7
+ %9 = OpLabel
+ %11 = OpVariable %10 Function
+ %21 = OpAccessChain %20 %17 %18 %19
+ %22 = OpLoad %6 %21
+ %24 = OpAccessChain %20 %17 %18 %23
+ %25 = OpLoad %6 %24
+ %26 = OpShiftLeftLogical %6 %22 %25
+ OpStore %11 %26
+ %27 = OpLoad %6 %11
+ %29 = OpAccessChain %20 %17 %18 %28
+ %30 = OpLoad %6 %29
+ %31 = OpShiftRightArithmetic %6 %27 %30
+ %32 = OpLoad %6 %11
+ %33 = OpAccessChain %20 %17 %18 %28
+ %34 = OpLoad %6 %33
+ %35 = OpShiftRightArithmetic %6 %32 %34
+ %36 = OpAccessChain %20 %17 %18 %18
+ %37 = OpLoad %6 %36
+ %38 = OpExtInst %6 %1 SClamp %31 %35 %37
+ OpReturnValue %38
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# _GLF_uniform_int_values
+BUFFER variant__GLF_uniform_int_values DATA_TYPE int32[] STD140 DATA
+ 4 2 5 1 6 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]
+#
+# 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];
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# int func()
+# {
+# while(true)
+# {
+# for(int i = 0; i < 1; i++)
+# {
+# // Always true.
+# if(gl_FragCoord.y > 0.0)
+# {
+# return 1;
+# }
+# }
+# }
+#
+# // Never executed.
+# return _int_0;
+# }
+#
+# void main()
+# {
+# // Always true.
+# if(func() == _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: 132
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %31 %61
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %31 "gl_FragCoord"
+ OpName %46 "buf0"
+ OpMemberName %46 0 "_GLF_uniform_int_values"
+ OpName %48 ""
+ OpName %61 "_GLF_color"
+ OpDecorate %31 BuiltIn FragCoord
+ OpDecorate %45 ArrayStride 16
+ OpMemberDecorate %46 0 Offset 0
+ OpDecorate %46 Block
+ OpDecorate %48 DescriptorSet 0
+ OpDecorate %48 Binding 0
+ OpDecorate %61 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeInt 32 1
+ %15 = OpTypeBool
+ %16 = OpConstantTrue %15
+ %19 = OpConstant %6 0
+ %26 = OpConstant %6 1
+ %28 = OpTypeFloat 32
+ %29 = OpTypeVector %28 4
+ %30 = OpTypePointer Input %29
+ %31 = OpVariable %30 Input
+ %32 = OpTypeInt 32 0
+ %33 = OpConstant %32 1
+ %34 = OpTypePointer Input %28
+ %37 = OpConstant %28 0
+ %44 = OpConstant %32 2
+ %45 = OpTypeArray %6 %44
+ %46 = OpTypeStruct %45
+ %47 = OpTypePointer Uniform %46
+ %48 = OpVariable %47 Uniform
+ %49 = OpTypePointer Uniform %6
+ %60 = OpTypePointer Output %29
+ %61 = OpVariable %60 Output
+ %84 = OpConstant %32 0
+ %85 = OpConstantFalse %15
+ %131 = OpUndef %6
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ OpSelectionMerge %121 None
+ OpSwitch %84 %97
+ %97 = OpLabel
+ OpBranch %98
+ %98 = OpLabel
+ %126 = OpPhi %15 %85 %97 %124 %117
+ %130 = OpPhi %6 %131 %97 %128 %117
+ OpLoopMerge %118 %117 None
+ OpBranch %101
+ %101 = OpLabel
+ %123 = OpPhi %6 %19 %98 %113 %111
+ %104 = OpSLessThan %15 %123 %26
+ OpLoopMerge %114 %111 None
+ OpBranchConditional %104 %105 %114
+ %105 = OpLabel
+ %106 = OpAccessChain %34 %31 %33
+ %107 = OpLoad %28 %106
+ %108 = OpFOrdGreaterThan %15 %107 %37
+ OpSelectionMerge %110 None
+ OpBranchConditional %108 %109 %110
+ %109 = OpLabel
+ OpBranch %114
+ %110 = OpLabel
+ OpBranch %111
+ %111 = OpLabel
+ %113 = OpIAdd %6 %123 %26
+ OpBranch %101
+ %114 = OpLabel
+ %128 = OpPhi %6 %130 %101 %26 %109
+ %124 = OpPhi %15 %126 %101 %16 %109
+ OpSelectionMerge %116 None
+ OpBranchConditional %124 %118 %116
+ %116 = OpLabel
+ OpBranch %117
+ %117 = OpLabel
+ OpBranch %98
+ %118 = OpLabel
+ OpSelectionMerge %120 None
+ OpBranchConditional %124 %121 %120
+ %120 = OpLabel
+ OpBranch %121
+ %121 = OpLabel
+ %55 = OpAccessChain %49 %48 %19 %26
+ %56 = OpLoad %6 %55
+ %57 = OpIEqual %15 %128 %56
+ OpSelectionMerge %59 None
+ OpBranchConditional %57 %58 %75
+ %75 = OpLabel
+ %76 = OpAccessChain %49 %48 %19 %19
+ %77 = OpLoad %6 %76
+ %78 = OpConvertSToF %28 %77
+ %79 = OpCompositeConstruct %29 %78 %78 %78 %78
+ OpStore %61 %79
+ OpBranch %59
+ %58 = OpLabel
+ %64 = OpConvertSToF %28 %56
+ %65 = OpAccessChain %49 %48 %19 %19
+ %66 = OpLoad %6 %65
+ %67 = OpConvertSToF %28 %66
+ %74 = OpCompositeConstruct %29 %64 %67 %67 %64
+ OpStore %61 %74
+ OpBranch %59
+ %59 = OpLabel
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# _GLF_uniform_int_values
+BUFFER variant__GLF_uniform_int_values DATA_TYPE int32[] STD140 DATA
+ 0 1
+END
+
+BUFFER variant_framebuffer FORMAT B8G8R8A8_UNORM
+
+PIPELINE graphics variant_pipeline
+ ATTACH variant_vertex_shader
+ ATTACH variant_fragment_shader
+ FRAMEBUFFER_SIZE 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_4 _GLF_uniform_int_values[2]
+# #define _int_2 _GLF_uniform_int_values[3]
+#
+# precision highp float;
+# precision highp int;
+#
+# // Contents of _GLF_uniform_int_values: [0, 1, 4, 2]
+# layout(set = 0, binding = 0) uniform buf0
+# {
+# int _GLF_uniform_int_values[4];
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# int func()
+# {
+# int a = _int_1;
+# int b = _int_1;
+# int arr[6] = int[6](_int_1, _int_1, _int_1, _int_1, _int_1, _int_1);
+#
+# // Returns during the second iteration.
+# while(b >= _int_1)
+# {
+# a = b++;
+#
+# for(int i = 0; i < 3; i++)
+# {
+# switch(a)
+# {
+# case 2:
+# arr[a]++;
+# break;
+# case 3:
+# return arr[_int_2];
+# case 5:
+# // Never executed.
+# arr[a]++;
+# break;
+# }
+# }
+# }
+#
+# // Never executed.
+# return _int_0;
+# }
+#
+# void main()
+# {
+# // Always true.
+# if(func() == _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: 120
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %101
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %8 "func("
+ OpName %11 "a"
+ OpName %15 "buf0"
+ OpMemberName %15 0 "_GLF_uniform_int_values"
+ OpName %17 ""
+ OpName %23 "b"
+ OpName %29 "arr"
+ OpName %55 "i"
+ OpName %101 "_GLF_color"
+ OpDecorate %14 ArrayStride 16
+ OpMemberDecorate %15 0 Offset 0
+ OpDecorate %15 Block
+ OpDecorate %17 DescriptorSet 0
+ OpDecorate %17 Binding 0
+ OpDecorate %101 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeInt 32 1
+ %7 = OpTypeFunction %6
+ %10 = OpTypePointer Function %6
+ %12 = OpTypeInt 32 0
+ %13 = OpConstant %12 4
+ %14 = OpTypeArray %6 %13
+ %15 = OpTypeStruct %14
+ %16 = OpTypePointer Uniform %15
+ %17 = OpVariable %16 Uniform
+ %18 = OpConstant %6 0
+ %19 = OpConstant %6 1
+ %20 = OpTypePointer Uniform %6
+ %26 = OpConstant %12 6
+ %27 = OpTypeArray %6 %26
+ %28 = OpTypePointer Function %27
+ %51 = OpTypeBool
+ %62 = OpConstant %6 3
+ %92 = OpConstant %6 2
+ %98 = OpTypeFloat 32
+ %99 = OpTypeVector %98 4
+ %100 = OpTypePointer Output %99
+ %101 = OpVariable %100 Output
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %91 = OpFunctionCall %6 %8
+ %93 = OpAccessChain %20 %17 %18 %92
+ %94 = OpLoad %6 %93
+ %95 = OpIEqual %51 %91 %94
+ OpSelectionMerge %97 None
+ OpBranchConditional %95 %96 %115
+ %96 = OpLabel
+ %102 = OpAccessChain %20 %17 %18 %19
+ %103 = OpLoad %6 %102
+ %104 = OpConvertSToF %98 %103
+ %105 = OpAccessChain %20 %17 %18 %18
+ %106 = OpLoad %6 %105
+ %107 = OpConvertSToF %98 %106
+ %108 = OpAccessChain %20 %17 %18 %18
+ %109 = OpLoad %6 %108
+ %110 = OpConvertSToF %98 %109
+ %111 = OpAccessChain %20 %17 %18 %19
+ %112 = OpLoad %6 %111
+ %113 = OpConvertSToF %98 %112
+ %114 = OpCompositeConstruct %99 %104 %107 %110 %113
+ OpStore %101 %114
+ OpBranch %97
+ %115 = OpLabel
+ %116 = OpAccessChain %20 %17 %18 %18
+ %117 = OpLoad %6 %116
+ %118 = OpConvertSToF %98 %117
+ %119 = OpCompositeConstruct %99 %118 %118 %118 %118
+ OpStore %101 %119
+ OpBranch %97
+ %97 = OpLabel
+ OpReturn
+ OpFunctionEnd
+ %8 = OpFunction %6 None %7
+ %9 = OpLabel
+ %11 = OpVariable %10 Function
+ %23 = OpVariable %10 Function
+ %29 = OpVariable %28 Function
+ %55 = OpVariable %10 Function
+ %21 = OpAccessChain %20 %17 %18 %19
+ %22 = OpLoad %6 %21
+ OpStore %11 %22
+ %24 = OpAccessChain %20 %17 %18 %19
+ %25 = OpLoad %6 %24
+ OpStore %23 %25
+ %30 = OpAccessChain %20 %17 %18 %19
+ %31 = OpLoad %6 %30
+ %32 = OpAccessChain %20 %17 %18 %19
+ %33 = OpLoad %6 %32
+ %34 = OpAccessChain %20 %17 %18 %19
+ %35 = OpLoad %6 %34
+ %36 = OpAccessChain %20 %17 %18 %19
+ %37 = OpLoad %6 %36
+ %38 = OpAccessChain %20 %17 %18 %19
+ %39 = OpLoad %6 %38
+ %40 = OpAccessChain %20 %17 %18 %19
+ %41 = OpLoad %6 %40
+ %42 = OpCompositeConstruct %27 %31 %33 %35 %37 %39 %41
+ OpStore %29 %42
+ OpBranch %43
+ %43 = OpLabel
+ OpLoopMerge %45 %46 None
+ OpBranch %47
+ %47 = OpLabel
+ %48 = OpLoad %6 %23
+ %49 = OpAccessChain %20 %17 %18 %19
+ %50 = OpLoad %6 %49
+ %52 = OpSGreaterThanEqual %51 %48 %50
+ OpBranchConditional %52 %44 %45
+ %44 = OpLabel
+ %53 = OpLoad %6 %23
+ %54 = OpIAdd %6 %53 %19
+ OpStore %23 %54
+ OpStore %11 %53
+ OpStore %55 %18
+ OpBranch %56
+ %56 = OpLabel
+ OpLoopMerge %58 %59 None
+ OpBranch %60
+ %60 = OpLabel
+ %61 = OpLoad %6 %55
+ %63 = OpSLessThan %51 %61 %62
+ OpBranchConditional %63 %57 %58
+ %57 = OpLabel
+ %64 = OpLoad %6 %11
+ OpSelectionMerge %68 None
+ OpSwitch %64 %68 2 %65 3 %66 5 %67
+ %65 = OpLabel
+ %69 = OpLoad %6 %11
+ %70 = OpAccessChain %10 %29 %69
+ %71 = OpLoad %6 %70
+ %72 = OpIAdd %6 %71 %19
+ OpStore %70 %72
+ OpBranch %68
+ %66 = OpLabel
+ %74 = OpAccessChain %20 %17 %18 %62
+ %75 = OpLoad %6 %74
+ %76 = OpAccessChain %10 %29 %75
+ %77 = OpLoad %6 %76
+ OpReturnValue %77
+ %67 = OpLabel
+ %79 = OpLoad %6 %11
+ %80 = OpAccessChain %10 %29 %79
+ %81 = OpLoad %6 %80
+ %82 = OpIAdd %6 %81 %19
+ OpStore %80 %82
+ OpBranch %68
+ %68 = OpLabel
+ OpBranch %59
+ %59 = OpLabel
+ %85 = OpLoad %6 %55
+ %86 = OpIAdd %6 %85 %19
+ OpStore %55 %86
+ OpBranch %56
+ %58 = OpLabel
+ OpBranch %46
+ %46 = OpLabel
+ OpBranch %43
+ %45 = OpLabel
+ %87 = OpAccessChain %20 %17 %18 %18
+ %88 = OpLoad %6 %87
+ OpReturnValue %88
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# _GLF_uniform_int_values
+BUFFER variant__GLF_uniform_int_values DATA_TYPE int32[] STD140 DATA
+ 0 1 4 2
+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;
+#
+# vec4 func()
+# {
+# int a = _int_1;
+# min(a, a << 24323);
+# return vec4(_int_1, _int_0, _int_0, _int_1);
+# }
+#
+# void main()
+# {
+# _GLF_color = func();
+# }
+SHADER fragment variant_fragment_shader SPIRV-ASM TARGET_ENV spv1.0
+; SPIR-V
+; Version: 1.0
+; Generator: Khronos Glslang Reference Front End; 10
+; Bound: 48
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %46
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %9 "func("
+ OpName %13 "a"
+ OpName %17 "buf0"
+ OpMemberName %17 0 "_GLF_uniform_int_values"
+ OpName %19 ""
+ OpName %46 "_GLF_color"
+ OpDecorate %16 ArrayStride 16
+ OpMemberDecorate %17 0 Offset 0
+ OpDecorate %17 Block
+ OpDecorate %19 DescriptorSet 0
+ OpDecorate %19 Binding 0
+ OpDecorate %46 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeFloat 32
+ %7 = OpTypeVector %6 4
+ %8 = OpTypeFunction %7
+ %11 = OpTypeInt 32 1
+ %12 = OpTypePointer Function %11
+ %14 = OpTypeInt 32 0
+ %15 = OpConstant %14 2
+ %16 = OpTypeArray %11 %15
+ %17 = OpTypeStruct %16
+ %18 = OpTypePointer Uniform %17
+ %19 = OpVariable %18 Uniform
+ %20 = OpConstant %11 0
+ %21 = OpTypePointer Uniform %11
+ %26 = OpConstant %11 24323
+ %32 = OpConstant %11 1
+ %45 = OpTypePointer Output %7
+ %46 = OpVariable %45 Output
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %47 = OpFunctionCall %7 %9
+ OpStore %46 %47
+ OpReturn
+ OpFunctionEnd
+ %9 = OpFunction %7 None %8
+ %10 = OpLabel
+ %13 = OpVariable %12 Function
+ %22 = OpAccessChain %21 %19 %20 %20
+ %23 = OpLoad %11 %22
+ OpStore %13 %23
+ %24 = OpLoad %11 %13
+ %25 = OpLoad %11 %13
+ %27 = OpShiftLeftLogical %11 %25 %26
+ %28 = OpExtInst %11 %1 SMin %24 %27
+ %29 = OpAccessChain %21 %19 %20 %20
+ %30 = OpLoad %11 %29
+ %31 = OpConvertSToF %6 %30
+ %33 = OpAccessChain %21 %19 %20 %32
+ %34 = OpLoad %11 %33
+ %35 = OpConvertSToF %6 %34
+ %36 = OpAccessChain %21 %19 %20 %32
+ %37 = OpLoad %11 %36
+ %38 = OpConvertSToF %6 %37
+ %39 = OpAccessChain %21 %19 %20 %20
+ %40 = OpLoad %11 %39
+ %41 = OpConvertSToF %6 %40
+ %42 = OpCompositeConstruct %7 %31 %35 %38 %41
+ OpReturnValue %42
+ 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
+#
+# precision highp float;
+# precision highp int;
+#
+# // Contents of one: 1
+# layout(push_constant) uniform buf_push
+# {
+# int one;
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void main()
+# {
+# int a = 100;
+#
+# do
+# {
+# // Always false.
+# if(one < 1)
+# {
+# break;
+# }
+#
+# a--;
+# }
+# while(a > 1);
+#
+# // Always true.
+# if(a == 1)
+# {
+# _GLF_color = vec4(1, 0, 0, 1);
+# }
+# else
+# {
+# _GLF_color = vec4(0);
+# }
+# }
+SHADER fragment variant_fragment_shader SPIRV-ASM TARGET_ENV spv1.0
+; SPIR-V
+; Version: 1.0
+; Generator: Khronos Glslang Reference Front End; 10
+; Bound: 44
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %38
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %8 "a"
+ OpName %14 "buf_push"
+ OpMemberName %14 0 "one"
+ OpName %16 ""
+ OpName %38 "_GLF_color"
+ OpMemberDecorate %14 0 Offset 0
+ OpDecorate %14 Block
+ OpDecorate %38 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeInt 32 1
+ %7 = OpTypePointer Function %6
+ %9 = OpConstant %6 100
+ %14 = OpTypeStruct %6
+ %15 = OpTypePointer PushConstant %14
+ %16 = OpVariable %15 PushConstant
+ %17 = OpConstant %6 0
+ %18 = OpTypePointer PushConstant %6
+ %21 = OpConstant %6 1
+ %22 = OpTypeBool
+ %35 = OpTypeFloat 32
+ %36 = OpTypeVector %35 4
+ %37 = OpTypePointer Output %36
+ %38 = OpVariable %37 Output
+ %39 = OpConstant %35 1
+ %40 = OpConstant %35 0
+ %41 = OpConstantComposite %36 %39 %40 %40 %39
+ %43 = OpConstantComposite %36 %40 %40 %40 %40
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %8 = OpVariable %7 Function
+ OpStore %8 %9
+ OpBranch %10
+ %10 = OpLabel
+ OpLoopMerge %12 %13 None
+ OpBranch %11
+ %11 = OpLabel
+ %19 = OpAccessChain %18 %16 %17
+ %20 = OpLoad %6 %19
+ %23 = OpSLessThan %22 %20 %21
+ OpSelectionMerge %25 None
+ OpBranchConditional %23 %24 %25
+ %24 = OpLabel
+ OpBranch %12
+ %25 = OpLabel
+ %27 = OpLoad %6 %8
+ %28 = OpISub %6 %27 %21
+ OpStore %8 %28
+ OpBranch %13
+ %13 = OpLabel
+ %29 = OpLoad %6 %8
+ %30 = OpSGreaterThan %22 %29 %21
+ OpBranchConditional %30 %10 %12
+ %12 = OpLabel
+ %31 = OpLoad %6 %8
+ %32 = OpIEqual %22 %31 %21
+ OpSelectionMerge %34 None
+ OpBranchConditional %32 %33 %42
+ %33 = OpLabel
+ OpStore %38 %41
+ OpBranch %34
+ %42 = OpLabel
+ OpStore %38 %43
+ OpBranch %34
+ %34 = OpLabel
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# one
+BUFFER variant_one DATA_TYPE int32 STD140 DATA
+ 1
+END
+
+BUFFER variant_framebuffer FORMAT B8G8R8A8_UNORM
+
+PIPELINE graphics variant_pipeline
+ ATTACH variant_vertex_shader
+ ATTACH variant_fragment_shader
+ FRAMEBUFFER_SIZE 32 32
+ BIND BUFFER variant_framebuffer AS color LOCATION 0
+ BIND BUFFER variant_one AS push_constant
+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_3 _GLF_uniform_int_values[1]
+# #define _int_1 _GLF_uniform_int_values[2]
+# #define _int_2 _GLF_uniform_int_values[3]
+#
+# precision highp float;
+# precision highp int;
+#
+# // Contents of _GLF_uniform_int_values: [0, 3, 1, 2]
+# layout(set = 0, binding = 0) uniform buf0
+# {
+# int _GLF_uniform_int_values[4];
+# };
+#
+# const int _GLF_global_loop_bound = 10;
+# int _GLF_global_loop_count = 0;
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void main()
+# {
+# ivec4 v = ivec4(_int_0);
+# int a = 1;
+# int b = 1;
+#
+# do
+# {
+# _GLF_global_loop_count++;
+#
+# if(b++ >= 3)
+# {
+# break;
+# }
+#
+# // Executed twice: v[1] = 2 and v[2] = 3.
+# v[a++] = a;
+# }
+# while(_GLF_global_loop_count < _GLF_global_loop_bound);
+#
+# // Always true.
+# if(v == ivec4(_int_0, _int_2, _int_3, _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: 86
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %66
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %8 "_GLF_global_loop_count"
+ OpName %12 "v"
+ OpName %16 "buf0"
+ OpMemberName %16 0 "_GLF_uniform_int_values"
+ OpName %18 ""
+ OpName %24 "a"
+ OpName %26 "b"
+ OpName %66 "_GLF_color"
+ OpDecorate %15 ArrayStride 16
+ OpMemberDecorate %16 0 Offset 0
+ OpDecorate %16 Block
+ OpDecorate %18 DescriptorSet 0
+ OpDecorate %18 Binding 0
+ OpDecorate %66 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeInt 32 1
+ %7 = OpTypePointer Private %6
+ %8 = OpVariable %7 Private
+ %9 = OpConstant %6 0
+ %10 = OpTypeVector %6 4
+ %11 = OpTypePointer Function %10
+ %13 = OpTypeInt 32 0
+ %14 = OpConstant %13 4
+ %15 = OpTypeArray %6 %14
+ %16 = OpTypeStruct %15
+ %17 = OpTypePointer Uniform %16
+ %18 = OpVariable %17 Uniform
+ %19 = OpTypePointer Uniform %6
+ %23 = OpTypePointer Function %6
+ %25 = OpConstant %6 1
+ %35 = OpConstant %6 3
+ %36 = OpTypeBool
+ %46 = OpConstant %6 10
+ %58 = OpTypeVector %36 4
+ %63 = OpTypeFloat 32
+ %64 = OpTypeVector %63 4
+ %65 = OpTypePointer Output %64
+ %66 = OpVariable %65 Output
+ %67 = OpConstant %6 2
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %12 = OpVariable %11 Function
+ %24 = OpVariable %23 Function
+ %26 = OpVariable %23 Function
+ OpStore %8 %9
+ %20 = OpAccessChain %19 %18 %9 %9
+ %21 = OpLoad %6 %20
+ %22 = OpCompositeConstruct %10 %21 %21 %21 %21
+ OpStore %12 %22
+ OpStore %24 %25
+ OpStore %26 %25
+ OpBranch %27
+ %27 = OpLabel
+ OpLoopMerge %29 %30 None
+ OpBranch %28
+ %28 = OpLabel
+ %31 = OpLoad %6 %8
+ %32 = OpIAdd %6 %31 %25
+ OpStore %8 %32
+ %33 = OpLoad %6 %26
+ %34 = OpIAdd %6 %33 %25
+ OpStore %26 %34
+ %37 = OpSGreaterThanEqual %36 %33 %35
+ OpSelectionMerge %39 None
+ OpBranchConditional %37 %38 %39
+ %38 = OpLabel
+ OpBranch %29
+ %39 = OpLabel
+ %41 = OpLoad %6 %24
+ %42 = OpIAdd %6 %41 %25
+ OpStore %24 %42
+ %43 = OpLoad %6 %24
+ %44 = OpAccessChain %23 %12 %41
+ OpStore %44 %43
+ OpBranch %30
+ %30 = OpLabel
+ %45 = OpLoad %6 %8
+ %47 = OpSLessThan %36 %45 %46
+ OpBranchConditional %47 %27 %29
+ %29 = OpLabel
+ %48 = OpLoad %10 %12
+ %49 = OpAccessChain %19 %18 %9 %9
+ %50 = OpLoad %6 %49
+ %51 = OpAccessChain %19 %18 %9 %35
+ %52 = OpLoad %6 %51
+ %53 = OpAccessChain %19 %18 %9 %25
+ %54 = OpLoad %6 %53
+ %55 = OpAccessChain %19 %18 %9 %9
+ %56 = OpLoad %6 %55
+ %57 = OpCompositeConstruct %10 %50 %52 %54 %56
+ %59 = OpIEqual %58 %48 %57
+ %60 = OpAll %36 %59
+ OpSelectionMerge %62 None
+ OpBranchConditional %60 %61 %81
+ %61 = OpLabel
+ %68 = OpAccessChain %19 %18 %9 %67
+ %69 = OpLoad %6 %68
+ %70 = OpConvertSToF %63 %69
+ %71 = OpAccessChain %19 %18 %9 %9
+ %72 = OpLoad %6 %71
+ %73 = OpConvertSToF %63 %72
+ %74 = OpAccessChain %19 %18 %9 %9
+ %75 = OpLoad %6 %74
+ %76 = OpConvertSToF %63 %75
+ %77 = OpAccessChain %19 %18 %9 %67
+ %78 = OpLoad %6 %77
+ %79 = OpConvertSToF %63 %78
+ %80 = OpCompositeConstruct %64 %70 %73 %76 %79
+ OpStore %66 %80
+ OpBranch %62
+ %81 = OpLabel
+ %82 = OpAccessChain %19 %18 %9 %9
+ %83 = OpLoad %6 %82
+ %84 = OpConvertSToF %63 %83
+ %85 = OpCompositeConstruct %64 %84 %84 %84 %84
+ OpStore %66 %85
+ OpBranch %62
+ %62 = OpLabel
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# _GLF_uniform_int_values
+BUFFER variant__GLF_uniform_int_values DATA_TYPE int32[] STD140 DATA
+ 0 3 1 2
+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_10 _GLF_uniform_int_values[0]
+# #define _int_1 _GLF_uniform_int_values[1]
+# #define _int_0 _GLF_uniform_int_values[2]
+# #define _int_2 _GLF_uniform_int_values[3]
+# #define _int_3 _GLF_uniform_int_values[4]
+# #define _int_4 _GLF_uniform_int_values[5]
+# #define _int_5 _GLF_uniform_int_values[6]
+# #define _int_6 _GLF_uniform_int_values[7]
+# #define _int_7 _GLF_uniform_int_values[8]
+# #define _int_8 _GLF_uniform_int_values[9]
+# #define _int_9 _GLF_uniform_int_values[10]
+# #define _int_11 _GLF_uniform_int_values[11]
+# #define _int_12 _GLF_uniform_int_values[12]
+# #define _int_13 _GLF_uniform_int_values[13]
+# #define _int_14 _GLF_uniform_int_values[14]
+# #define _int_15 _GLF_uniform_int_values[15]
+# #define _int_16 _GLF_uniform_int_values[16]
+# #define _int_17 _GLF_uniform_int_values[17]
+# #define _int_18 _GLF_uniform_int_values[18]
+# #define _int_19 _GLF_uniform_int_values[19]
+#
+# precision highp float;
+# precision highp int;
+#
+# // Contents of _GLF_uniform_int_values: [10, 1, 0, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 19]
+# layout(set = 0, binding = 0) uniform buf0
+# {
+# int _GLF_uniform_int_values[20];
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void main()
+# {
+# int data0[10] = int[10](_int_0, _int_1, _int_2, _int_3, _int_4, _int_5, _int_6, _int_7, _int_8, _int_9);
+# int data1[10] = int[10](_int_10, _int_11, _int_12, _int_13, _int_14, _int_15, _int_16, _int_17, _int_18, _int_19);
+#
+# data1[_int_1] = data0[_int_1];
+#
+# for(int i = _int_2; i < _int_10; i += _int_2)
+# {
+# for(int j = _int_1; j < _int_10; j += (i / _int_2))
+# {
+# // Iterates once with k = j if j <= 5.
+# for(int k = j; k <= min(j, 5); k ++)
+# {
+# data0[k] = data1[k];
+# }
+# }
+# }
+#
+# _GLF_color = vec4(_int_1, _int_0, _int_0, _int_1);
+#
+# // Compare against reference values and set output to black if failed.
+# int ref[10] = int[10](_int_0, _int_1, _int_12, _int_13, _int_14, _int_15, _int_6, _int_7, _int_8, _int_9);
+#
+# for(int i = _int_0; i < _int_10; i ++)
+# {
+# if(data0[i] != ref[i])
+# {
+# _GLF_color = vec4(_int_0);
+# }
+# }
+# }
+SHADER fragment variant_fragment_shader SPIRV-ASM TARGET_ENV spv1.0
+; SPIR-V
+; Version: 1.0
+; Generator: Khronos Glslang Reference Front End; 10
+; Bound: 214
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %145
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %11 "data0"
+ OpName %14 "buf0"
+ OpMemberName %14 0 "_GLF_uniform_int_values"
+ OpName %16 ""
+ OpName %50 "data1"
+ OpName %145 "_GLF_color"
+ OpName %159 "ref"
+ OpDecorate %13 ArrayStride 16
+ OpMemberDecorate %14 0 Offset 0
+ OpDecorate %14 Block
+ OpDecorate %16 DescriptorSet 0
+ OpDecorate %16 Binding 0
+ OpDecorate %145 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 20
+ %13 = OpTypeArray %6 %12
+ %14 = OpTypeStruct %13
+ %15 = OpTypePointer Uniform %14
+ %16 = OpVariable %15 Uniform
+ %17 = OpConstant %6 0
+ %18 = OpConstant %6 2
+ %19 = OpTypePointer Uniform %6
+ %22 = OpConstant %6 1
+ %25 = OpConstant %6 3
+ %28 = OpConstant %6 4
+ %31 = OpConstant %6 5
+ %34 = OpConstant %6 6
+ %37 = OpConstant %6 7
+ %40 = OpConstant %6 8
+ %43 = OpConstant %6 9
+ %46 = OpConstant %6 10
+ %53 = OpConstant %6 11
+ %56 = OpConstant %6 12
+ %59 = OpConstant %6 13
+ %62 = OpConstant %6 14
+ %65 = OpConstant %6 15
+ %68 = OpConstant %6 16
+ %71 = OpConstant %6 17
+ %74 = OpConstant %6 18
+ %77 = OpConstant %6 19
+ %85 = OpTypePointer Function %6
+ %100 = OpTypeBool
+ %142 = OpTypeFloat 32
+ %143 = OpTypeVector %142 4
+ %144 = OpTypePointer Output %143
+ %145 = OpVariable %144 Output
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %11 = OpVariable %10 Function
+ %50 = OpVariable %10 Function
+ %159 = OpVariable %10 Function
+ %20 = OpAccessChain %19 %16 %17 %18
+ %21 = OpLoad %6 %20
+ %23 = OpAccessChain %19 %16 %17 %22
+ %24 = OpLoad %6 %23
+ %26 = OpAccessChain %19 %16 %17 %25
+ %27 = OpLoad %6 %26
+ %29 = OpAccessChain %19 %16 %17 %28
+ %30 = OpLoad %6 %29
+ %32 = OpAccessChain %19 %16 %17 %31
+ %33 = OpLoad %6 %32
+ %35 = OpAccessChain %19 %16 %17 %34
+ %36 = OpLoad %6 %35
+ %38 = OpAccessChain %19 %16 %17 %37
+ %39 = OpLoad %6 %38
+ %41 = OpAccessChain %19 %16 %17 %40
+ %42 = OpLoad %6 %41
+ %44 = OpAccessChain %19 %16 %17 %43
+ %45 = OpLoad %6 %44
+ %47 = OpAccessChain %19 %16 %17 %46
+ %48 = OpLoad %6 %47
+ %49 = OpCompositeConstruct %9 %21 %24 %27 %30 %33 %36 %39 %42 %45 %48
+ OpStore %11 %49
+ %51 = OpAccessChain %19 %16 %17 %17
+ %52 = OpLoad %6 %51
+ %54 = OpAccessChain %19 %16 %17 %53
+ %55 = OpLoad %6 %54
+ %57 = OpAccessChain %19 %16 %17 %56
+ %58 = OpLoad %6 %57
+ %60 = OpAccessChain %19 %16 %17 %59
+ %61 = OpLoad %6 %60
+ %63 = OpAccessChain %19 %16 %17 %62
+ %64 = OpLoad %6 %63
+ %66 = OpAccessChain %19 %16 %17 %65
+ %67 = OpLoad %6 %66
+ %69 = OpAccessChain %19 %16 %17 %68
+ %70 = OpLoad %6 %69
+ %72 = OpAccessChain %19 %16 %17 %71
+ %73 = OpLoad %6 %72
+ %75 = OpAccessChain %19 %16 %17 %74
+ %76 = OpLoad %6 %75
+ %78 = OpAccessChain %19 %16 %17 %77
+ %79 = OpLoad %6 %78
+ %80 = OpCompositeConstruct %9 %52 %55 %58 %61 %64 %67 %70 %73 %76 %79
+ OpStore %50 %80
+ %86 = OpAccessChain %85 %11 %24
+ %87 = OpLoad %6 %86
+ %88 = OpAccessChain %85 %50 %24
+ OpStore %88 %87
+ OpBranch %92
+ %92 = OpLabel
+ %208 = OpPhi %6 %27 %5 %141 %95
+ %101 = OpSLessThan %100 %208 %52
+ OpLoopMerge %94 %95 None
+ OpBranchConditional %101 %93 %94
+ %93 = OpLabel
+ OpBranch %105
+ %105 = OpLabel
+ %211 = OpPhi %6 %24 %93 %137 %108
+ %113 = OpSLessThan %100 %211 %52
+ OpLoopMerge %107 %108 None
+ OpBranchConditional %113 %106 %107
+ %106 = OpLabel
+ OpBranch %116
+ %116 = OpLabel
+ %213 = OpPhi %6 %211 %106 %131 %117
+ %123 = OpExtInst %6 %1 SMin %211 %31
+ %124 = OpSLessThanEqual %100 %213 %123
+ OpLoopMerge %118 %117 None
+ OpBranchConditional %124 %117 %118
+ %117 = OpLabel
+ %127 = OpAccessChain %85 %50 %213
+ %128 = OpLoad %6 %127
+ %129 = OpAccessChain %85 %11 %213
+ OpStore %129 %128
+ %131 = OpIAdd %6 %213 %22
+ OpBranch %116
+ %118 = OpLabel
+ OpBranch %108
+ %108 = OpLabel
+ %135 = OpSDiv %6 %208 %27
+ %137 = OpIAdd %6 %211 %135
+ OpBranch %105
+ %107 = OpLabel
+ OpBranch %95
+ %95 = OpLabel
+ %141 = OpIAdd %6 %208 %27
+ OpBranch %92
+ %94 = OpLabel
+ %148 = OpConvertSToF %142 %24
+ %151 = OpConvertSToF %142 %21
+ %158 = OpCompositeConstruct %143 %148 %151 %151 %148
+ OpStore %145 %158
+ %180 = OpCompositeConstruct %9 %21 %24 %58 %61 %64 %67 %39 %42 %45 %48
+ OpStore %159 %180
+ OpBranch %184
+ %184 = OpLabel
+ %209 = OpPhi %6 %21 %94 %207 %187
+ %192 = OpSLessThan %100 %209 %52
+ OpLoopMerge %186 %187 None
+ OpBranchConditional %192 %185 %186
+ %185 = OpLabel
+ %194 = OpAccessChain %85 %11 %209
+ %195 = OpLoad %6 %194
+ %197 = OpAccessChain %85 %159 %209
+ %198 = OpLoad %6 %197
+ %199 = OpINotEqual %100 %195 %198
+ OpSelectionMerge %201 None
+ OpBranchConditional %199 %200 %201
+ %200 = OpLabel
+ %205 = OpCompositeConstruct %143 %151 %151 %151 %151
+ OpStore %145 %205
+ OpBranch %201
+ %201 = OpLabel
+ OpBranch %187
+ %187 = OpLabel
+ %207 = OpIAdd %6 %209 %22
+ OpBranch %184
+ %186 = OpLabel
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# _GLF_uniform_int_values
+BUFFER variant__GLF_uniform_int_values DATA_TYPE int32[] STD140 DATA
+ 10 1 0 2 3 4 5 6 7 8 9 11 12 13 14 15 16 17 18 19
+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()
+# {
+# _GLF_color = vec4(_int_0);
+#
+# // Iterates once with i = 1.
+# for(int i = 1; i <= 1; i *= 2)
+# {
+# // Iterates once with j = 0.
+# for(int j = 0; j < 1; j += 2 * i)
+# {
+# // k = 1 + 0 + 1 = 2
+# int k = i + j + 1;
+#
+# // Never iterates.
+# while((j + i) >= _int_1 && k <= min(j + 2 * i, 1))
+# {
+# return;
+# }
+# }
+# }
+#
+# _GLF_color = vec4(_int_1, _int_0, _int_0, _int_1);
+# }
+SHADER fragment variant_fragment_shader SPIRV-ASM TARGET_ENV spv1.0
+; SPIR-V
+; Version: 1.0
+; Generator: Khronos Glslang Reference Front End; 10
+; Bound: 89
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %9
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %9 "_GLF_color"
+ OpName %14 "buf0"
+ OpMemberName %14 0 "_GLF_uniform_int_values"
+ OpName %16 ""
+ OpName %25 "i"
+ OpName %34 "j"
+ OpName %42 "k"
+ OpDecorate %9 Location 0
+ OpDecorate %13 ArrayStride 16
+ OpMemberDecorate %14 0 Offset 0
+ OpDecorate %14 Block
+ OpDecorate %16 DescriptorSet 0
+ OpDecorate %16 Binding 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeFloat 32
+ %7 = OpTypeVector %6 4
+ %8 = OpTypePointer Output %7
+ %9 = OpVariable %8 Output
+ %10 = OpTypeInt 32 1
+ %11 = OpTypeInt 32 0
+ %12 = OpConstant %11 2
+ %13 = OpTypeArray %10 %12
+ %14 = OpTypeStruct %13
+ %15 = OpTypePointer Uniform %14
+ %16 = OpVariable %15 Uniform
+ %17 = OpConstant %10 0
+ %18 = OpConstant %10 1
+ %19 = OpTypePointer Uniform %10
+ %24 = OpTypePointer Function %10
+ %32 = OpTypeBool
+ %62 = OpConstant %10 2
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %25 = OpVariable %24 Function
+ %34 = OpVariable %24 Function
+ %42 = OpVariable %24 Function
+ %20 = OpAccessChain %19 %16 %17 %18
+ %21 = OpLoad %10 %20
+ %22 = OpConvertSToF %6 %21
+ %23 = OpCompositeConstruct %7 %22 %22 %22 %22
+ OpStore %9 %23
+ OpStore %25 %18
+ OpBranch %26
+ %26 = OpLabel
+ OpLoopMerge %28 %29 None
+ OpBranch %30
+ %30 = OpLabel
+ %31 = OpLoad %10 %25
+ %33 = OpSLessThanEqual %32 %31 %18
+ OpBranchConditional %33 %27 %28
+ %27 = OpLabel
+ OpStore %34 %17
+ OpBranch %35
+ %35 = OpLabel
+ OpLoopMerge %37 %38 None
+ OpBranch %39
+ %39 = OpLabel
+ %40 = OpLoad %10 %34
+ %41 = OpSLessThan %32 %40 %18
+ OpBranchConditional %41 %36 %37
+ %36 = OpLabel
+ %43 = OpLoad %10 %25
+ %44 = OpLoad %10 %34
+ %45 = OpIAdd %10 %43 %44
+ %46 = OpIAdd %10 %45 %18
+ OpStore %42 %46
+ OpBranch %47
+ %47 = OpLabel
+ OpLoopMerge %49 %50 None
+ OpBranch %51
+ %51 = OpLabel
+ %52 = OpLoad %10 %34
+ %53 = OpLoad %10 %25
+ %54 = OpIAdd %10 %52 %53
+ %55 = OpAccessChain %19 %16 %17 %17
+ %56 = OpLoad %10 %55
+ %57 = OpSGreaterThanEqual %32 %54 %56
+ OpSelectionMerge %59 None
+ OpBranchConditional %57 %58 %59
+ %58 = OpLabel
+ %60 = OpLoad %10 %42
+ %61 = OpLoad %10 %34
+ %63 = OpLoad %10 %25
+ %64 = OpIMul %10 %62 %63
+ %65 = OpIAdd %10 %61 %64
+ %66 = OpExtInst %10 %1 SMin %65 %18
+ %67 = OpSLessThanEqual %32 %60 %66
+ OpBranch %59
+ %59 = OpLabel
+ %68 = OpPhi %32 %57 %51 %67 %58
+ OpBranchConditional %68 %48 %49
+ %48 = OpLabel
+ OpReturn
+ %50 = OpLabel
+ OpBranch %47
+ %49 = OpLabel
+ OpBranch %38
+ %38 = OpLabel
+ %70 = OpLoad %10 %25
+ %71 = OpIMul %10 %62 %70
+ %72 = OpLoad %10 %34
+ %73 = OpIAdd %10 %72 %71
+ OpStore %34 %73
+ OpBranch %35
+ %37 = OpLabel
+ OpBranch %29
+ %29 = OpLabel
+ %74 = OpLoad %10 %25
+ %75 = OpIMul %10 %74 %62
+ OpStore %25 %75
+ OpBranch %26
+ %28 = OpLabel
+ %76 = OpAccessChain %19 %16 %17 %17
+ %77 = OpLoad %10 %76
+ %78 = OpConvertSToF %6 %77
+ %79 = OpAccessChain %19 %16 %17 %18
+ %80 = OpLoad %10 %79
+ %81 = OpConvertSToF %6 %80
+ %82 = OpAccessChain %19 %16 %17 %18
+ %83 = OpLoad %10 %82
+ %84 = OpConvertSToF %6 %83
+ %85 = OpAccessChain %19 %16 %17 %17
+ %86 = OpLoad %10 %85
+ %87 = OpConvertSToF %6 %86
+ %88 = OpCompositeConstruct %7 %78 %81 %84 %87
+ OpStore %9 %88
+ 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]
+# #define _int_2 _GLF_uniform_int_values[2]
+# #define _int_3 _GLF_uniform_int_values[3]
+# #define _float_1_0 _GLF_uniform_float_values[0]
+# #define _float_9_0 _GLF_uniform_float_values[1]
+# #define _float_10_0 _GLF_uniform_float_values[2]
+# #define _float_2_0 _GLF_uniform_float_values[3]
+#
+# precision highp float;
+# precision highp int;
+#
+# // Contents of _GLF_uniform_int_values: [1, 0, 2, 3]
+# layout(set = 0, binding = 0) uniform buf0
+# {
+# int _GLF_uniform_int_values[4];
+# };
+#
+# // Contents of _GLF_uniform_float_values: [1.0, 9.0, 10.0, 2.0]
+# layout(set = 0, binding = 1) uniform buf1
+# {
+# float _GLF_uniform_float_values[4];
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void main()
+# {
+# float f = _float_2_0;
+# mat4 m = mat4(_float_1_0);
+# int a = 1;
+#
+# // i = 1: m[1][1] = m[1][1] - 5 * 2 = 1 - 10 = -9.
+# // i = 2: m[1][2] = m[1][1] - 1 = -9 - 1 = -10.
+# // i = 3: m[1][3] = m[1][1] - 1 = -9 - 1 = -10.
+# for(int i = 1; i < 4; i ++)
+# {
+# // Always false.
+# if(gl_FragCoord.x < 0.0)
+# {
+# break;
+# }
+#
+# // Always false.
+# if(a ++ >= 5)
+# {
+# break;
+# }
+#
+# for(int j = 1; j < 6; j++)
+# {
+# m[_int_1][i] = m[_int_1][_int_1] - f;
+# }
+#
+# f = _float_1_0;
+# }
+#
+# mat4 ref = mat4(_float_1_0);
+# ref[1][1] = -9.0;
+# ref[1][2] = -10.0;
+# ref[1][3] = -10.0;
+#
+# // Always true.
+# if(m == ref)
+# {
+# _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: 156
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %48 %137
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %8 "f"
+ OpName %12 "buf1"
+ OpMemberName %12 0 "_GLF_uniform_float_values"
+ OpName %14 ""
+ OpName %24 "m"
+ OpName %35 "a"
+ OpName %37 "i"
+ OpName %48 "gl_FragCoord"
+ OpName %64 "j"
+ OpName %74 "buf0"
+ OpMemberName %74 0 "_GLF_uniform_int_values"
+ OpName %76 ""
+ OpName %96 "ref"
+ OpName %137 "_GLF_color"
+ OpDecorate %11 ArrayStride 16
+ OpMemberDecorate %12 0 Offset 0
+ OpDecorate %12 Block
+ OpDecorate %14 DescriptorSet 0
+ OpDecorate %14 Binding 1
+ OpDecorate %48 BuiltIn FragCoord
+ OpDecorate %73 ArrayStride 16
+ OpMemberDecorate %74 0 Offset 0
+ OpDecorate %74 Block
+ OpDecorate %76 DescriptorSet 0
+ OpDecorate %76 Binding 0
+ OpDecorate %137 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeFloat 32
+ %7 = OpTypePointer Function %6
+ %9 = OpTypeInt 32 0
+ %10 = OpConstant %9 4
+ %11 = OpTypeArray %6 %10
+ %12 = OpTypeStruct %11
+ %13 = OpTypePointer Uniform %12
+ %14 = OpVariable %13 Uniform
+ %15 = OpTypeInt 32 1
+ %16 = OpConstant %15 0
+ %17 = OpConstant %15 3
+ %18 = OpTypePointer Uniform %6
+ %21 = OpTypeVector %6 4
+ %22 = OpTypeMatrix %21 4
+ %23 = OpTypePointer Function %22
+ %27 = OpConstant %6 1
+ %28 = OpConstant %6 0
+ %34 = OpTypePointer Function %15
+ %36 = OpConstant %15 1
+ %44 = OpConstant %15 4
+ %45 = OpTypeBool
+ %47 = OpTypePointer Input %21
+ %48 = OpVariable %47 Input
+ %49 = OpConstant %9 0
+ %50 = OpTypePointer Input %6
+ %59 = OpConstant %15 5
+ %71 = OpConstant %15 6
+ %73 = OpTypeArray %15 %10
+ %74 = OpTypeStruct %73
+ %75 = OpTypePointer Uniform %74
+ %76 = OpVariable %75 Uniform
+ %77 = OpTypePointer Uniform %15
+ %104 = OpConstant %6 -9
+ %105 = OpConstant %9 1
+ %107 = OpConstant %6 -10
+ %108 = OpConstant %9 2
+ %110 = OpConstant %9 3
+ %116 = OpTypeVector %45 4
+ %136 = OpTypePointer Output %21
+ %137 = OpVariable %136 Output
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %8 = OpVariable %7 Function
+ %24 = OpVariable %23 Function
+ %35 = OpVariable %34 Function
+ %37 = OpVariable %34 Function
+ %64 = OpVariable %34 Function
+ %96 = OpVariable %23 Function
+ %19 = OpAccessChain %18 %14 %16 %17
+ %20 = OpLoad %6 %19
+ OpStore %8 %20
+ %25 = OpAccessChain %18 %14 %16 %16
+ %26 = OpLoad %6 %25
+ %29 = OpCompositeConstruct %21 %26 %28 %28 %28
+ %30 = OpCompositeConstruct %21 %28 %26 %28 %28
+ %31 = OpCompositeConstruct %21 %28 %28 %26 %28
+ %32 = OpCompositeConstruct %21 %28 %28 %28 %26
+ %33 = OpCompositeConstruct %22 %29 %30 %31 %32
+ OpStore %24 %33
+ OpStore %35 %36
+ OpStore %37 %36
+ OpBranch %38
+ %38 = OpLabel
+ OpLoopMerge %40 %41 None
+ OpBranch %42
+ %42 = OpLabel
+ %43 = OpLoad %15 %37
+ %46 = OpSLessThan %45 %43 %44
+ OpBranchConditional %46 %39 %40
+ %39 = OpLabel
+ %51 = OpAccessChain %50 %48 %49
+ %52 = OpLoad %6 %51
+ %53 = OpFOrdLessThan %45 %52 %28
+ OpSelectionMerge %55 None
+ OpBranchConditional %53 %54 %55
+ %54 = OpLabel
+ OpBranch %40
+ %55 = OpLabel
+ %57 = OpLoad %15 %35
+ %58 = OpIAdd %15 %57 %36
+ OpStore %35 %58
+ %60 = OpSGreaterThanEqual %45 %57 %59
+ OpSelectionMerge %62 None
+ OpBranchConditional %60 %61 %62
+ %61 = OpLabel
+ OpBranch %40
+ %62 = OpLabel
+ OpStore %64 %36
+ OpBranch %65
+ %65 = OpLabel
+ OpLoopMerge %67 %68 None
+ OpBranch %69
+ %69 = OpLabel
+ %70 = OpLoad %15 %64
+ %72 = OpSLessThan %45 %70 %71
+ OpBranchConditional %72 %66 %67
+ %66 = OpLabel
+ %78 = OpAccessChain %77 %76 %16 %16
+ %79 = OpLoad %15 %78
+ %80 = OpLoad %15 %37
+ %81 = OpAccessChain %77 %76 %16 %16
+ %82 = OpLoad %15 %81
+ %83 = OpAccessChain %77 %76 %16 %16
+ %84 = OpLoad %15 %83
+ %85 = OpAccessChain %7 %24 %82 %84
+ %86 = OpLoad %6 %85
+ %87 = OpLoad %6 %8
+ %88 = OpFSub %6 %86 %87
+ %89 = OpAccessChain %7 %24 %79 %80
+ OpStore %89 %88
+ OpBranch %68
+ %68 = OpLabel
+ %90 = OpLoad %15 %64
+ %91 = OpIAdd %15 %90 %36
+ OpStore %64 %91
+ OpBranch %65
+ %67 = OpLabel
+ %92 = OpAccessChain %18 %14 %16 %16
+ %93 = OpLoad %6 %92
+ OpStore %8 %93
+ OpBranch %41
+ %41 = OpLabel
+ %94 = OpLoad %15 %37
+ %95 = OpIAdd %15 %94 %36
+ OpStore %37 %95
+ OpBranch %38
+ %40 = OpLabel
+ %97 = OpAccessChain %18 %14 %16 %16
+ %98 = OpLoad %6 %97
+ %99 = OpCompositeConstruct %21 %98 %28 %28 %28
+ %100 = OpCompositeConstruct %21 %28 %98 %28 %28
+ %101 = OpCompositeConstruct %21 %28 %28 %98 %28
+ %102 = OpCompositeConstruct %21 %28 %28 %28 %98
+ %103 = OpCompositeConstruct %22 %99 %100 %101 %102
+ OpStore %96 %103
+ %106 = OpAccessChain %7 %96 %36 %105
+ OpStore %106 %104
+ %109 = OpAccessChain %7 %96 %36 %108
+ OpStore %109 %107
+ %111 = OpAccessChain %7 %96 %36 %110
+ OpStore %111 %107
+ %112 = OpLoad %22 %24
+ %113 = OpLoad %22 %96
+ %114 = OpCompositeExtract %21 %112 0
+ %115 = OpCompositeExtract %21 %113 0
+ %117 = OpFOrdEqual %116 %114 %115
+ %118 = OpAll %45 %117
+ %119 = OpCompositeExtract %21 %112 1
+ %120 = OpCompositeExtract %21 %113 1
+ %121 = OpFOrdEqual %116 %119 %120
+ %122 = OpAll %45 %121
+ %123 = OpLogicalAnd %45 %118 %122
+ %124 = OpCompositeExtract %21 %112 2
+ %125 = OpCompositeExtract %21 %113 2
+ %126 = OpFOrdEqual %116 %124 %125
+ %127 = OpAll %45 %126
+ %128 = OpLogicalAnd %45 %123 %127
+ %129 = OpCompositeExtract %21 %112 3
+ %130 = OpCompositeExtract %21 %113 3
+ %131 = OpFOrdEqual %116 %129 %130
+ %132 = OpAll %45 %131
+ %133 = OpLogicalAnd %45 %128 %132
+ OpSelectionMerge %135 None
+ OpBranchConditional %133 %134 %151
+ %134 = OpLabel
+ %138 = OpAccessChain %77 %76 %16 %16
+ %139 = OpLoad %15 %138
+ %140 = OpConvertSToF %6 %139
+ %141 = OpAccessChain %77 %76 %16 %36
+ %142 = OpLoad %15 %141
+ %143 = OpConvertSToF %6 %142
+ %144 = OpAccessChain %77 %76 %16 %36
+ %145 = OpLoad %15 %144
+ %146 = OpConvertSToF %6 %145
+ %147 = OpAccessChain %77 %76 %16 %16
+ %148 = OpLoad %15 %147
+ %149 = OpConvertSToF %6 %148
+ %150 = OpCompositeConstruct %21 %140 %143 %146 %149
+ OpStore %137 %150
+ OpBranch %135
+ %151 = OpLabel
+ %152 = OpAccessChain %77 %76 %16 %36
+ %153 = OpLoad %15 %152
+ %154 = OpConvertSToF %6 %153
+ %155 = OpCompositeConstruct %21 %154 %154 %154 %154
+ OpStore %137 %155
+ OpBranch %135
+ %135 = OpLabel
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# _GLF_uniform_float_values
+BUFFER variant__GLF_uniform_float_values DATA_TYPE float[] STD140 DATA
+ 1.0 9.0 10.0 2.0
+END
+# _GLF_uniform_int_values
+BUFFER variant__GLF_uniform_int_values DATA_TYPE int32[] STD140 DATA
+ 1 0 2 3
+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_2 _GLF_uniform_int_values[0]
+# #define _int_1 _GLF_uniform_int_values[1]
+# #define _int_0 _GLF_uniform_int_values[2]
+# #define _int_4 _GLF_uniform_int_values[3]
+# #define _int_5 _GLF_uniform_int_values[4]
+# #define _int_7 _GLF_uniform_int_values[5]
+#
+# precision highp float;
+# precision highp int;
+#
+# // Contents of _GLF_uniform_int_values: [2, 1, 0, 4, 5, 7]
+# layout(set = 0, binding = 0) uniform buf0
+# {
+# int _GLF_uniform_int_values[6];
+# };
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void main()
+# {
+# int arr[3] = int[3](_int_0, _int_1, _int_2);
+# int a = 1;
+#
+# // Iterates three times.
+# for(int i = 2; i < 5; i++)
+# {
+# int b = _int_1;
+#
+# // Iterates three times.
+# while(i > _int_1)
+# {
+# if(b >= _int_4)
+# {
+# break;
+# }
+# b++;
+#
+# switch(a)
+# {
+# case 1:
+# arr[a]++;
+# // Fallthrough makes arr[1] to increment by two.
+# case 2:
+# arr[a]++;
+# }
+# }
+#
+# a++;
+# }
+#
+# // Always true.
+# if(arr[_int_0] == _int_0 && arr[_int_1] == _int_7 && arr[_int_2] == _int_5)
+# {
+# _GLF_color = vec4(_int_1, _int_0, _int_0, _int_1);
+# }
+# else
+# {
+# _GLF_color = vec4(_int_0);
+# }
+# }
+SHADER fragment variant_fragment_shader SPIRV-ASM TARGET_ENV spv1.0
+; SPIR-V
+; Version: 1.0
+; Generator: Khronos Glslang Reference Front End; 10
+; Bound: 131
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %112
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %11 "arr"
+ OpName %14 "buf0"
+ OpMemberName %14 0 "_GLF_uniform_int_values"
+ OpName %16 ""
+ OpName %29 "a"
+ OpName %30 "i"
+ OpName %40 "b"
+ OpName %112 "_GLF_color"
+ OpDecorate %13 ArrayStride 16
+ OpMemberDecorate %14 0 Offset 0
+ OpDecorate %14 Block
+ OpDecorate %16 DescriptorSet 0
+ OpDecorate %16 Binding 0
+ OpDecorate %112 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeInt 32 1
+ %7 = OpTypeInt 32 0
+ %8 = OpConstant %7 3
+ %9 = OpTypeArray %6 %8
+ %10 = OpTypePointer Function %9
+ %12 = OpConstant %7 6
+ %13 = OpTypeArray %6 %12
+ %14 = OpTypeStruct %13
+ %15 = OpTypePointer Uniform %14
+ %16 = OpVariable %15 Uniform
+ %17 = OpConstant %6 0
+ %18 = OpConstant %6 2
+ %19 = OpTypePointer Uniform %6
+ %22 = OpConstant %6 1
+ %28 = OpTypePointer Function %6
+ %37 = OpConstant %6 5
+ %38 = OpTypeBool
+ %53 = OpConstant %6 3
+ %102 = OpConstant %6 4
+ %109 = OpTypeFloat 32
+ %110 = OpTypeVector %109 4
+ %111 = OpTypePointer Output %110
+ %112 = OpVariable %111 Output
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %11 = OpVariable %10 Function
+ %29 = OpVariable %28 Function
+ %30 = OpVariable %28 Function
+ %40 = OpVariable %28 Function
+ %20 = OpAccessChain %19 %16 %17 %18
+ %21 = OpLoad %6 %20
+ %23 = OpAccessChain %19 %16 %17 %22
+ %24 = OpLoad %6 %23
+ %25 = OpAccessChain %19 %16 %17 %17
+ %26 = OpLoad %6 %25
+ %27 = OpCompositeConstruct %9 %21 %24 %26
+ OpStore %11 %27
+ OpStore %29 %22
+ OpStore %30 %18
+ 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
+ %41 = OpAccessChain %19 %16 %17 %22
+ %42 = OpLoad %6 %41
+ OpStore %40 %42
+ OpBranch %43
+ %43 = OpLabel
+ OpLoopMerge %45 %46 None
+ OpBranch %47
+ %47 = OpLabel
+ %48 = OpLoad %6 %30
+ %49 = OpAccessChain %19 %16 %17 %22
+ %50 = OpLoad %6 %49
+ %51 = OpSGreaterThan %38 %48 %50
+ OpBranchConditional %51 %44 %45
+ %44 = OpLabel
+ %52 = OpLoad %6 %40
+ %54 = OpAccessChain %19 %16 %17 %53
+ %55 = OpLoad %6 %54
+ %56 = OpSGreaterThanEqual %38 %52 %55
+ OpSelectionMerge %58 None
+ OpBranchConditional %56 %57 %58
+ %57 = OpLabel
+ OpBranch %45
+ %58 = OpLabel
+ %60 = OpLoad %6 %40
+ %61 = OpIAdd %6 %60 %22
+ OpStore %40 %61
+ %62 = OpLoad %6 %29
+ OpSelectionMerge %65 None
+ OpSwitch %62 %65 1 %63 2 %64
+ %63 = OpLabel
+ %66 = OpLoad %6 %29
+ %67 = OpAccessChain %28 %11 %66
+ %68 = OpLoad %6 %67
+ %69 = OpIAdd %6 %68 %22
+ OpStore %67 %69
+ OpBranch %64
+ %64 = OpLabel
+ %70 = OpLoad %6 %29
+ %71 = OpAccessChain %28 %11 %70
+ %72 = OpLoad %6 %71
+ %73 = OpIAdd %6 %72 %22
+ OpStore %71 %73
+ OpBranch %65
+ %65 = OpLabel
+ OpBranch %46
+ %46 = OpLabel
+ OpBranch %43
+ %45 = OpLabel
+ %75 = OpLoad %6 %29
+ %76 = OpIAdd %6 %75 %22
+ OpStore %29 %76
+ OpBranch %34
+ %34 = OpLabel
+ %77 = OpLoad %6 %30
+ %78 = OpIAdd %6 %77 %22
+ OpStore %30 %78
+ OpBranch %31
+ %33 = OpLabel
+ %79 = OpAccessChain %19 %16 %17 %18
+ %80 = OpLoad %6 %79
+ %81 = OpAccessChain %28 %11 %80
+ %82 = OpLoad %6 %81
+ %83 = OpAccessChain %19 %16 %17 %18
+ %84 = OpLoad %6 %83
+ %85 = OpIEqual %38 %82 %84
+ OpSelectionMerge %87 None
+ OpBranchConditional %85 %86 %87
+ %86 = OpLabel
+ %88 = OpAccessChain %19 %16 %17 %22
+ %89 = OpLoad %6 %88
+ %90 = OpAccessChain %28 %11 %89
+ %91 = OpLoad %6 %90
+ %92 = OpAccessChain %19 %16 %17 %37
+ %93 = OpLoad %6 %92
+ %94 = OpIEqual %38 %91 %93
+ OpBranch %87
+ %87 = OpLabel
+ %95 = OpPhi %38 %85 %33 %94 %86
+ OpSelectionMerge %97 None
+ OpBranchConditional %95 %96 %97
+ %96 = OpLabel
+ %98 = OpAccessChain %19 %16 %17 %17
+ %99 = OpLoad %6 %98
+ %100 = OpAccessChain %28 %11 %99
+ %101 = OpLoad %6 %100
+ %103 = OpAccessChain %19 %16 %17 %102
+ %104 = OpLoad %6 %103
+ %105 = OpIEqual %38 %101 %104
+ OpBranch %97
+ %97 = OpLabel
+ %106 = OpPhi %38 %95 %87 %105 %96
+ OpSelectionMerge %108 None
+ OpBranchConditional %106 %107 %126
+ %107 = OpLabel
+ %113 = OpAccessChain %19 %16 %17 %22
+ %114 = OpLoad %6 %113
+ %115 = OpConvertSToF %109 %114
+ %116 = OpAccessChain %19 %16 %17 %18
+ %117 = OpLoad %6 %116
+ %118 = OpConvertSToF %109 %117
+ %119 = OpAccessChain %19 %16 %17 %18
+ %120 = OpLoad %6 %119
+ %121 = OpConvertSToF %109 %120
+ %122 = OpAccessChain %19 %16 %17 %22
+ %123 = OpLoad %6 %122
+ %124 = OpConvertSToF %109 %123
+ %125 = OpCompositeConstruct %110 %115 %118 %121 %124
+ OpStore %112 %125
+ OpBranch %108
+ %126 = OpLabel
+ %127 = OpAccessChain %19 %16 %17 %18
+ %128 = OpLoad %6 %127
+ %129 = OpConvertSToF %109 %128
+ %130 = OpCompositeConstruct %110 %129 %129 %129 %129
+ OpStore %112 %130
+ OpBranch %108
+ %108 = 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 4 5 7
+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_20 _GLF_uniform_int_values[0]
+# #define _int_1 _GLF_uniform_int_values[1]
+# #define _int_0 _GLF_uniform_int_values[2]
+# #define _int_5 _GLF_uniform_int_values[3]
+# #define _int_3 _GLF_uniform_int_values[4]
+# #define _float_0_0 _GLF_uniform_float_values[0]
+#
+# precision highp float;
+# precision highp int;
+#
+# // Contents of _GLF_uniform_float_values: 0.0
+# layout(set = 0, binding = 0) uniform buf0
+# {
+# float _GLF_uniform_float_values[1];
+# };
+#
+# // Contents of _GLF_uniform_int_values: [20, 1, 0, 5, 3]
+# layout(set = 0, binding = 1) uniform buf1
+# {
+# int _GLF_uniform_int_values[5];
+# };
+#
+# const int _GLF_global_loop_bound = 10;
+# int _GLF_global_loop_count = 0;
+#
+# layout(location = 0) out vec4 _GLF_color;
+#
+# void main()
+# {
+# int a = _int_1;
+#
+# for(int i = _int_0; i < _int_3; i++)
+# {
+# // Always true.
+# if(gl_FragCoord.x > _float_0_0)
+# {
+# a++;
+# }
+# }
+#
+# while(_GLF_global_loop_count < _GLF_global_loop_bound)
+# {
+# _GLF_global_loop_count ++;
+#
+# // Breaks when a is five.
+# if(a * a + _int_1 > _int_20)
+# {
+# break;
+# }
+#
+# a++;
+# }
+#
+# // Always true.
+# if(a == _int_5)
+# {
+# _GLF_color = vec4(_int_1, _int_0, _int_0, _int_1);
+# }
+# else
+# {
+# _GLF_color = vec4(_int_0);
+# }
+# }
+SHADER fragment variant_fragment_shader SPIRV-ASM TARGET_ENV spv1.0
+; SPIR-V
+; Version: 1.0
+; Generator: Khronos Glslang Reference Front End; 10
+; Bound: 111
+; Schema: 0
+ OpCapability Shader
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %4 "main" %40 %92
+ OpExecutionMode %4 OriginUpperLeft
+ OpSource ESSL 320
+ OpName %4 "main"
+ OpName %8 "_GLF_global_loop_count"
+ OpName %11 "a"
+ OpName %15 "buf1"
+ OpMemberName %15 0 "_GLF_uniform_int_values"
+ OpName %17 ""
+ OpName %22 "i"
+ OpName %40 "gl_FragCoord"
+ OpName %47 "buf0"
+ OpMemberName %47 0 "_GLF_uniform_float_values"
+ OpName %49 ""
+ OpName %92 "_GLF_color"
+ OpDecorate %14 ArrayStride 16
+ OpMemberDecorate %15 0 Offset 0
+ OpDecorate %15 Block
+ OpDecorate %17 DescriptorSet 0
+ OpDecorate %17 Binding 1
+ OpDecorate %40 BuiltIn FragCoord
+ OpDecorate %46 ArrayStride 16
+ OpMemberDecorate %47 0 Offset 0
+ OpDecorate %47 Block
+ OpDecorate %49 DescriptorSet 0
+ OpDecorate %49 Binding 0
+ OpDecorate %92 Location 0
+ %2 = OpTypeVoid
+ %3 = OpTypeFunction %2
+ %6 = OpTypeInt 32 1
+ %7 = OpTypePointer Private %6
+ %8 = OpVariable %7 Private
+ %9 = OpConstant %6 0
+ %10 = OpTypePointer Function %6
+ %12 = OpTypeInt 32 0
+ %13 = OpConstant %12 5
+ %14 = OpTypeArray %6 %13
+ %15 = OpTypeStruct %14
+ %16 = OpTypePointer Uniform %15
+ %17 = OpVariable %16 Uniform
+ %18 = OpConstant %6 1
+ %19 = OpTypePointer Uniform %6
+ %23 = OpConstant %6 2
+ %32 = OpConstant %6 4
+ %35 = OpTypeBool
+ %37 = OpTypeFloat 32
+ %38 = OpTypeVector %37 4
+ %39 = OpTypePointer Input %38
+ %40 = OpVariable %39 Input
+ %41 = OpConstant %12 0
+ %42 = OpTypePointer Input %37
+ %45 = OpConstant %12 1
+ %46 = OpTypeArray %37 %45
+ %47 = OpTypeStruct %46
+ %48 = OpTypePointer Uniform %47
+ %49 = OpVariable %48 Uniform
+ %50 = OpTypePointer Uniform %37
+ %66 = OpConstant %6 10
+ %85 = OpConstant %6 3
+ %91 = OpTypePointer Output %38
+ %92 = OpVariable %91 Output
+ %4 = OpFunction %2 None %3
+ %5 = OpLabel
+ %11 = OpVariable %10 Function
+ %22 = OpVariable %10 Function
+ OpStore %8 %9
+ %20 = OpAccessChain %19 %17 %9 %18
+ %21 = OpLoad %6 %20
+ OpStore %11 %21
+ %24 = OpAccessChain %19 %17 %9 %23
+ %25 = OpLoad %6 %24
+ OpStore %22 %25
+ OpBranch %26
+ %26 = OpLabel
+ OpLoopMerge %28 %29 None
+ OpBranch %30
+ %30 = OpLabel
+ %31 = OpLoad %6 %22
+ %33 = OpAccessChain %19 %17 %9 %32
+ %34 = OpLoad %6 %33
+ %36 = OpSLessThan %35 %31 %34
+ OpBranchConditional %36 %27 %28
+ %27 = OpLabel
+ %43 = OpAccessChain %42 %40 %41
+ %44 = OpLoad %37 %43
+ %51 = OpAccessChain %50 %49 %9 %9
+ %52 = OpLoad %37 %51
+ %53 = OpFOrdGreaterThan %35 %44 %52
+ OpSelectionMerge %55 None
+ OpBranchConditional %53 %54 %55
+ %54 = OpLabel
+ %56 = OpLoad %6 %11
+ %57 = OpIAdd %6 %56 %18
+ OpStore %11 %57
+ OpBranch %55
+ %55 = OpLabel
+ OpBranch %29
+ %29 = OpLabel
+ %58 = OpLoad %6 %22
+ %59 = OpIAdd %6 %58 %18
+ OpStore %22 %59
+ OpBranch %26
+ %28 = OpLabel
+ OpBranch %60
+ %60 = OpLabel
+ OpLoopMerge %62 %63 None
+ OpBranch %64
+ %64 = OpLabel
+ %65 = OpLoad %6 %8
+ %67 = OpSLessThan %35 %65 %66
+ OpBranchConditional %67 %61 %62
+ %61 = OpLabel
+ %68 = OpLoad %6 %8
+ %69 = OpIAdd %6 %68 %18
+ OpStore %8 %69
+ %70 = OpLoad %6 %11
+ %71 = OpLoad %6 %11
+ %72 = OpIMul %6 %70 %71
+ %73 = OpAccessChain %19 %17 %9 %18
+ %74 = OpLoad %6 %73
+ %75 = OpIAdd %6 %72 %74
+ %76 = OpAccessChain %19 %17 %9 %9
+ %77 = OpLoad %6 %76
+ %78 = OpSGreaterThan %35 %75 %77
+ OpSelectionMerge %80 None
+ OpBranchConditional %78 %79 %80
+ %79 = OpLabel
+ OpBranch %62
+ %80 = OpLabel
+ %82 = OpLoad %6 %11
+ %83 = OpIAdd %6 %82 %18
+ OpStore %11 %83
+ OpBranch %63
+ %63 = OpLabel
+ OpBranch %60
+ %62 = OpLabel
+ %84 = OpLoad %6 %11
+ %86 = OpAccessChain %19 %17 %9 %85
+ %87 = OpLoad %6 %86
+ %88 = OpIEqual %35 %84 %87
+ OpSelectionMerge %90 None
+ OpBranchConditional %88 %89 %106
+ %89 = OpLabel
+ %93 = OpAccessChain %19 %17 %9 %18
+ %94 = OpLoad %6 %93
+ %95 = OpConvertSToF %37 %94
+ %96 = OpAccessChain %19 %17 %9 %23
+ %97 = OpLoad %6 %96
+ %98 = OpConvertSToF %37 %97
+ %99 = OpAccessChain %19 %17 %9 %23
+ %100 = OpLoad %6 %99
+ %101 = OpConvertSToF %37 %100
+ %102 = OpAccessChain %19 %17 %9 %18
+ %103 = OpLoad %6 %102
+ %104 = OpConvertSToF %37 %103
+ %105 = OpCompositeConstruct %38 %95 %98 %101 %104
+ OpStore %92 %105
+ OpBranch %90
+ %106 = OpLabel
+ %107 = OpAccessChain %19 %17 %9 %23
+ %108 = OpLoad %6 %107
+ %109 = OpConvertSToF %37 %108
+ %110 = OpCompositeConstruct %38 %109 %109 %109 %109
+ OpStore %92 %110
+ OpBranch %90
+ %90 = OpLabel
+ OpReturn
+ OpFunctionEnd
+END
+
+# uniforms for variant
+
+# _GLF_uniform_int_values
+BUFFER variant__GLF_uniform_int_values DATA_TYPE int32[] STD140 DATA
+ 20 1 0 5 3
+END
+# _GLF_uniform_float_values
+BUFFER variant__GLF_uniform_float_values DATA_TYPE float[] STD140 DATA
+ 0.0
+END
+
+BUFFER variant_framebuffer FORMAT B8G8R8A8_UNORM
+
+PIPELINE graphics variant_pipeline
+ ATTACH variant_vertex_shader
+ ATTACH variant_fragment_shader
+ FRAMEBUFFER_SIZE 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
{ "cov-apfloat-reflect-denorm.amber", "cov-apfloat-reflect-denorm", "A fragment shader that covers a specific floating point code path" },
{ "cov-apfloat-unpackunorm-loop.amber", "cov-apfloat-unpackunorm-loop", "A fragment shader that covers a specific floating point code path" },
{ "cov-array-accesses-clamp.amber", "cov-array-accesses-clamp", "A fragment shader that covers a specific inst combine select path" },
+{ "cov-array-cast-bool-float-div-by-zero-no-effect.amber", "cov-array-cast-bool-float-div-by-zero-no-effect", "A fragment shader that covers specific LLVM code paths" },
{ "cov-array-copies-loops-with-limiters.amber", "cov-array-copies-loops-with-limiters", "A fragment shader that covers specific NIR code paths" },
+{ "cov-array-set-element-condition-negative-modulus.amber", "cov-array-set-element-condition-negative-modulus", "A fragment shader that covers specific LLVM code paths" },
{ "cov-asin-undefined-smoothstep.amber", "cov-asin-undefined-smoothstep", "A fragment shader that covers a specific instruction simplify code path" },
{ "cov-atan-trunc-vec4.amber", "cov-atan-trunc-vec4", "A fragment shader that covers specific NIR code paths" },
{ "cov-basic-block-discard-in-function.amber", "cov-basic-block-discard-in-function", "A fragment shader that covers a specific basic block code path" },
{ "cov-cast-float-to-int-and-back.amber", "cov-cast-float-to-int-and-back", "A fragment shader that covers specific NIR code paths" },
{ "cov-clamp-loop-limit-increment-float-array.amber", "cov-clamp-loop-limit-increment-float-array", "A fragment shader that covers specific NIR code paths" },
{ "cov-clamp-lower-limit-from-always-false.amber", "cov-clamp-lower-limit-from-always-false", "A fragment shader that covers specific BRW code paths" },
+{ "cov-clamp-min-bitcount-uniform.amber", "cov-clamp-min-bitcount-uniform", "A fragment shader that covers specific LLVM code paths" },
{ "cov-clamp-vector-component-condition-using-matrix.amber", "cov-clamp-vector-component-condition-using-matrix", "A fragment shader that covers specific patch optimization code paths" },
{ "cov-clamp-vector-element-ceil-negative.amber", "cov-clamp-vector-element-ceil-negative", "A fragment shader that covers specific NIR code paths" },
{ "cov-clamp-vector-variable-negative-offset.amber", "cov-clamp-vector-variable-negative-offset", "A fragment shader that covers specific NIR code paths" },
{ "cov-color-output-undefined-in-unexecuted-branch.amber", "cov-color-output-undefined-in-unexecuted-branch", "A fragment shader that covers specific LLVM code paths" },
{ "cov-combine-and-or-xor-gt-lt.amber", "cov-combine-and-or-xor-gt-lt", "A fragment shader that covers a specific bitwise operator cobmining code path" },
{ "cov-condition-bitfield-extract-integer.amber", "cov-condition-bitfield-extract-integer", "A fragment shader that covers specific LLVM code paths" },
+{ "cov-condition-clamp-min-from-uniform-never-larger.amber", "cov-condition-clamp-min-from-uniform-never-larger", "A fragment shader that covers specific LLVM code paths" },
{ "cov-condition-increment-zero-to-one-divide-by-two.amber", "cov-condition-increment-zero-to-one-divide-by-two", "A fragment shader that covers specific LLVM code paths" },
{ "cov-condition-loop-index-bitwise-not.amber", "cov-condition-loop-index-bitwise-not", "A fragment shader that covers specific BRW code paths" },
{ "cov-condition-matrix-determinant-uniform.amber", "cov-condition-matrix-determinant-uniform", "A fragment shader that covers specific LLVM code paths" },
{ "cov-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-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-large-array-max-clamp.amber", "cov-function-large-array-max-clamp", "A fragment shader that covers specific LLVM code paths" },
{ "cov-function-loop-condition-uniform-shift-right.amber", "cov-function-loop-condition-uniform-shift-right", "A fragment shader that covers specific LLVM code paths" },
{ "cov-function-loop-condition-variable-less-than-min-itself.amber", "cov-function-loop-condition-variable-less-than-min-itself", "A fragment shader that covers specific LLVM code paths" },
{ "cov-function-loop-copy-array-elements-based-on-arguments.amber", "cov-function-loop-copy-array-elements-based-on-arguments", "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-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-loop-condition-double-negate.amber", "cov-loop-condition-double-negate", "A fragment shader that covers specific NIR code paths" },
{ "cov-loop-condition-filter-some-iterations-never-discard.amber", "cov-loop-condition-filter-some-iterations-never-discard", "A fragment shader that covers specific LLVM code paths" },
{ "cov-loop-condition-logical-or-never-iterated.amber", "cov-loop-condition-logical-or-never-iterated", "A fragment shader that covers specific LLVM code paths" },
+{ "cov-loop-decrease-integer-never-break.amber", "cov-loop-decrease-integer-never-break", "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-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-increase-iterator-condition-uniform-copy-array-elements.amber", "cov-loop-increase-iterator-condition-uniform-copy-array-elements", "A fragment shader that covers specific LLVM code paths" },
{ "cov-loop-increment-array-elements-clamp-index.amber", "cov-loop-increment-array-elements-clamp-index", "A fragment shader that covers specific LLVM code paths" },
{ "cov-loop-increment-integer-findmsb-minus-uniform.amber", "cov-loop-increment-integer-findmsb-minus-uniform", "A fragment shader that covers specific LLVM code paths" },
{ "cov-nested-loops-global-loop-counter-output-color-from-backup.amber", "cov-nested-loops-global-loop-counter-output-color-from-backup", "A fragment shader that covers specific LLVM code paths" },
{ "cov-nested-loops-identical-iterator-names-multiply-divide.amber", "cov-nested-loops-identical-iterator-names-multiply-divide", "A fragment shader that covers specific LLVM code paths" },
{ "cov-nested-loops-increase-integer-dot-product.amber", "cov-nested-loops-increase-integer-dot-product", "A fragment shader that covers specific LLVM code paths" },
+{ "cov-nested-loops-inner-loop-min-copy-array-elements.amber", "cov-nested-loops-inner-loop-min-copy-array-elements", "A fragment shader that covers specific LLVM code paths" },
{ "cov-nested-loops-redundant-condition.amber", "cov-nested-loops-redundant-condition", "A fragment shader that covers specific LLVM code paths" },
+{ "cov-nested-loops-return-inside-while-never-executed.amber", "cov-nested-loops-return-inside-while-never-executed", "A fragment shader that covers specific LLVM code paths" },
{ "cov-nested-loops-sample-opposite-corners.amber", "cov-nested-loops-sample-opposite-corners", "A fragment shader that covers specific LLVM code paths" },
{ "cov-nested-loops-set-struct-data-verify-in-function.amber", "cov-nested-loops-set-struct-data-verify-in-function", "A fragment shader that covers specific BRW code paths" },
+{ "cov-nested-loops-substract-matrix-element-change-float.amber", "cov-nested-loops-substract-matrix-element-change-float", "A fragment shader that covers specific LLVM code paths" },
+{ "cov-nested-loops-switch-case-fallthrough-increment-array-element.amber", "cov-nested-loops-switch-case-fallthrough-increment-array-element", "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-trunc-fract-always-zero.amber", "cov-trunc-fract-always-zero", "A fragment shader that covers specific NIR code paths" },
{ "cov-two-functions-modify-struct-array-element-return-from-loop.amber", "cov-two-functions-modify-struct-array-element-return-from-loop", "A fragment shader that covers specific LLVM code paths" },
{ "cov-two-loops-global-loop-counter-shift-right-zero-increment-array-element.amber", "cov-two-loops-global-loop-counter-shift-right-zero-increment-array-element", "A fragment shader that covers specific LLVM code paths" },
+{ "cov-two-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-ucarryadd-one-and-one.amber", "cov-ucarryadd-one-and-one", "A fragment shader that covers specific LLVM code paths" },
dEQP-VK.graphicsfuzz.cov-apfloat-reflect-denorm
dEQP-VK.graphicsfuzz.cov-apfloat-unpackunorm-loop
dEQP-VK.graphicsfuzz.cov-array-accesses-clamp
+dEQP-VK.graphicsfuzz.cov-array-cast-bool-float-div-by-zero-no-effect
dEQP-VK.graphicsfuzz.cov-array-copies-loops-with-limiters
+dEQP-VK.graphicsfuzz.cov-array-set-element-condition-negative-modulus
dEQP-VK.graphicsfuzz.cov-asin-undefined-smoothstep
dEQP-VK.graphicsfuzz.cov-atan-trunc-vec4
dEQP-VK.graphicsfuzz.cov-basic-block-discard-in-function
dEQP-VK.graphicsfuzz.cov-cast-float-to-int-and-back
dEQP-VK.graphicsfuzz.cov-clamp-loop-limit-increment-float-array
dEQP-VK.graphicsfuzz.cov-clamp-lower-limit-from-always-false
+dEQP-VK.graphicsfuzz.cov-clamp-min-bitcount-uniform
dEQP-VK.graphicsfuzz.cov-clamp-vector-component-condition-using-matrix
dEQP-VK.graphicsfuzz.cov-clamp-vector-element-ceil-negative
dEQP-VK.graphicsfuzz.cov-clamp-vector-variable-negative-offset
dEQP-VK.graphicsfuzz.cov-color-output-undefined-in-unexecuted-branch
dEQP-VK.graphicsfuzz.cov-combine-and-or-xor-gt-lt
dEQP-VK.graphicsfuzz.cov-condition-bitfield-extract-integer
+dEQP-VK.graphicsfuzz.cov-condition-clamp-min-from-uniform-never-larger
dEQP-VK.graphicsfuzz.cov-condition-increment-zero-to-one-divide-by-two
dEQP-VK.graphicsfuzz.cov-condition-loop-index-bitwise-not
dEQP-VK.graphicsfuzz.cov-condition-matrix-determinant-uniform
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-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-large-array-max-clamp
dEQP-VK.graphicsfuzz.cov-function-loop-condition-uniform-shift-right
dEQP-VK.graphicsfuzz.cov-function-loop-condition-variable-less-than-min-itself
dEQP-VK.graphicsfuzz.cov-function-loop-copy-array-elements-based-on-arguments
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-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-loop-condition-double-negate
dEQP-VK.graphicsfuzz.cov-loop-condition-filter-some-iterations-never-discard
dEQP-VK.graphicsfuzz.cov-loop-condition-logical-or-never-iterated
+dEQP-VK.graphicsfuzz.cov-loop-decrease-integer-never-break
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-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-increase-iterator-condition-uniform-copy-array-elements
dEQP-VK.graphicsfuzz.cov-loop-increment-array-elements-clamp-index
dEQP-VK.graphicsfuzz.cov-loop-increment-integer-findmsb-minus-uniform
dEQP-VK.graphicsfuzz.cov-nested-loops-global-loop-counter-output-color-from-backup
dEQP-VK.graphicsfuzz.cov-nested-loops-identical-iterator-names-multiply-divide
dEQP-VK.graphicsfuzz.cov-nested-loops-increase-integer-dot-product
+dEQP-VK.graphicsfuzz.cov-nested-loops-inner-loop-min-copy-array-elements
dEQP-VK.graphicsfuzz.cov-nested-loops-redundant-condition
+dEQP-VK.graphicsfuzz.cov-nested-loops-return-inside-while-never-executed
dEQP-VK.graphicsfuzz.cov-nested-loops-sample-opposite-corners
dEQP-VK.graphicsfuzz.cov-nested-loops-set-struct-data-verify-in-function
+dEQP-VK.graphicsfuzz.cov-nested-loops-substract-matrix-element-change-float
+dEQP-VK.graphicsfuzz.cov-nested-loops-switch-case-fallthrough-increment-array-element
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-trunc-fract-always-zero
dEQP-VK.graphicsfuzz.cov-two-functions-modify-struct-array-element-return-from-loop
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-types-return-in-main-never-hit
dEQP-VK.graphicsfuzz.cov-ucarryadd-one-and-one
projects / platform / upstream / VK-GL-CTS.git / commitdiff