| SKIP: FAILED |
| |
| ../../src/tint/lang/msl/writer/printer/printer.cc:1257 internal compiler error: main_out = struct @align(16) { |
| x_GLF_color_1:vec4<f32> @offset(0), @location(0) |
| } |
| |
| $B1: { # root |
| %x_GLF_global_loop_count:ptr<private, i32, read_write> = var |
| %x_GLF_color:ptr<private, vec4<f32>, read_write> = var |
| } |
| |
| %main_1 = func():void { |
| $B2: { |
| %m23:ptr<function, mat2x3<f32>, read_write> = var |
| %m24:ptr<function, mat2x4<f32>, read_write> = var |
| %m32:ptr<function, mat3x2<f32>, read_write> = var |
| %m33:ptr<function, mat3x3<f32>, read_write> = var |
| %m34:ptr<function, mat3x4<f32>, read_write> = var |
| %m42:ptr<function, mat4x2<f32>, read_write> = var |
| %m43:ptr<function, mat4x3<f32>, read_write> = var |
| %m44:ptr<function, mat4x4<f32>, read_write> = var |
| %i:ptr<function, i32, read_write> = var |
| %i_1:ptr<function, i32, read_write> = var |
| %i_2:ptr<function, i32, read_write> = var |
| %i_3:ptr<function, i32, read_write> = var |
| %i_4:ptr<function, i32, read_write> = var |
| %i_5:ptr<function, i32, read_write> = var |
| %i_6:ptr<function, i32, read_write> = var |
| %i_7:ptr<function, i32, read_write> = var |
| %i_8:ptr<function, i32, read_write> = var |
| %i_9:ptr<function, i32, read_write> = var |
| %i_10:ptr<function, i32, read_write> = var |
| %i_11:ptr<function, i32, read_write> = var |
| %i_12:ptr<function, i32, read_write> = var |
| %i_13:ptr<function, i32, read_write> = var |
| %i_14:ptr<function, i32, read_write> = var |
| %i_15:ptr<function, i32, read_write> = var |
| %i_16:ptr<function, i32, read_write> = var |
| %i_17:ptr<function, i32, read_write> = var |
| %i_18:ptr<function, i32, read_write> = var |
| %i_19:ptr<function, i32, read_write> = var |
| %i_20:ptr<function, i32, read_write> = var |
| %i_21:ptr<function, i32, read_write> = var |
| %i_22:ptr<function, i32, read_write> = var |
| %i_23:ptr<function, i32, read_write> = var |
| %i_24:ptr<function, i32, read_write> = var |
| %i_25:ptr<function, i32, read_write> = var |
| %i_26:ptr<function, i32, read_write> = var |
| %i_27:ptr<function, i32, read_write> = var |
| %i_28:ptr<function, i32, read_write> = var |
| %i_29:ptr<function, i32, read_write> = var |
| %i_30:ptr<function, i32, read_write> = var |
| %i_31:ptr<function, i32, read_write> = var |
| %i_32:ptr<function, i32, read_write> = var |
| %i_33:ptr<function, i32, read_write> = var |
| %i_34:ptr<function, i32, read_write> = var |
| %i_35:ptr<function, i32, read_write> = var |
| %i_36:ptr<function, i32, read_write> = var |
| %i_37:ptr<function, i32, read_write> = var |
| %sum:ptr<function, f32, read_write> = var |
| %r:ptr<function, i32, read_write> = var |
| store %x_GLF_global_loop_count, 0i |
| store %m23, mat2x3<f32>(vec3<f32>(0.0f)) |
| store %m24, mat2x4<f32>(vec4<f32>(0.0f)) |
| store %m32, mat3x2<f32>(vec2<f32>(0.0f)) |
| store %m33, mat3x3<f32>(vec3<f32>(0.0f)) |
| store %m34, mat3x4<f32>(vec4<f32>(0.0f)) |
| store %m42, mat4x2<f32>(vec2<f32>(0.0f)) |
| store %m43, mat4x3<f32>(vec3<f32>(0.0f)) |
| store %m44, mat4x4<f32>(vec4<f32>(0.0f)) |
| store %i, 0i |
| loop [b: $B3, c: $B4] { # loop_1 |
| $B3: { # body |
| %52:i32 = load %i |
| %53:bool = lt %52, 1i |
| if %53 [t: $B5, f: $B6] { # if_1 |
| $B5: { # true |
| exit_if # if_1 |
| } |
| $B6: { # false |
| exit_loop # loop_1 |
| } |
| } |
| store %i_1, 0i |
| loop [b: $B7, c: $B8] { # loop_2 |
| $B7: { # body |
| %54:i32 = load %i_1 |
| %55:bool = lt %54, 1i |
| if %55 [t: $B9, f: $B10] { # if_2 |
| $B9: { # true |
| exit_if # if_2 |
| } |
| $B10: { # false |
| exit_loop # loop_2 |
| } |
| } |
| store %i_2, 0i |
| loop [b: $B11, c: $B12] { # loop_3 |
| $B11: { # body |
| %56:i32 = load %i_2 |
| %57:bool = lt %56, 1i |
| if %57 [t: $B13, f: $B14] { # if_3 |
| $B13: { # true |
| exit_if # if_3 |
| } |
| $B14: { # false |
| exit_loop # loop_3 |
| } |
| } |
| store %i_3, 0i |
| loop [b: $B15, c: $B16] { # loop_4 |
| $B15: { # body |
| %58:i32 = load %i_3 |
| %59:bool = lt %58, 1i |
| if %59 [t: $B17, f: $B18] { # if_4 |
| $B17: { # true |
| exit_if # if_4 |
| } |
| $B18: { # false |
| exit_loop # loop_4 |
| } |
| } |
| store %i_4, 0i |
| loop [b: $B19, c: $B20] { # loop_5 |
| $B19: { # body |
| %60:i32 = load %i_4 |
| %61:bool = lt %60, 1i |
| if %61 [t: $B21, f: $B22] { # if_5 |
| $B21: { # true |
| exit_if # if_5 |
| } |
| $B22: { # false |
| exit_loop # loop_5 |
| } |
| } |
| store %i_5, 0i |
| loop [b: $B23, c: $B24] { # loop_6 |
| $B23: { # body |
| %62:i32 = load %i_5 |
| %63:bool = lt %62, 1i |
| if %63 [t: $B25, f: $B26] { # if_6 |
| $B25: { # true |
| exit_if # if_6 |
| } |
| $B26: { # false |
| exit_loop # loop_6 |
| } |
| } |
| store %i_6, 0i |
| loop [b: $B27, c: $B28] { # loop_7 |
| $B27: { # body |
| %64:i32 = load %i_6 |
| %65:bool = lt %64, 1i |
| if %65 [t: $B29, f: $B30] { # if_7 |
| $B29: { # true |
| exit_if # if_7 |
| } |
| $B30: { # false |
| exit_loop # loop_7 |
| } |
| } |
| store %i_7, 0i |
| loop [b: $B31, c: $B32] { # loop_8 |
| $B31: { # body |
| %66:i32 = load %i_7 |
| %67:bool = lt %66, 1i |
| if %67 [t: $B33, f: $B34] { # if_8 |
| $B33: { # true |
| exit_if # if_8 |
| } |
| $B34: { # false |
| exit_loop # loop_8 |
| } |
| } |
| store %i_8, 0i |
| loop [b: $B35, c: $B36] { # loop_9 |
| $B35: { # body |
| %68:i32 = load %i_8 |
| %69:bool = lt %68, 1i |
| if %69 [t: $B37, f: $B38] { # if_9 |
| $B37: { # true |
| exit_if # if_9 |
| } |
| $B38: { # false |
| exit_loop # loop_9 |
| } |
| } |
| store %i_9, 0i |
| loop [b: $B39, c: $B40] { # loop_10 |
| $B39: { # body |
| %70:i32 = load %i_9 |
| %71:bool = lt %70, 1i |
| if %71 [t: $B41, f: $B42] { # if_10 |
| $B41: { # true |
| exit_if # if_10 |
| } |
| $B42: { # false |
| exit_loop # loop_10 |
| } |
| } |
| store %i_10, 0i |
| loop [b: $B43, c: $B44] { # loop_11 |
| $B43: { # body |
| %72:i32 = load %i_10 |
| %73:bool = lt %72, 1i |
| if %73 [t: $B45, f: $B46] { # if_11 |
| $B45: { # true |
| exit_if # if_11 |
| } |
| $B46: { # false |
| exit_loop # loop_11 |
| } |
| } |
| store %i_11, 0i |
| loop [b: $B47, c: $B48] { # loop_12 |
| $B47: { # body |
| %74:i32 = load %i_11 |
| %75:bool = lt %74, 1i |
| if %75 [t: $B49, f: $B50] { # if_12 |
| $B49: { # true |
| exit_if # if_12 |
| } |
| $B50: { # false |
| exit_loop # loop_12 |
| } |
| } |
| store %i_12, 0i |
| loop [b: $B51, c: $B52] { # loop_13 |
| $B51: { # body |
| %76:i32 = load %i_12 |
| %77:bool = lt %76, 1i |
| if %77 [t: $B53, f: $B54] { # if_13 |
| $B53: { # true |
| exit_if # if_13 |
| } |
| $B54: { # false |
| exit_loop # loop_13 |
| } |
| } |
| store %i_13, 0i |
| loop [b: $B55, c: $B56] { # loop_14 |
| $B55: { # body |
| %78:i32 = load %i_13 |
| %79:bool = lt %78, 1i |
| if %79 [t: $B57, f: $B58] { # if_14 |
| $B57: { # true |
| exit_if # if_14 |
| } |
| $B58: { # false |
| exit_loop # loop_14 |
| } |
| } |
| store %i_14, 0i |
| loop [b: $B59, c: $B60] { # loop_15 |
| $B59: { # body |
| %80:i32 = load %i_14 |
| %81:bool = lt %80, 1i |
| if %81 [t: $B61, f: $B62] { # if_15 |
| $B61: { # true |
| exit_if # if_15 |
| } |
| $B62: { # false |
| exit_loop # loop_15 |
| } |
| } |
| store %i_15, 0i |
| loop [b: $B63, c: $B64] { # loop_16 |
| $B63: { # body |
| %82:i32 = load %i_15 |
| %83:bool = lt %82, 1i |
| if %83 [t: $B65, f: $B66] { # if_16 |
| $B65: { # true |
| exit_if # if_16 |
| } |
| $B66: { # false |
| exit_loop # loop_16 |
| } |
| } |
| store %i_16, 0i |
| loop [b: $B67, c: $B68] { # loop_17 |
| $B67: { # body |
| %84:i32 = load %i_16 |
| %85:bool = lt %84, 1i |
| if %85 [t: $B69, f: $B70] { # if_17 |
| $B69: { # true |
| exit_if # if_17 |
| } |
| $B70: { # false |
| exit_loop # loop_17 |
| } |
| } |
| store %i_17, 0i |
| loop [b: $B71, c: $B72] { # loop_18 |
| $B71: { # body |
| %86:i32 = load %i_17 |
| %87:bool = lt %86, 1i |
| if %87 [t: $B73, f: $B74] { # if_18 |
| $B73: { # true |
| exit_if # if_18 |
| } |
| $B74: { # false |
| exit_loop # loop_18 |
| } |
| } |
| store %i_18, 0i |
| loop [b: $B75, c: $B76] { # loop_19 |
| $B75: { # body |
| %88:i32 = load %i_18 |
| %89:bool = lt %88, 1i |
| if %89 [t: $B77, f: $B78] { # if_19 |
| $B77: { # true |
| exit_if # if_19 |
| } |
| $B78: { # false |
| exit_loop # loop_19 |
| } |
| } |
| store %i_19, 0i |
| loop [b: $B79, c: $B80] { # loop_20 |
| $B79: { # body |
| %90:i32 = load %i_19 |
| %91:bool = lt %90, 1i |
| if %91 [t: $B81, f: $B82] { # if_20 |
| $B81: { # true |
| exit_if # if_20 |
| } |
| $B82: { # false |
| exit_loop # loop_20 |
| } |
| } |
| store %i_20, 0i |
| loop [b: $B83, c: $B84] { # loop_21 |
| $B83: { # body |
| %92:i32 = load %i_20 |
| %93:bool = lt %92, 1i |
| if %93 [t: $B85, f: $B86] { # if_21 |
| $B85: { # true |
| exit_if # if_21 |
| } |
| $B86: { # false |
| exit_loop # loop_21 |
| } |
| } |
| store %i_21, 0i |
| loop [b: $B87, c: $B88] { # loop_22 |
| $B87: { # body |
| %94:i32 = load %i_21 |
| %95:bool = lt %94, 1i |
| if %95 [t: $B89, f: $B90] { # if_22 |
| $B89: { # true |
| exit_if # if_22 |
| } |
| $B90: { # false |
| exit_loop # loop_22 |
| } |
| } |
| store %i_22, 0i |
| loop [b: $B91, c: $B92] { # loop_23 |
| $B91: { # body |
| %96:i32 = load %i_22 |
| %97:bool = lt %96, 1i |
| if %97 [t: $B93, f: $B94] { # if_23 |
| $B93: { # true |
| exit_if # if_23 |
| } |
| $B94: { # false |
| exit_loop # loop_23 |
| } |
| } |
| store %i_23, 0i |
| loop [b: $B95, c: $B96] { # loop_24 |
| $B95: { # body |
| %98:i32 = load %i_23 |
| %99:bool = lt %98, 1i |
| if %99 [t: $B97, f: $B98] { # if_24 |
| $B97: { # true |
| exit_if # if_24 |
| } |
| $B98: { # false |
| exit_loop # loop_24 |
| } |
| } |
| store %i_24, 0i |
| loop [b: $B99, c: $B100] { # loop_25 |
| $B99: { # body |
| %100:i32 = load %i_24 |
| %101:bool = lt %100, 1i |
| if %101 [t: $B101, f: $B102] { # if_25 |
| $B101: { # true |
| exit_if # if_25 |
| } |
| $B102: { # false |
| exit_loop # loop_25 |
| } |
| } |
| store %i_25, 0i |
| loop [b: $B103, c: $B104] { # loop_26 |
| $B103: { # body |
| %102:i32 = load %i_25 |
| %103:bool = lt %102, 1i |
| if %103 [t: $B105, f: $B106] { # if_26 |
| $B105: { # true |
| exit_if # if_26 |
| } |
| $B106: { # false |
| exit_loop # loop_26 |
| } |
| } |
| store %i_26, 0i |
| loop [b: $B107, c: $B108] { # loop_27 |
| $B107: { # body |
| %104:i32 = load %i_26 |
| %105:bool = lt %104, 1i |
| if %105 [t: $B109, f: $B110] { # if_27 |
| $B109: { # true |
| exit_if # if_27 |
| } |
| $B110: { # false |
| exit_loop # loop_27 |
| } |
| } |
| store %i_27, 0i |
| loop [b: $B111, c: $B112] { # loop_28 |
| $B111: { # body |
| %106:i32 = load %i_27 |
| %107:bool = lt %106, 1i |
| if %107 [t: $B113, f: $B114] { # if_28 |
| $B113: { # true |
| exit_if # if_28 |
| } |
| $B114: { # false |
| exit_loop # loop_28 |
| } |
| } |
| store %i_28, 0i |
| loop [b: $B115, c: $B116] { # loop_29 |
| $B115: { # body |
| %108:i32 = load %i_28 |
| %109:bool = lt %108, 1i |
| if %109 [t: $B117, f: $B118] { # if_29 |
| $B117: { # true |
| exit_if # if_29 |
| } |
| $B118: { # false |
| exit_loop # loop_29 |
| } |
| } |
| store %i_29, 0i |
| loop [b: $B119, c: $B120] { # loop_30 |
| $B119: { # body |
| %110:i32 = load %i_29 |
| %111:bool = lt %110, 1i |
| if %111 [t: $B121, f: $B122] { # if_30 |
| $B121: { # true |
| exit_if # if_30 |
| } |
| $B122: { # false |
| exit_loop # loop_30 |
| } |
| } |
| store %i_30, 0i |
| loop [b: $B123, c: $B124] { # loop_31 |
| $B123: { # body |
| %112:i32 = load %i_30 |
| %113:bool = lt %112, 1i |
| if %113 [t: $B125, f: $B126] { # if_31 |
| $B125: { # true |
| exit_if # if_31 |
| } |
| $B126: { # false |
| exit_loop # loop_31 |
| } |
| } |
| store %i_31, 0i |
| loop [b: $B127, c: $B128] { # loop_32 |
| $B127: { # body |
| %114:i32 = load %i_31 |
| %115:bool = lt %114, 1i |
| if %115 [t: $B129, f: $B130] { # if_32 |
| $B129: { # true |
| exit_if # if_32 |
| } |
| $B130: { # false |
| exit_loop # loop_32 |
| } |
| } |
| store %i_32, 0i |
| loop [b: $B131, c: $B132] { # loop_33 |
| $B131: { # body |
| %116:i32 = load %i_32 |
| %117:bool = lt %116, 1i |
| if %117 [t: $B133, f: $B134] { # if_33 |
| $B133: { # true |
| exit_if # if_33 |
| } |
| $B134: { # false |
| exit_loop # loop_33 |
| } |
| } |
| store %i_33, 0i |
| loop [b: $B135, c: $B136] { # loop_34 |
| $B135: { # body |
| %118:i32 = load %i_33 |
| %119:bool = lt %118, 1i |
| if %119 [t: $B137, f: $B138] { # if_34 |
| $B137: { # true |
| exit_if # if_34 |
| } |
| $B138: { # false |
| exit_loop # loop_34 |
| } |
| } |
| store %i_34, 0i |
| loop [b: $B139, c: $B140] { # loop_35 |
| $B139: { # body |
| %120:i32 = load %i_34 |
| %121:bool = lt %120, 1i |
| if %121 [t: $B141, f: $B142] { # if_35 |
| $B141: { # true |
| exit_if # if_35 |
| } |
| $B142: { # false |
| exit_loop # loop_35 |
| } |
| } |
| store %i_35, 0i |
| loop [b: $B143, c: $B144] { # loop_36 |
| $B143: { # body |
| %122:i32 = load %i_35 |
| %123:bool = lt %122, 1i |
| if %123 [t: $B145, f: $B146] { # if_36 |
| $B145: { # true |
| exit_if # if_36 |
| } |
| $B146: { # false |
| exit_loop # loop_36 |
| } |
| } |
| store %i_36, 0i |
| loop [b: $B147, c: $B148] { # loop_37 |
| $B147: { # body |
| %124:i32 = load %i_36 |
| %125:bool = lt %124, 1i |
| if %125 [t: $B149, f: $B150] { # if_37 |
| $B149: { # true |
| exit_if # if_37 |
| } |
| $B150: { # false |
| exit_loop # loop_37 |
| } |
| } |
| store %i_37, 0i |
| loop [b: $B151, c: $B152] { # loop_38 |
| $B151: { # body |
| %126:i32 = load %i_37 |
| %127:bool = lt %126, 1i |
| if %127 [t: $B153, f: $B154] { # if_38 |
| $B153: { # true |
| exit_if # if_38 |
| } |
| $B154: { # false |
| exit_loop # loop_38 |
| } |
| } |
| loop [b: $B155, c: $B156] { # loop_39 |
| $B155: { # body |
| %128:i32 = load %x_GLF_global_loop_count |
| %129:i32 = add %128, 1i |
| store %x_GLF_global_loop_count, %129 |
| continue # -> $B156 |
| } |
| $B156: { # continuing |
| %130:i32 = load %x_GLF_global_loop_count |
| %x_373:i32 = let %130 |
| %132:bool = lt %x_373, 98i |
| %133:bool = eq %132, false |
| break_if %133 # -> [t: exit_loop loop_39, f: $B155] |
| } |
| } |
| %134:i32 = load %i_37 |
| %x_375:i32 = let %134 |
| %136:i32 = load %i_37 |
| %x_376:i32 = let %136 |
| %138:ptr<function, vec3<f32>, read_write> = access %m23, %x_375 |
| store_vector_element %138, %x_376, 1.0f |
| %139:i32 = load %i_37 |
| %x_378:i32 = let %139 |
| %141:i32 = load %i_37 |
| %x_379:i32 = let %141 |
| %143:ptr<function, vec4<f32>, read_write> = access %m24, %x_378 |
| store_vector_element %143, %x_379, 1.0f |
| %144:i32 = load %i_37 |
| %x_381:i32 = let %144 |
| %146:i32 = load %i_37 |
| %x_382:i32 = let %146 |
| %148:ptr<function, vec2<f32>, read_write> = access %m32, %x_381 |
| store_vector_element %148, %x_382, 1.0f |
| %149:i32 = load %i_37 |
| %x_384:i32 = let %149 |
| %151:i32 = load %i_37 |
| %x_385:i32 = let %151 |
| %153:ptr<function, vec3<f32>, read_write> = access %m33, %x_384 |
| store_vector_element %153, %x_385, 1.0f |
| %154:i32 = load %i_37 |
| %x_387:i32 = let %154 |
| %156:i32 = load %i_37 |
| %x_388:i32 = let %156 |
| %158:ptr<function, vec4<f32>, read_write> = access %m34, %x_387 |
| store_vector_element %158, %x_388, 1.0f |
| %159:i32 = load %i_37 |
| %x_390:i32 = let %159 |
| %161:i32 = load %i_37 |
| %x_391:i32 = let %161 |
| %163:ptr<function, vec2<f32>, read_write> = access %m42, %x_390 |
| store_vector_element %163, %x_391, 1.0f |
| %164:i32 = load %i_37 |
| %x_393:i32 = let %164 |
| %166:i32 = load %i_37 |
| %x_394:i32 = let %166 |
| %168:ptr<function, vec3<f32>, read_write> = access %m43, %x_393 |
| store_vector_element %168, %x_394, 1.0f |
| %169:i32 = load %i_37 |
| %x_396:i32 = let %169 |
| %171:i32 = load %i_37 |
| %x_397:i32 = let %171 |
| %173:ptr<function, vec4<f32>, read_write> = access %m44, %x_396 |
| store_vector_element %173, %x_397, 1.0f |
| continue # -> $B152 |
| } |
| $B152: { # continuing |
| %174:i32 = load %i_37 |
| %175:i32 = add %174, 1i |
| store %i_37, %175 |
| next_iteration # -> $B151 |
| } |
| } |
| continue # -> $B148 |
| } |
| $B148: { # continuing |
| %176:i32 = load %i_36 |
| %177:i32 = add %176, 1i |
| store %i_36, %177 |
| next_iteration # -> $B147 |
| } |
| } |
| continue # -> $B144 |
| } |
| $B144: { # continuing |
| %178:i32 = load %i_35 |
| %179:i32 = add %178, 1i |
| store %i_35, %179 |
| next_iteration # -> $B143 |
| } |
| } |
| continue # -> $B140 |
| } |
| $B140: { # continuing |
| %180:i32 = load %i_34 |
| %181:i32 = add %180, 1i |
| store %i_34, %181 |
| next_iteration # -> $B139 |
| } |
| } |
| continue # -> $B136 |
| } |
| $B136: { # continuing |
| %182:i32 = load %i_33 |
| %183:i32 = add %182, 1i |
| store %i_33, %183 |
| next_iteration # -> $B135 |
| } |
| } |
| continue # -> $B132 |
| } |
| $B132: { # continuing |
| %184:i32 = load %i_32 |
| %185:i32 = add %184, 1i |
| store %i_32, %185 |
| next_iteration # -> $B131 |
| } |
| } |
| continue # -> $B128 |
| } |
| $B128: { # continuing |
| %186:i32 = load %i_31 |
| %187:i32 = add %186, 1i |
| store %i_31, %187 |
| next_iteration # -> $B127 |
| } |
| } |
| continue # -> $B124 |
| } |
| $B124: { # continuing |
| %188:i32 = load %i_30 |
| %189:i32 = add %188, 1i |
| store %i_30, %189 |
| next_iteration # -> $B123 |
| } |
| } |
| continue # -> $B120 |
| } |
| $B120: { # continuing |
| %190:i32 = load %i_29 |
| %191:i32 = add %190, 1i |
| store %i_29, %191 |
| next_iteration # -> $B119 |
| } |
| } |
| continue # -> $B116 |
| } |
| $B116: { # continuing |
| %192:i32 = load %i_28 |
| %193:i32 = add %192, 1i |
| store %i_28, %193 |
| next_iteration # -> $B115 |
| } |
| } |
| continue # -> $B112 |
| } |
| $B112: { # continuing |
| %194:i32 = load %i_27 |
| %195:i32 = add %194, 1i |
| store %i_27, %195 |
| next_iteration # -> $B111 |
| } |
| } |
| continue # -> $B108 |
| } |
| $B108: { # continuing |
| %196:i32 = load %i_26 |
| %197:i32 = add %196, 1i |
| store %i_26, %197 |
| next_iteration # -> $B107 |
| } |
| } |
| continue # -> $B104 |
| } |
| $B104: { # continuing |
| %198:i32 = load %i_25 |
| %199:i32 = add %198, 1i |
| store %i_25, %199 |
| next_iteration # -> $B103 |
| } |
| } |
| continue # -> $B100 |
| } |
| $B100: { # continuing |
| %200:i32 = load %i_24 |
| %201:i32 = add %200, 1i |
| store %i_24, %201 |
| next_iteration # -> $B99 |
| } |
| } |
| continue # -> $B96 |
| } |
| $B96: { # continuing |
| %202:i32 = load %i_23 |
| %203:i32 = add %202, 1i |
| store %i_23, %203 |
| next_iteration # -> $B95 |
| } |
| } |
| continue # -> $B92 |
| } |
| $B92: { # continuing |
| %204:i32 = load %i_22 |
| %205:i32 = add %204, 1i |
| store %i_22, %205 |
| next_iteration # -> $B91 |
| } |
| } |
| continue # -> $B88 |
| } |
| $B88: { # continuing |
| %206:i32 = load %i_21 |
| %207:i32 = add %206, 1i |
| store %i_21, %207 |
| next_iteration # -> $B87 |
| } |
| } |
| continue # -> $B84 |
| } |
| $B84: { # continuing |
| %208:i32 = load %i_20 |
| %209:i32 = add %208, 1i |
| store %i_20, %209 |
| next_iteration # -> $B83 |
| } |
| } |
| continue # -> $B80 |
| } |
| $B80: { # continuing |
| %210:i32 = load %i_19 |
| %211:i32 = add %210, 1i |
| store %i_19, %211 |
| next_iteration # -> $B79 |
| } |
| } |
| continue # -> $B76 |
| } |
| $B76: { # continuing |
| %212:i32 = load %i_18 |
| %213:i32 = add %212, 1i |
| store %i_18, %213 |
| next_iteration # -> $B75 |
| } |
| } |
| continue # -> $B72 |
| } |
| $B72: { # continuing |
| %214:i32 = load %i_17 |
| %215:i32 = add %214, 1i |
| store %i_17, %215 |
| next_iteration # -> $B71 |
| } |
| } |
| continue # -> $B68 |
| } |
| $B68: { # continuing |
| %216:i32 = load %i_16 |
| %217:i32 = add %216, 1i |
| store %i_16, %217 |
| next_iteration # -> $B67 |
| } |
| } |
| continue # -> $B64 |
| } |
| $B64: { # continuing |
| %218:i32 = load %i_15 |
| %219:i32 = add %218, 1i |
| store %i_15, %219 |
| next_iteration # -> $B63 |
| } |
| } |
| continue # -> $B60 |
| } |
| $B60: { # continuing |
| %220:i32 = load %i_14 |
| %221:i32 = add %220, 1i |
| store %i_14, %221 |
| next_iteration # -> $B59 |
| } |
| } |
| continue # -> $B56 |
| } |
| $B56: { # continuing |
| %222:i32 = load %i_13 |
| %223:i32 = add %222, 1i |
| store %i_13, %223 |
| next_iteration # -> $B55 |
| } |
| } |
| continue # -> $B52 |
| } |
| $B52: { # continuing |
| %224:i32 = load %i_12 |
| %225:i32 = add %224, 1i |
| store %i_12, %225 |
| next_iteration # -> $B51 |
| } |
| } |
| continue # -> $B48 |
| } |
| $B48: { # continuing |
| %226:i32 = load %i_11 |
| %227:i32 = add %226, 1i |
| store %i_11, %227 |
| next_iteration # -> $B47 |
| } |
| } |
| continue # -> $B44 |
| } |
| $B44: { # continuing |
| %228:i32 = load %i_10 |
| %229:i32 = add %228, 1i |
| store %i_10, %229 |
| next_iteration # -> $B43 |
| } |
| } |
| continue # -> $B40 |
| } |
| $B40: { # continuing |
| %230:i32 = load %i_9 |
| %231:i32 = add %230, 1i |
| store %i_9, %231 |
| next_iteration # -> $B39 |
| } |
| } |
| continue # -> $B36 |
| } |
| $B36: { # continuing |
| %232:i32 = load %i_8 |
| %233:i32 = add %232, 1i |
| store %i_8, %233 |
| next_iteration # -> $B35 |
| } |
| } |
| continue # -> $B32 |
| } |
| $B32: { # continuing |
| %234:i32 = load %i_7 |
| %235:i32 = add %234, 1i |
| store %i_7, %235 |
| next_iteration # -> $B31 |
| } |
| } |
| continue # -> $B28 |
| } |
| $B28: { # continuing |
| %236:i32 = load %i_6 |
| %237:i32 = add %236, 1i |
| store %i_6, %237 |
| next_iteration # -> $B27 |
| } |
| } |
| continue # -> $B24 |
| } |
| $B24: { # continuing |
| %238:i32 = load %i_5 |
| %239:i32 = add %238, 1i |
| store %i_5, %239 |
| next_iteration # -> $B23 |
| } |
| } |
| continue # -> $B20 |
| } |
| $B20: { # continuing |
| %240:i32 = load %i_4 |
| %241:i32 = add %240, 1i |
| store %i_4, %241 |
| next_iteration # -> $B19 |
| } |
| } |
| continue # -> $B16 |
| } |
| $B16: { # continuing |
| %242:i32 = load %i_3 |
| %243:i32 = add %242, 1i |
| store %i_3, %243 |
| next_iteration # -> $B15 |
| } |
| } |
| continue # -> $B12 |
| } |
| $B12: { # continuing |
| %244:i32 = load %i_2 |
| %245:i32 = add %244, 1i |
| store %i_2, %245 |
| next_iteration # -> $B11 |
| } |
| } |
| continue # -> $B8 |
| } |
| $B8: { # continuing |
| %246:i32 = load %i_1 |
| %247:i32 = add %246, 1i |
| store %i_1, %247 |
| next_iteration # -> $B7 |
| } |
| } |
| continue # -> $B4 |
| } |
| $B4: { # continuing |
| %248:i32 = load %i |
| %249:i32 = add %248, 1i |
| store %i, %249 |
| next_iteration # -> $B3 |
| } |
| } |
| store %sum, 0.0f |
| store %r, 0i |
| loop [b: $B157, c: $B158] { # loop_40 |
| $B157: { # body |
| %250:i32 = load %x_GLF_global_loop_count |
| %251:bool = lt %250, 100i |
| if %251 [t: $B159, f: $B160] { # if_39 |
| $B159: { # true |
| exit_if # if_39 |
| } |
| $B160: { # false |
| exit_loop # loop_40 |
| } |
| } |
| %252:i32 = load %x_GLF_global_loop_count |
| %253:i32 = add %252, 1i |
| store %x_GLF_global_loop_count, %253 |
| %254:f32 = load %sum |
| %255:ptr<function, vec3<f32>, read_write> = access %m23, 0i |
| %256:i32 = load %r |
| %257:f32 = load_vector_element %255, %256 |
| %258:f32 = add %254, %257 |
| store %sum, %258 |
| %259:f32 = load %sum |
| %260:ptr<function, vec4<f32>, read_write> = access %m24, 0i |
| %261:i32 = load %r |
| %262:f32 = load_vector_element %260, %261 |
| %263:f32 = add %259, %262 |
| store %sum, %263 |
| %264:f32 = load %sum |
| %265:ptr<function, vec2<f32>, read_write> = access %m32, 0i |
| %266:i32 = load %r |
| %267:f32 = load_vector_element %265, %266 |
| %268:f32 = add %264, %267 |
| store %sum, %268 |
| %269:f32 = load %sum |
| %270:ptr<function, vec3<f32>, read_write> = access %m33, 0i |
| %271:i32 = load %r |
| %272:f32 = load_vector_element %270, %271 |
| %273:f32 = add %269, %272 |
| store %sum, %273 |
| %274:f32 = load %sum |
| %275:ptr<function, vec4<f32>, read_write> = access %m34, 0i |
| %276:i32 = load %r |
| %277:f32 = load_vector_element %275, %276 |
| %278:f32 = add %274, %277 |
| store %sum, %278 |
| %279:f32 = load %sum |
| %280:ptr<function, vec2<f32>, read_write> = access %m42, 0i |
| %281:i32 = load %r |
| %282:f32 = load_vector_element %280, %281 |
| %283:f32 = add %279, %282 |
| store %sum, %283 |
| %284:f32 = load %sum |
| %285:ptr<function, vec3<f32>, read_write> = access %m43, 0i |
| %286:i32 = load %r |
| %287:f32 = load_vector_element %285, %286 |
| %288:f32 = add %284, %287 |
| store %sum, %288 |
| %289:f32 = load %sum |
| %290:ptr<function, vec4<f32>, read_write> = access %m44, 0i |
| %291:i32 = load %r |
| %292:f32 = load_vector_element %290, %291 |
| %293:f32 = add %289, %292 |
| store %sum, %293 |
| continue # -> $B158 |
| } |
| $B158: { # continuing |
| %294:i32 = load %r |
| %295:i32 = add %294, 1i |
| store %r, %295 |
| next_iteration # -> $B157 |
| } |
| } |
| %296:f32 = load %sum |
| %297:bool = eq %296, 8.0f |
| if %297 [t: $B161, f: $B162] { # if_40 |
| $B161: { # true |
| store %x_GLF_color, vec4<f32>(1.0f, 0.0f, 0.0f, 1.0f) |
| exit_if # if_40 |
| } |
| $B162: { # false |
| store %x_GLF_color, vec4<f32>(0.0f) |
| exit_if # if_40 |
| } |
| } |
| ret |
| } |
| } |
| %tint_symbol = @fragment func():main_out { |
| $B163: { |
| %299:void = call %main_1 |
| %300:vec4<f32> = load %x_GLF_color |
| %301:main_out = construct %300 |
| ret %301 |
| } |
| } |
| |
| invalid entry point IO struct uses |
| ******************************************************************** |
| * 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. * |
| ******************************************************************** |
