test/tint/vk-gl-cts/graphicsfuzz/stable-colorgrid-modulo-double-always-false-discard/1.wgsl.expected.ir.msl

SKIP: FAILED

../../src/tint/lang/msl/writer/printer/printer.cc:500 internal compiler error: buf1 = struct @align(8) {
  injectionSwitch:vec2<f32> @offset(0)
}

buf0 = struct @align(8) {
  resolution:vec2<f32> @offset(0)
}

main_out = struct @align(16) {
  x_GLF_color_1:vec4<f32> @offset(0), @location(0)
}

$B1: {  # root
  %x_6:ptr<uniform, buf1, read> = var @binding_point(0, 1)
  %x_9:ptr<uniform, buf0, read> = var @binding_point(0, 0)
  %gl_FragCoord:ptr<private, vec4<f32>, read_write> = var
  %x_GLF_color:ptr<private, vec4<f32>, read_write> = var
  %continue_execution:ptr<private, bool, read_write> = var, true
}

%main_1 = func():void {
  $B2: {
    %c:ptr<function, vec3<f32>, read_write> = var
    %x_54:ptr<function, f32, read_write> = var
    %x_58:ptr<function, f32, read_write> = var
    %x_59:ptr<function, f32, read_write> = var
    %x_91:ptr<function, f32, read_write> = var
    %x_92:ptr<function, f32, read_write> = var
    %x_135:ptr<function, f32, read_write> = var
    %x_136:ptr<function, f32, read_write> = var
    %x_58_phi:ptr<function, f32, read_write> = var
    %x_61_phi:ptr<function, i32, read_write> = var
    %x_91_phi:ptr<function, f32, read_write> = var
    %x_92_phi:ptr<function, f32, read_write> = var
    %x_93_phi:ptr<function, bool, read_write> = var
    %x_95_phi:ptr<function, f32, read_write> = var
    %x_139_phi:ptr<function, f32, read_write> = var
    %x_146_phi:ptr<function, i32, read_write> = var
    store %c, vec3<f32>(7.0f, 8.0f, 9.0f)
    %23:ptr<uniform, vec2<f32>, read> = access %x_9, 0u
    %24:f32 = load_vector_element %23, 0u
    %x_50:f32 = let %24
    %26:f32 = mul %x_50, 0.125f
    %27:f32 = round %26
    %x_52:f32 = let %27
    %29:f32 = load_vector_element %gl_FragCoord, 0u
    store %x_54, %29
    switch 0u [c: (default, $B3)] {  # switch_1
      $B3: {  # case
        store %x_58_phi, -0.5f
        store %x_61_phi, 1i
        loop [b: $B4, c: $B5] {  # loop_1
          $B4: {  # body
            %x_71:ptr<function, f32, read_write> = var
            %x_79:ptr<function, f32, read_write> = var
            %x_62:ptr<function, i32, read_write> = var
            %x_59_phi:ptr<function, f32, read_write> = var
            %34:f32 = load %x_58_phi
            store %x_58, %34
            %35:i32 = load %x_61_phi
            %x_61:i32 = let %35
            store %x_91_phi, 0.0f
            %37:f32 = load %x_58
            store %x_92_phi, %37
            store %x_93_phi, false
            %38:bool = lt %x_61, 800i
            if %38 [t: $B6, f: $B7] {  # if_1
              $B6: {  # true
                exit_if  # if_1
              }
              $B7: {  # false
                exit_loop  # loop_1
              }
            }
            %x_78:ptr<function, f32, read_write> = var
            %x_79_phi:ptr<function, f32, read_write> = var
            %41:i32 = call %tint_mod_i32, %x_61, 32i
            %43:bool = eq %41, 0i
            if %43 [t: $B8, f: $B9] {  # if_2
              $B8: {  # true
                %44:f32 = load %x_58
                %45:f32 = add %44, 0.40000000596046447754f
                store %x_71, %45
                %46:f32 = load %x_71
                store %x_59_phi, %46
                exit_if  # if_2
              }
              $B9: {  # false
                %47:f32 = load %x_58
                store %x_79_phi, %47
                %48:f32 = convert %x_61
                %49:f32 = let %48
                %50:f32 = round %x_52
                %51:f32 = let %50
                %52:f32 = convert %x_61
                %53:f32 = let %52
                %54:f32 = round %x_52
                %55:f32 = div %53, %54
                %56:f32 = floor %55
                %57:f32 = mul %51, %56
                %58:f32 = sub %49, %57
                %59:bool = lte %58, 0.00999999977648258209f
                if %59 [t: $B10] {  # if_3
                  $B10: {  # true
                    %60:f32 = load %x_58
                    %61:f32 = add %60, 100.0f
                    store %x_78, %61
                    %62:f32 = load %x_78
                    store %x_79_phi, %62
                    exit_if  # if_3
                  }
                }
                %63:f32 = load %x_79_phi
                store %x_79, %63
                %64:ptr<uniform, vec2<f32>, read> = access %x_6, 0u
                %65:f32 = load_vector_element %64, 0u
                %x_81:f32 = let %65
                %67:ptr<uniform, vec2<f32>, read> = access %x_6, 0u
                %68:f32 = load_vector_element %67, 1u
                %x_83:f32 = let %68
                %70:bool = gt %x_81, %x_83
                if %70 [t: $B11] {  # if_4
                  $B11: {  # true
                    store %continue_execution, false
                    exit_if  # if_4
                  }
                }
                %71:f32 = load %x_79
                store %x_59_phi, %71
                exit_if  # if_2
              }
            }
            %72:f32 = load %x_59_phi
            store %x_59, %72
            %73:f32 = convert %x_61
            %74:f32 = load %x_54
            %75:bool = gte %73, %74
            if %75 [t: $B12] {  # if_5
              $B12: {  # true
                %76:f32 = load %x_59
                store %x_91_phi, %76
                %77:f32 = load %x_59
                store %x_92_phi, %77
                store %x_93_phi, true
                exit_loop  # loop_1
              }
            }
            continue  # -> $B5
          }
          $B5: {  # continuing
            %78:i32 = add %x_61, 1i
            store %x_62, %78
            %79:f32 = load %x_59
            store %x_58_phi, %79
            %80:i32 = load %x_62
            store %x_61_phi, %80
            next_iteration  # -> $B4
          }
        }
        %81:f32 = load %x_91_phi
        store %x_91, %81
        %82:f32 = load %x_92_phi
        store %x_92, %82
        %83:bool = load %x_93_phi
        %x_93:bool = let %83
        %85:f32 = load %x_91
        store %x_95_phi, %85
        if %x_93 [t: $B13] {  # if_6
          $B13: {  # true
            exit_switch  # switch_1
          }
        }
        %86:f32 = load %x_92
        store %x_95_phi, %86
        exit_switch  # switch_1
      }
    }
    %x_98:ptr<function, f32, read_write> = var
    %x_102:ptr<function, f32, read_write> = var
    %x_103:ptr<function, f32, read_write> = var
    %x_102_phi:ptr<function, f32, read_write> = var
    %x_105_phi:ptr<function, i32, read_write> = var
    %x_135_phi:ptr<function, f32, read_write> = var
    %x_136_phi:ptr<function, f32, read_write> = var
    %x_137_phi:ptr<function, bool, read_write> = var
    %95:f32 = load %x_95_phi
    %x_95:f32 = let %95
    store_vector_element %c, 0u, %x_95
    %97:f32 = load_vector_element %gl_FragCoord, 1u
    store %x_98, %97
    switch 0u [c: (default, $B14)] {  # switch_2
      $B14: {  # case
        store %x_102_phi, -0.5f
        store %x_105_phi, 1i
        loop [b: $B15, c: $B16] {  # loop_2
          $B15: {  # body
            %x_115:ptr<function, f32, read_write> = var
            %x_123:ptr<function, f32, read_write> = var
            %x_106:ptr<function, i32, read_write> = var
            %x_103_phi:ptr<function, f32, read_write> = var
            %102:f32 = load %x_102_phi
            store %x_102, %102
            %103:i32 = load %x_105_phi
            %x_105:i32 = let %103
            store %x_135_phi, 0.0f
            %105:f32 = load %x_102
            store %x_136_phi, %105
            store %x_137_phi, false
            %106:bool = lt %x_105, 800i
            if %106 [t: $B17, f: $B18] {  # if_7
              $B17: {  # true
                exit_if  # if_7
              }
              $B18: {  # false
                exit_loop  # loop_2
              }
            }
            %x_122:ptr<function, f32, read_write> = var
            %x_123_phi:ptr<function, f32, read_write> = var
            %109:i32 = call %tint_mod_i32, %x_105, 32i
            %110:bool = eq %109, 0i
            if %110 [t: $B19, f: $B20] {  # if_8
              $B19: {  # true
                %111:f32 = load %x_102
                %112:f32 = add %111, 0.40000000596046447754f
                store %x_115, %112
                %113:f32 = load %x_115
                store %x_103_phi, %113
                exit_if  # if_8
              }
              $B20: {  # false
                %114:f32 = load %x_102
                store %x_123_phi, %114
                %115:f32 = convert %x_105
                %116:f32 = let %115
                %117:f32 = round %x_52
                %118:f32 = let %117
                %119:f32 = convert %x_105
                %120:f32 = let %119
                %121:f32 = round %x_52
                %122:f32 = div %120, %121
                %123:f32 = floor %122
                %124:f32 = mul %118, %123
                %125:f32 = sub %116, %124
                %126:bool = lte %125, 0.00999999977648258209f
                if %126 [t: $B21] {  # if_9
                  $B21: {  # true
                    %127:f32 = load %x_102
                    %128:f32 = add %127, 100.0f
                    store %x_122, %128
                    %129:f32 = load %x_122
                    store %x_123_phi, %129
                    exit_if  # if_9
                  }
                }
                %130:f32 = load %x_123_phi
                store %x_123, %130
                %131:ptr<uniform, vec2<f32>, read> = access %x_6, 0u
                %132:f32 = load_vector_element %131, 0u
                %x_125:f32 = let %132
                %134:ptr<uniform, vec2<f32>, read> = access %x_6, 0u
                %135:f32 = load_vector_element %134, 1u
                %x_127:f32 = let %135
                %137:bool = gt %x_125, %x_127
                if %137 [t: $B22] {  # if_10
                  $B22: {  # true
                    store %continue_execution, false
                    exit_if  # if_10
                  }
                }
                %138:f32 = load %x_123
                store %x_103_phi, %138
                exit_if  # if_8
              }
            }
            %139:f32 = load %x_103_phi
            store %x_103, %139
            %140:f32 = convert %x_105
            %141:f32 = load %x_98
            %142:bool = gte %140, %141
            if %142 [t: $B23] {  # if_11
              $B23: {  # true
                %143:f32 = load %x_103
                store %x_135_phi, %143
                %144:f32 = load %x_103
                store %x_136_phi, %144
                store %x_137_phi, true
                exit_loop  # loop_2
              }
            }
            continue  # -> $B16
          }
          $B16: {  # continuing
            %145:i32 = add %x_105, 1i
            store %x_106, %145
            %146:f32 = load %x_103
            store %x_102_phi, %146
            %147:i32 = load %x_106
            store %x_105_phi, %147
            next_iteration  # -> $B15
          }
        }
        %148:f32 = load %x_135_phi
        store %x_135, %148
        %149:f32 = load %x_136_phi
        store %x_136, %149
        %150:bool = load %x_137_phi
        %x_137:bool = let %150
        %152:f32 = load %x_135
        store %x_139_phi, %152
        if %x_137 [t: $B24] {  # if_12
          $B24: {  # true
            exit_switch  # switch_2
          }
        }
        %153:f32 = load %x_136
        store %x_139_phi, %153
        exit_switch  # switch_2
      }
    }
    %154:f32 = load %x_139_phi
    %x_139:f32 = let %154
    store_vector_element %c, 1u, %x_139
    %156:f32 = load_vector_element %c, 0u
    %x_141:f32 = let %156
    %158:f32 = load_vector_element %c, 1u
    %x_142:f32 = let %158
    %160:f32 = add %x_141, %x_142
    store_vector_element %c, 2u, %160
    store %x_146_phi, 0i
    loop [b: $B25, c: $B26] {  # loop_3
      $B25: {  # body
        %x_147:ptr<function, i32, read_write> = var
        %162:i32 = load %x_146_phi
        %x_146:i32 = let %162
        %164:bool = lt %x_146, 3i
        if %164 [t: $B27, f: $B28] {  # if_13
          $B27: {  # true
            exit_if  # if_13
          }
          $B28: {  # false
            exit_loop  # loop_3
          }
        }
        %165:f32 = load_vector_element %c, %x_146
        %x_153:f32 = let %165
        %167:bool = gte %x_153, 1.0f
        if %167 [t: $B29] {  # if_14
          $B29: {  # true
            %168:f32 = load_vector_element %c, %x_146
            %x_157:f32 = let %168
            %170:f32 = load_vector_element %c, %x_146
            %x_158:f32 = let %170
            %172:f32 = mul %x_157, %x_158
            store_vector_element %c, %x_146, %172
            %173:ptr<uniform, vec2<f32>, read> = access %x_6, 0u
            %174:f32 = load_vector_element %173, 0u
            %x_161:f32 = let %174
            %176:ptr<uniform, vec2<f32>, read> = access %x_6, 0u
            %177:f32 = load_vector_element %176, 1u
            %x_163:f32 = let %177
            %179:bool = gt %x_161, %x_163
            if %179 [t: $B30] {  # if_15
              $B30: {  # true
                store %continue_execution, false
                exit_if  # if_15
              }
            }
            exit_if  # if_14
          }
        }
        continue  # -> $B26
      }
      $B26: {  # continuing
        %180:i32 = add %x_146, 1i
        store %x_147, %180
        %181:i32 = load %x_147
        store %x_146_phi, %181
        next_iteration  # -> $B25
      }
    }
    %182:vec3<f32> = load %c
    %x_167:vec3<f32> = let %182
    %184:vec3<f32> = abs %x_167
    %185:vec3<f32> = normalize %184
    %x_169:vec3<f32> = let %185
    %187:f32 = access %x_169, 0u
    %188:f32 = access %x_169, 1u
    %189:f32 = access %x_169, 2u
    %190:vec4<f32> = construct %187, %188, %189, 1.0f
    store %x_GLF_color, %190
    ret
  }
}
%tint_symbol = @fragment func(%gl_FragCoord_param:vec4<f32> [@position]):main_out {
  $B31: {
    store %gl_FragCoord, %gl_FragCoord_param
    %193:void = call %main_1
    %194:vec4<f32> = load %x_GLF_color
    %195:main_out = construct %194
    %196:bool = load %continue_execution
    %197:bool = eq %196, false
    if %197 [t: $B32] {  # if_16
      $B32: {  # true
        terminate_invocation
      }
    }
    ret %195
  }
}
%tint_mod_i32 = func(%lhs:i32, %rhs:i32):i32 {
  $B33: {
    %200:bool = eq %rhs, 0i
    %201:bool = eq %lhs, -2147483648i
    %202:bool = eq %rhs, -1i
    %203:bool = and %201, %202
    %204:bool = or %200, %203
    %205:i32 = select %rhs, 1i, %204
    %206:i32 = let %205
    %207:i32 = div %lhs, %206
    %208:i32 = mul %207, %206
    %209:i32 = sub %lhs, %208
    ret %209
  }
}

unhandled variable address space
********************************************************************
*  The tint shader compiler has encountered an unexpected error.   *
*                                                                  *
*  Please help us fix this issue by submitting a bug report at     *
*  crbug.com/tint with the source program that triggered the bug.  *
********************************************************************