test/tint/vk-gl-cts/graphicsfuzz/stable-triangle-nested-for-loop-and-true-if/1.spvasm.expected.ir.msl

SKIP: FAILED

<dawn>/src/tint/lang/msl/writer/printer/printer.cc:355 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 = block {  # root
  %x_11:ptr<uniform, buf1, read> = var @binding_point(0, 1)
  %x_GLF_color:ptr<private, vec4<f32>, read_write> = var
  %gl_FragCoord:ptr<private, vec4<f32>, read_write> = var
  %x_19:ptr<uniform, buf0, read> = var @binding_point(0, 0)
}

%pointInTriangle_vf2_vf2_vf2_vf2_ = func(%p:ptr<function, vec2<f32>, read_write>, %a:ptr<function, vec2<f32>, read_write>, %b:ptr<function, vec2<f32>, read_write>, %c:ptr<function, vec2<f32>, read_write>):i32 -> %b2 {
  %b2 = block {
    %x_78:ptr<function, f32, read_write> = var
    %x_79:ptr<function, f32, read_write> = var
    %x_80:ptr<function, f32, read_write> = var
    %param:ptr<function, vec2<f32>, read_write> = var
    %param_1:ptr<function, vec2<f32>, read_write> = var
    %param_2:ptr<function, vec2<f32>, read_write> = var
    %param_3:ptr<function, vec2<f32>, read_write> = var
    %param_4:ptr<function, vec2<f32>, read_write> = var
    %param_5:ptr<function, vec2<f32>, read_write> = var
    %x_147:ptr<function, bool, read_write> = var
    %x_148:ptr<function, bool, read_write> = var
    %x_203:ptr<function, bool, read_write> = var
    %x_204:ptr<function, bool, read_write> = var
    %x_93:f32 = load_vector_element %b, 0u
    %x_94:f32 = load_vector_element %a, 0u
    %x_97:f32 = load_vector_element %b, 1u
    %x_98:f32 = load_vector_element %a, 1u
    %27:f32 = load_vector_element %p, 0u
    %28:f32 = load_vector_element %a, 0u
    %29:f32 = sub %27, %28
    %30:f32 = load_vector_element %p, 1u
    %31:f32 = load_vector_element %a, 1u
    %32:f32 = sub %30, %31
    %33:vec2<f32> = construct %29, %32
    store %param, %33
    %34:f32 = sub %x_93, %x_94
    %35:f32 = sub %x_97, %x_98
    %36:vec2<f32> = construct %34, %35
    store %param_1, %36
    %37:f32 = load_vector_element %param, 0u
    %38:f32 = load_vector_element %param_1, 1u
    %39:f32 = mul %37, %38
    %40:f32 = load_vector_element %param_1, 0u
    %41:f32 = load_vector_element %param, 1u
    %42:f32 = mul %40, %41
    %x_111:f32 = sub %39, %42
    store %x_80, %x_111
    %x_120:f32 = load_vector_element %c, 0u
    %x_121:f32 = load_vector_element %b, 0u
    %x_124:f32 = load_vector_element %c, 1u
    %x_125:f32 = load_vector_element %b, 1u
    %48:f32 = load_vector_element %p, 0u
    %49:f32 = load_vector_element %b, 0u
    %50:f32 = sub %48, %49
    %51:f32 = load_vector_element %p, 1u
    %52:f32 = load_vector_element %b, 1u
    %53:f32 = sub %51, %52
    %54:vec2<f32> = construct %50, %53
    store %param_2, %54
    %55:f32 = sub %x_120, %x_121
    %56:f32 = sub %x_124, %x_125
    %57:vec2<f32> = construct %55, %56
    store %param_3, %57
    %58:f32 = load_vector_element %param_2, 0u
    %59:f32 = load_vector_element %param_3, 1u
    %60:f32 = mul %58, %59
    %61:f32 = load_vector_element %param_3, 0u
    %62:f32 = load_vector_element %param_2, 1u
    %63:f32 = mul %61, %62
    %x_138:f32 = sub %60, %63
    store %x_79, %x_138
    %x_139:bool = lt %x_111, 0.0f
    %66:bool = lt %x_138, 0.0f
    %x_141:bool = and %x_139, %66
    store %x_148, %x_141
    %68:bool = eq %x_141, false
    if %68 [t: %b3] {  # if_1
      %b3 = block {  # true
        %69:bool = gte %x_111, 0.0f
        %70:bool = gte %x_138, 0.0f
        %71:bool = and %69, %70
        store %x_147, %71
        %72:bool = load %x_147
        store %x_148, %72
        exit_if  # if_1
      }
    }
    %x_153:ptr<function, i32, read_write> = var
    %74:bool = load %x_148
    %75:bool = eq %74, false
    if %75 [t: %b4] {  # if_2
      %b4 = block {  # true
        store %x_153, 0i
        loop [b: %b5, c: %b6] {  # loop_1
          %b5 = block {  # body
            %x_164:ptr<function, i32, read_write> = var
            %x_154:ptr<function, i32, read_write> = var
            %78:ptr<uniform, vec2<f32>, read> = access %x_11, 0u
            %79:f32 = load_vector_element %78, 1u
            %x_160:i32 = convert %79
            %81:i32 = load %x_153
            %82:bool = lt %81, %x_160
            if %82 [t: %b7, f: %b8] {  # if_3
              %b7 = block {  # true
                exit_if  # if_3
              }
              %b8 = block {  # false
                exit_loop  # loop_1
              }
            }
            store %x_GLF_color, vec4<f32>(1.0f)
            store %x_164, 0i
            loop [b: %b9, c: %b10] {  # loop_2
              %b9 = block {  # body
                %x_165:ptr<function, i32, read_write> = var
                %84:i32 = load %x_164
                %85:bool = lt %84, %x_160
                if %85 [t: %b11, f: %b12] {  # if_4
                  %b11 = block {  # true
                    exit_if  # if_4
                  }
                  %b12 = block {  # false
                    exit_loop  # loop_2
                  }
                }
                store %x_GLF_color, vec4<f32>(1.0f)
                continue %b10
              }
              %b10 = block {  # continuing
                %86:i32 = load %x_164
                %87:i32 = add %86, 1i
                store %x_165, %87
                %88:i32 = load %x_165
                store %x_164, %88
                next_iteration %b9
              }
            }
            continue %b6
          }
          %b6 = block {  # continuing
            %89:i32 = load %x_153
            %90:i32 = add %89, 1i
            store %x_154, %90
            %91:i32 = load %x_154
            store %x_153, %91
            next_iteration %b5
          }
        }
        ret 0i
      }
    }
    %x_178:f32 = load_vector_element %a, 0u
    %x_179:f32 = load_vector_element %c, 0u
    %x_181:f32 = load_vector_element %a, 1u
    %x_182:f32 = load_vector_element %c, 1u
    %96:f32 = load_vector_element %p, 0u
    %97:f32 = load_vector_element %c, 0u
    %98:f32 = sub %96, %97
    %99:f32 = load_vector_element %p, 1u
    %100:f32 = load_vector_element %c, 1u
    %101:f32 = sub %99, %100
    %102:vec2<f32> = construct %98, %101
    store %param_4, %102
    %103:f32 = sub %x_178, %x_179
    %104:f32 = sub %x_181, %x_182
    %105:vec2<f32> = construct %103, %104
    store %param_5, %105
    %106:f32 = load_vector_element %param_4, 0u
    %107:f32 = load_vector_element %param_5, 1u
    %108:f32 = mul %106, %107
    %109:f32 = load_vector_element %param_5, 0u
    %110:f32 = load_vector_element %param_4, 1u
    %111:f32 = mul %109, %110
    %x_195:f32 = sub %108, %111
    store %x_78, %x_195
    %113:bool = lt %x_195, 0.0f
    %x_197:bool = and %x_139, %113
    store %x_204, %x_197
    %115:bool = eq %x_197, false
    if %115 [t: %b13] {  # if_5
      %b13 = block {  # true
        %116:bool = gte %x_111, 0.0f
        %117:bool = gte %x_195, 0.0f
        %118:bool = and %116, %117
        store %x_203, %118
        %119:bool = load %x_203
        store %x_204, %119
        exit_if  # if_5
      }
    }
    %120:bool = load %x_204
    %121:bool = eq %120, false
    if %121 [t: %b14] {  # if_6
      %b14 = block {  # true
        ret 0i
      }
    }
    ret 1i
  }
}
%main_1 = func():void -> %b15 {
  %b15 = block {
    %param_6:ptr<function, vec2<f32>, read_write> = var
    %param_7:ptr<function, vec2<f32>, read_write> = var
    %param_8:ptr<function, vec2<f32>, read_write> = var
    %param_9:ptr<function, vec2<f32>, read_write> = var
    %127:vec4<f32> = load %gl_FragCoord
    %128:vec2<f32> = swizzle %127, xy
    %129:ptr<uniform, vec2<f32>, read> = access %x_19, 0u
    %130:vec2<f32> = load %129
    %131:vec2<f32> = div %128, %130
    store %param_6, %131
    store %param_7, vec2<f32>(0.69999998807907104492f, 0.30000001192092895508f)
    store %param_8, vec2<f32>(0.5f, 0.89999997615814208984f)
    store %param_9, vec2<f32>(0.10000000149011611938f, 0.40000000596046447754f)
    %x_65:i32 = call %pointInTriangle_vf2_vf2_vf2_vf2_, %param_6, %param_7, %param_8, %param_9
    %133:bool = eq %x_65, 1i
    if %133 [t: %b16, f: %b17] {  # if_7
      %b16 = block {  # true
        %134:ptr<uniform, vec2<f32>, read> = access %x_11, 0u
        %135:f32 = load_vector_element %134, 1u
        %136:ptr<uniform, vec2<f32>, read> = access %x_11, 0u
        %137:f32 = load_vector_element %136, 0u
        %138:bool = gte %135, %137
        if %138 [t: %b18] {  # if_8
          %b18 = block {  # true
            store %x_GLF_color, vec4<f32>(1.0f, 0.0f, 0.0f, 1.0f)
            exit_if  # if_8
          }
        }
        exit_if  # if_7
      }
      %b17 = block {  # false
        store %x_GLF_color, vec4<f32>(0.0f, 0.0f, 0.0f, 1.0f)
        exit_if  # if_7
      }
    }
    ret
  }
}
%tint_symbol = @fragment func(%gl_FragCoord_param:vec4<f32> [@position]):main_out -> %b19 {
  %b19 = block {
    store %gl_FragCoord, %gl_FragCoord_param
    %141:void = call %main_1
    %142:vec4<f32> = load %x_GLF_color
    %143:main_out = construct %142
    ret %143
  }
}

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.  *
********************************************************************