SKIP: FAILED

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

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

$B1: {  # root
  %x_8: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: {
    %temp:ptr<function, array<i32, 10>, read_write> = var
    %data:ptr<function, array<i32, 10>, read_write> = var
    %x_190:ptr<function, f32, read_write> = var
    %x_262:ptr<function, f32, read_write> = var
    %x_63_phi:ptr<function, i32, read_write> = var
    %x_103_phi:ptr<function, i32, read_write> = var
    %x_112_phi:ptr<function, i32, read_write> = var
    %x_263_phi:ptr<function, f32, read_write> = var
    %14:ptr<uniform, vec2<f32>, read> = access %x_8, 0u
    %15:f32 = load_vector_element %14, 0u
    %x_60:f32 = let %15
    %17:i32 = call %tint_f32_to_i32, %x_60
    %x_61:i32 = let %17
    store %x_63_phi, %x_61
    loop [b: $B3, c: $B4] {  # loop_1
      $B3: {  # body
        %x_100:ptr<function, i32, read_write> = var
        %x_98:ptr<function, i32, read_write> = var
        %x_96:ptr<function, i32, read_write> = var
        %x_94:ptr<function, i32, read_write> = var
        %x_92:ptr<function, i32, read_write> = var
        %x_90:ptr<function, i32, read_write> = var
        %x_88:ptr<function, i32, read_write> = var
        %x_86:ptr<function, i32, read_write> = var
        %x_84:ptr<function, i32, read_write> = var
        %x_82:ptr<function, i32, read_write> = var
        %x_64_phi:ptr<function, i32, read_write> = var
        %31:i32 = load %x_63_phi
        %x_63:i32 = let %31
        %33:array<i32, 10> = load %data
        %x_68:array<i32, 10> = let %33
        store %data, array<i32, 10>(0i)
        store %data, %x_68
        %35:i32 = add %x_63, 1i
        %x_69:i32 = let %35
        store %x_64_phi, %x_69
        switch %x_63 [c: (9i, $B5), c: (8i, $B6), c: (7i, $B7), c: (6i, $B8), c: (5i, $B9), c: (4i, $B10), c: (3i, $B11), c: (2i, $B12), c: (1i, $B13), c: (0i, $B14), c: (default, $B15)] {  # switch_1
          $B5: {  # case
            %37:ptr<function, i32, read_write> = access %data, %x_63
            store %37, -5i
            %38:i32 = add %x_63, 1i
            store %x_100, %38
            %39:i32 = load %x_100
            store %x_64_phi, %39
            exit_switch  # switch_1
          }
          $B6: {  # case
            %40:ptr<function, i32, read_write> = access %data, %x_63
            store %40, -4i
            %41:i32 = add %x_63, 1i
            store %x_98, %41
            %42:i32 = load %x_98
            store %x_64_phi, %42
            exit_switch  # switch_1
          }
          $B7: {  # case
            %43:ptr<function, i32, read_write> = access %data, %x_63
            store %43, -3i
            %44:i32 = add %x_63, 1i
            store %x_96, %44
            %45:i32 = load %x_96
            store %x_64_phi, %45
            exit_switch  # switch_1
          }
          $B8: {  # case
            %46:ptr<function, i32, read_write> = access %data, %x_63
            store %46, -2i
            %47:i32 = add %x_63, 1i
            store %x_94, %47
            %48:i32 = load %x_94
            store %x_64_phi, %48
            exit_switch  # switch_1
          }
          $B9: {  # case
            %49:ptr<function, i32, read_write> = access %data, %x_63
            store %49, -1i
            %50:i32 = add %x_63, 1i
            store %x_92, %50
            %51:i32 = load %x_92
            store %x_64_phi, %51
            exit_switch  # switch_1
          }
          $B10: {  # case
            %52:ptr<function, i32, read_write> = access %data, %x_63
            store %52, 0i
            %53:i32 = add %x_63, 1i
            store %x_90, %53
            %54:i32 = load %x_90
            store %x_64_phi, %54
            exit_switch  # switch_1
          }
          $B11: {  # case
            %55:ptr<function, i32, read_write> = access %data, %x_63
            store %55, 1i
            %56:i32 = add %x_63, 1i
            store %x_88, %56
            %57:i32 = load %x_88
            store %x_64_phi, %57
            exit_switch  # switch_1
          }
          $B12: {  # case
            %58:ptr<function, i32, read_write> = access %data, %x_63
            store %58, 2i
            %59:i32 = add %x_63, 1i
            store %x_86, %59
            %60:i32 = load %x_86
            store %x_64_phi, %60
            exit_switch  # switch_1
          }
          $B13: {  # case
            %61:ptr<function, i32, read_write> = access %data, %x_63
            store %61, 3i
            %62:i32 = add %x_63, 1i
            store %x_84, %62
            %63:i32 = load %x_84
            store %x_64_phi, %63
            exit_switch  # switch_1
          }
          $B14: {  # case
            %64:ptr<function, i32, read_write> = access %data, %x_63
            store %64, 4i
            %65:i32 = add %x_63, 1i
            store %x_82, %65
            %66:i32 = load %x_82
            store %x_64_phi, %66
            exit_switch  # switch_1
          }
          $B15: {  # case
            exit_switch  # switch_1
          }
        }
        %67:i32 = load %x_64_phi
        %x_64:i32 = let %67
        continue  # -> $B4
      }
      $B4: {  # continuing
        store %x_63_phi, %x_64
        %69:bool = lt %x_64, 10i
        %70:bool = eq %69, false
        break_if %70  # -> [t: exit_loop loop_1, f: $B3]
      }
    }
    store %x_103_phi, 0i
    loop [b: $B16, c: $B17] {  # loop_2
      $B16: {  # body
        %x_104:ptr<function, i32, read_write> = var
        %72:i32 = load %x_103_phi
        %x_103:i32 = let %72
        %74:bool = lt %x_103, 10i
        if %74 [t: $B18, f: $B19] {  # if_1
          $B18: {  # true
            exit_if  # if_1
          }
          $B19: {  # false
            exit_loop  # loop_2
          }
        }
        continue  # -> $B17
      }
      $B17: {  # continuing
        %75:ptr<function, i32, read_write> = access %data, %x_103
        %76:i32 = load %75
        %x_109:i32 = let %76
        %78:ptr<function, i32, read_write> = access %temp, %x_103
        store %78, %x_109
        %79:i32 = add %x_103, 1i
        store %x_104, %79
        %80:i32 = load %x_104
        store %x_103_phi, %80
        next_iteration  # -> $B16
      }
    }
    store %x_112_phi, 1i
    loop [b: $B20, c: $B21] {  # loop_3
      $B20: {  # body
        %x_113:ptr<function, i32, read_write> = var
        %x_119_phi:ptr<function, i32, read_write> = var
        %83:i32 = load %x_112_phi
        %x_112:i32 = let %83
        %85:bool = lte %x_112, 9i
        if %85 [t: $B22, f: $B23] {  # if_2
          $B22: {  # true
            exit_if  # if_2
          }
          $B23: {  # false
            exit_loop  # loop_3
          }
        }
        store %x_119_phi, 0i
        loop [b: $B24, c: $B25] {  # loop_4
          $B24: {  # body
            %x_131:ptr<function, i32, read_write> = var
            %x_136:ptr<function, i32, read_write> = var
            %x_131_phi:ptr<function, i32, read_write> = var
            %x_134_phi:ptr<function, i32, read_write> = var
            %x_136_phi:ptr<function, i32, read_write> = var
            %x_158_phi:ptr<function, i32, read_write> = var
            %x_161_phi:ptr<function, i32, read_write> = var
            %x_171_phi:ptr<function, i32, read_write> = var
            %94:i32 = load %x_119_phi
            %x_119:i32 = let %94
            %96:bool = lt %x_119, 9i
            if %96 [t: $B26, f: $B27] {  # if_3
              $B26: {  # true
                exit_if  # if_3
              }
              $B27: {  # false
                exit_loop  # loop_4
              }
            }
            %97:i32 = add %x_119, %x_112
            %x_125:i32 = let %97
            %99:i32 = sub %x_125, 1i
            %x_126:i32 = let %99
            %101:i32 = mul 2i, %x_112
            %102:i32 = add %x_119, %101
            %x_120:i32 = let %102
            %104:i32 = sub %x_120, 1i
            %105:i32 = min %104, 9i
            %x_129:i32 = let %105
            store %x_131_phi, %x_119
            store %x_134_phi, %x_125
            store %x_136_phi, %x_119
            loop [b: $B28, c: $B29] {  # loop_5
              $B28: {  # body
                %x_151:ptr<function, i32, read_write> = var
                %x_154:ptr<function, i32, read_write> = var
                %x_135_phi:ptr<function, i32, read_write> = var
                %x_137_phi:ptr<function, i32, read_write> = var
                %111:i32 = load %x_131_phi
                store %x_131, %111
                %112:i32 = load %x_134_phi
                %x_134:i32 = let %112
                %114:i32 = load %x_136_phi
                store %x_136, %114
                %115:i32 = load %x_136
                %116:bool = lte %115, %x_126
                %117:bool = lte %x_134, %x_129
                %118:bool = and %116, %117
                if %118 [t: $B30, f: $B31] {  # if_4
                  $B30: {  # true
                    exit_if  # if_4
                  }
                  $B31: {  # false
                    exit_loop  # loop_5
                  }
                }
                %119:i32 = load %x_136
                %x_143_save:i32 = let %119
                %121:ptr<function, i32, read_write> = access %data, %x_143_save
                %122:i32 = load %121
                %x_144:i32 = let %122
                %x_145_save:i32 = let %x_134
                %125:ptr<function, i32, read_write> = access %data, %x_145_save
                %126:i32 = load %125
                %x_146:i32 = let %126
                %128:i32 = load %x_131
                %129:i32 = add %128, 1i
                %130:i32 = bitcast %129
                %x_132:i32 = let %130
                %132:bool = lt %x_144, %x_146
                if %132 [t: $B32, f: $B33] {  # if_5
                  $B32: {  # true
                    %133:i32 = load %x_136
                    %134:i32 = add %133, 1i
                    %135:i32 = bitcast %134
                    store %x_151, %135
                    %136:ptr<function, i32, read_write> = access %data, %x_143_save
                    %137:i32 = load %136
                    %x_152:i32 = let %137
                    %139:i32 = load %x_131
                    %140:ptr<function, i32, read_write> = access %temp, %139
                    store %140, %x_152
                    store %x_135_phi, %x_134
                    %141:i32 = load %x_151
                    store %x_137_phi, %141
                    exit_if  # if_5
                  }
                  $B33: {  # false
                    %142:i32 = add %x_134, 1i
                    store %x_154, %142
                    %143:ptr<function, i32, read_write> = access %data, %x_145_save
                    %144:i32 = load %143
                    %x_155:i32 = let %144
                    %146:i32 = load %x_131
                    %147:ptr<function, i32, read_write> = access %temp, %146
                    store %147, %x_155
                    %148:i32 = load %x_154
                    store %x_135_phi, %148
                    %149:i32 = load %x_136
                    store %x_137_phi, %149
                    exit_if  # if_5
                  }
                }
                %150:i32 = load %x_135_phi
                %x_135:i32 = let %150
                %152:i32 = load %x_137_phi
                %x_137:i32 = let %152
                continue  # -> $B29
              }
              $B29: {  # continuing
                store %x_131_phi, %x_132
                store %x_134_phi, %x_135
                store %x_136_phi, %x_137
                next_iteration  # -> $B28
              }
            }
            %154:i32 = load %x_131
            store %x_158_phi, %154
            %155:i32 = load %x_136
            store %x_161_phi, %155
            loop [b: $B34, c: $B35] {  # loop_6
              $B34: {  # body
                %x_159:ptr<function, i32, read_write> = var
                %x_162:ptr<function, i32, read_write> = var
                %158:i32 = load %x_158_phi
                %x_158:i32 = let %158
                %160:i32 = load %x_161_phi
                %x_161:i32 = let %160
                %162:bool = lt %x_161, 10i
                %163:bool = lte %x_161, %x_126
                %164:bool = and %162, %163
                if %164 [t: $B36, f: $B37] {  # if_6
                  $B36: {  # true
                    exit_if  # if_6
                  }
                  $B37: {  # false
                    exit_loop  # loop_6
                  }
                }
                continue  # -> $B35
              }
              $B35: {  # continuing
                %165:i32 = add %x_158, 1i
                store %x_159, %165
                %166:i32 = add %x_161, 1i
                store %x_162, %166
                %167:ptr<function, i32, read_write> = access %data, %x_161
                %168:i32 = load %167
                %x_168:i32 = let %168
                %170:ptr<function, i32, read_write> = access %temp, %x_158
                store %170, %x_168
                %171:i32 = load %x_159
                store %x_158_phi, %171
                %172:i32 = load %x_162
                store %x_161_phi, %172
                next_iteration  # -> $B34
              }
            }
            store %x_171_phi, %x_119
            loop [b: $B38, c: $B39] {  # loop_7
              $B38: {  # body
                %x_172:ptr<function, i32, read_write> = var
                %174:i32 = load %x_171_phi
                %x_171:i32 = let %174
                %176:bool = lte %x_171, %x_129
                if %176 [t: $B40, f: $B41] {  # if_7
                  $B40: {  # true
                    exit_if  # if_7
                  }
                  $B41: {  # false
                    exit_loop  # loop_7
                  }
                }
                continue  # -> $B39
              }
              $B39: {  # continuing
                %177:ptr<function, i32, read_write> = access %temp, %x_171
                %178:i32 = load %177
                %x_177:i32 = let %178
                %180:ptr<function, i32, read_write> = access %data, %x_171
                store %180, %x_177
                %181:i32 = add %x_171, 1i
                store %x_172, %181
                %182:i32 = load %x_172
                store %x_171_phi, %182
                next_iteration  # -> $B38
              }
            }
            continue  # -> $B25
          }
          $B25: {  # continuing
            store %x_119_phi, %x_120
            next_iteration  # -> $B24
          }
        }
        continue  # -> $B21
      }
      $B21: {  # continuing
        %183:i32 = mul 2i, %x_112
        store %x_113, %183
        %184:i32 = load %x_113
        store %x_112_phi, %184
        next_iteration  # -> $B20
      }
    }
    %x_181:ptr<function, i32, read_write> = var
    %x_199:ptr<function, f32, read_write> = var
    %x_261:ptr<function, f32, read_write> = var
    %x_262_phi:ptr<function, f32, read_write> = var
    %189:f32 = load_vector_element %gl_FragCoord, 1u
    %x_180:f32 = let %189
    %191:i32 = call %tint_f32_to_i32, %x_180
    store %x_181, %191
    %192:i32 = load %x_181
    %193:bool = lt %192, 30i
    if %193 [t: $B42, f: $B43] {  # if_8
      $B42: {  # true
        %194:ptr<function, i32, read_write> = access %data, 0i
        %195:i32 = load %194
        %x_187:i32 = let %195
        %197:f32 = convert %x_187
        %198:f32 = mul %197, 0.10000000149011611938f
        %199:f32 = add 0.5f, %198
        store %x_190, %199
        %200:f32 = load %x_190
        store %x_263_phi, %200
        exit_if  # if_8
      }
      $B43: {  # false
        %x_208:ptr<function, f32, read_write> = var
        %x_260:ptr<function, f32, read_write> = var
        %x_261_phi:ptr<function, f32, read_write> = var
        %204:i32 = load %x_181
        %205:bool = lt %204, 60i
        if %205 [t: $B44, f: $B45] {  # if_9
          $B44: {  # true
            %206:ptr<function, i32, read_write> = access %data, 1i
            %207:i32 = load %206
            %x_196:i32 = let %207
            %209:f32 = convert %x_196
            %210:f32 = mul %209, 0.10000000149011611938f
            %211:f32 = add 0.5f, %210
            store %x_199, %211
            %212:f32 = load %x_199
            store %x_262_phi, %212
            exit_if  # if_9
          }
          $B45: {  # false
            %x_217:ptr<function, f32, read_write> = var
            %x_259:ptr<function, f32, read_write> = var
            %x_260_phi:ptr<function, f32, read_write> = var
            %216:i32 = load %x_181
            %217:bool = lt %216, 90i
            if %217 [t: $B46, f: $B47] {  # if_10
              $B46: {  # true
                %218:ptr<function, i32, read_write> = access %data, 2i
                %219:i32 = load %218
                %x_205:i32 = let %219
                %221:f32 = convert %x_205
                %222:f32 = mul %221, 0.10000000149011611938f
                %223:f32 = add 0.5f, %222
                store %x_208, %223
                %224:f32 = load %x_208
                store %x_261_phi, %224
                exit_if  # if_10
              }
              $B47: {  # false
                %225:i32 = load %x_181
                %226:bool = lt %225, 120i
                if %226 [t: $B48, f: $B49] {  # if_11
                  $B48: {  # true
                    %227:ptr<function, i32, read_write> = access %data, 3i
                    %228:i32 = load %227
                    %x_214:i32 = let %228
                    %230:f32 = convert %x_214
                    %231:f32 = mul %230, 0.10000000149011611938f
                    %232:f32 = add 0.5f, %231
                    store %x_217, %232
                    %233:f32 = load %x_217
                    store %x_260_phi, %233
                    exit_if  # if_11
                  }
                  $B49: {  # false
                    %x_230:ptr<function, f32, read_write> = var
                    %x_258:ptr<function, f32, read_write> = var
                    %x_259_phi:ptr<function, f32, read_write> = var
                    %237:i32 = load %x_181
                    %238:bool = lt %237, 150i
                    if %238 [t: $B50, f: $B51] {  # if_12
                      $B50: {  # true
                        store %continue_execution, false
                        exit_if  # if_12
                      }
                      $B51: {  # false
                        %x_239:ptr<function, f32, read_write> = var
                        %x_257:ptr<function, f32, read_write> = var
                        %x_258_phi:ptr<function, f32, read_write> = var
                        %242:i32 = load %x_181
                        %243:bool = lt %242, 180i
                        if %243 [t: $B52, f: $B53] {  # if_13
                          $B52: {  # true
                            %244:ptr<function, i32, read_write> = access %data, 5i
                            %245:i32 = load %244
                            %x_227:i32 = let %245
                            %247:f32 = convert %x_227
                            %248:f32 = mul %247, 0.10000000149011611938f
                            %249:f32 = add 0.5f, %248
                            store %x_230, %249
                            %250:f32 = load %x_230
                            store %x_259_phi, %250
                            exit_if  # if_13
                          }
                          $B53: {  # false
                            %x_248:ptr<function, f32, read_write> = var
                            %x_256:ptr<function, f32, read_write> = var
                            %x_257_phi:ptr<function, f32, read_write> = var
                            %254:i32 = load %x_181
                            %255:bool = lt %254, 210i
                            if %255 [t: $B54, f: $B55] {  # if_14
                              $B54: {  # true
                                %256:ptr<function, i32, read_write> = access %data, 6i
                                %257:i32 = load %256
                                %x_236:i32 = let %257
                                %259:f32 = convert %x_236
                                %260:f32 = mul %259, 0.10000000149011611938f
                                %261:f32 = add 0.5f, %260
                                store %x_239, %261
                                %262:f32 = load %x_239
                                store %x_258_phi, %262
                                exit_if  # if_14
                              }
                              $B55: {  # false
                                %263:i32 = load %x_181
                                %264:bool = lt %263, 240i
                                if %264 [t: $B56, f: $B57] {  # if_15
                                  $B56: {  # true
                                    %265:ptr<function, i32, read_write> = access %data, 7i
                                    %266:i32 = load %265
                                    %x_245:i32 = let %266
                                    %268:f32 = convert %x_245
                                    %269:f32 = mul %268, 0.10000000149011611938f
                                    %270:f32 = add 0.5f, %269
                                    store %x_248, %270
                                    %271:f32 = load %x_248
                                    store %x_257_phi, %271
                                    exit_if  # if_15
                                  }
                                  $B57: {  # false
                                    %272:i32 = load %x_181
                                    %273:bool = lt %272, 270i
                                    if %273 [t: $B58, f: $B59] {  # if_16
                                      $B58: {  # true
                                        exit_if  # if_16
                                      }
                                      $B59: {  # false
                                        store %continue_execution, false
                                        exit_if  # if_16
                                      }
                                    }
                                    %274:ptr<function, i32, read_write> = access %data, 8i
                                    %275:i32 = load %274
                                    %x_253:i32 = let %275
                                    %277:f32 = convert %x_253
                                    %278:f32 = mul %277, 0.10000000149011611938f
                                    %279:f32 = add 0.5f, %278
                                    store %x_256, %279
                                    %280:f32 = load %x_256
                                    store %x_257_phi, %280
                                    exit_if  # if_15
                                  }
                                }
                                %281:f32 = load %x_257_phi
                                store %x_257, %281
                                %282:f32 = load %x_257
                                store %x_258_phi, %282
                                exit_if  # if_14
                              }
                            }
                            %283:f32 = load %x_258_phi
                            store %x_258, %283
                            %284:f32 = load %x_258
                            store %x_259_phi, %284
                            exit_if  # if_13
                          }
                        }
                        %285:f32 = load %x_259_phi
                        store %x_259, %285
                        exit_if  # if_12
                      }
                    }
                    %286:f32 = load %x_259
                    store %x_260_phi, %286
                    exit_if  # if_11
                  }
                }
                %287:f32 = load %x_260_phi
                store %x_260, %287
                %288:f32 = load %x_260
                store %x_261_phi, %288
                exit_if  # if_10
              }
            }
            %289:f32 = load %x_261_phi
            store %x_261, %289
            %290:f32 = load %x_261
            store %x_262_phi, %290
            exit_if  # if_9
          }
        }
        %291:f32 = load %x_262_phi
        store %x_262, %291
        %292:f32 = load %x_262
        store %x_263_phi, %292
        exit_if  # if_8
      }
    }
    %293:f32 = load %x_263_phi
    %x_263:f32 = let %293
    %295:vec4<f32> = construct %x_263, %x_263, %x_263, 1.0f
    store %x_GLF_color, %295
    ret
  }
}
%tint_symbol = @fragment func(%gl_FragCoord_param:vec4<f32> [@position]):main_out {
  $B60: {
    store %gl_FragCoord, %gl_FragCoord_param
    %298:void = call %main_1
    %299:vec4<f32> = load %x_GLF_color
    %300:main_out = construct %299
    %301:bool = load %continue_execution
    %302:bool = eq %301, false
    if %302 [t: $B61] {  # if_17
      $B61: {  # true
        terminate_invocation
      }
    }
    ret %300
  }
}
%tint_f32_to_i32 = func(%value:f32):i32 {
  $B62: {
    %304:i32 = convert %value
    %305:bool = gte %value, -2147483648.0f
    %306:i32 = select -2147483648i, %304, %305
    %307:bool = lte %value, 2147483520.0f
    %308:i32 = select 2147483647i, %306, %307
    ret %308
  }
}

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