| SKIP: FAILED |
| |
| ../../src/tint/lang/msl/writer/printer/printer.cc:500 internal compiler error: QuicksortObject = struct @align(4) { |
| numbers:array<i32, 10> @offset(0) |
| } |
| |
| buf0 = struct @align(8) { |
| resolution:vec2<f32> @offset(0) |
| } |
| |
| main_out = struct @align(16) { |
| frag_color_1:vec4<f32> @offset(0), @location(0) |
| gl_Position:vec4<f32> @offset(16), @builtin(position) |
| } |
| |
| $B1: { # root |
| %obj:ptr<private, QuicksortObject, read_write> = var |
| %x_GLF_FragCoord:ptr<private, vec4<f32>, read_write> = var |
| %x_GLF_pos:ptr<private, vec4<f32>, read_write> = var |
| %x_34:ptr<uniform, buf0, read> = var @binding_point(0, 0) |
| %frag_color:ptr<private, vec4<f32>, read_write> = var |
| %gl_Position:ptr<private, vec4<f32>, read_write> = var |
| } |
| |
| %performPartition_i1_i1_ = func(%l:ptr<function, i32, read_write>, %h:ptr<function, i32, read_write>):i32 { |
| $B2: { |
| %x_314:ptr<function, i32, read_write> = var |
| %x_315:ptr<function, i32, read_write> = var |
| %pivot:ptr<function, i32, read_write> = var |
| %i_1:ptr<function, i32, read_write> = var |
| %j_1:ptr<function, i32, read_write> = var |
| %param:ptr<function, i32, read_write> = var |
| %param_1:ptr<function, i32, read_write> = var |
| %param_2:ptr<function, i32, read_write> = var |
| %param_3:ptr<function, i32, read_write> = var |
| %19:i32 = load %h |
| %20:ptr<private, i32, read_write> = access %obj, 0u, %19 |
| %21:i32 = load %20 |
| store %pivot, %21 |
| %22:i32 = load %l |
| %23:i32 = sub %22, 1i |
| store %i_1, %23 |
| %24:i32 = load %l |
| store %j_1, %24 |
| loop [b: $B3, c: $B4] { # loop_1 |
| $B3: { # body |
| %25:i32 = load %j_1 |
| %26:i32 = load %h |
| %27:i32 = sub %26, 1i |
| %28:bool = lte %25, %27 |
| if %28 [t: $B5, f: $B6] { # if_1 |
| $B5: { # true |
| exit_if # if_1 |
| } |
| $B6: { # false |
| exit_loop # loop_1 |
| } |
| } |
| %29:i32 = load %j_1 |
| %30:ptr<private, i32, read_write> = access %obj, 0u, %29 |
| %31:i32 = load %30 |
| %32:i32 = load %pivot |
| %33:bool = lte %31, %32 |
| if %33 [t: $B7] { # if_2 |
| $B7: { # true |
| %34:i32 = load %i_1 |
| %35:i32 = add %34, 1i |
| store %i_1, %35 |
| %36:i32 = load %i_1 |
| store %param, %36 |
| %37:i32 = load %j_1 |
| store %param_1, %37 |
| %38:i32 = load %param |
| %39:ptr<private, i32, read_write> = access %obj, 0u, %38 |
| %40:i32 = load %39 |
| store %x_315, %40 |
| %41:i32 = load %param |
| %x_345:i32 = let %41 |
| %43:ptr<private, i32, read_write> = access %obj, 0u, %x_345 |
| %44:i32 = load %param_1 |
| %45:ptr<private, i32, read_write> = access %obj, 0u, %44 |
| %46:i32 = load %45 |
| store %43, %46 |
| %47:i32 = load %param_1 |
| %x_350:i32 = let %47 |
| %49:ptr<private, i32, read_write> = access %obj, 0u, %x_350 |
| %50:i32 = load %x_315 |
| store %49, %50 |
| exit_if # if_2 |
| } |
| } |
| continue # -> $B4 |
| } |
| $B4: { # continuing |
| %51:i32 = load %j_1 |
| %52:i32 = add %51, 1i |
| store %j_1, %52 |
| next_iteration # -> $B3 |
| } |
| } |
| %53:i32 = load %i_1 |
| %54:i32 = add %53, 1i |
| store %param_2, %54 |
| %55:i32 = load %h |
| store %param_3, %55 |
| %56:i32 = load %param_2 |
| %57:ptr<private, i32, read_write> = access %obj, 0u, %56 |
| %58:i32 = load %57 |
| store %x_314, %58 |
| %59:i32 = load %param_2 |
| %x_361:i32 = let %59 |
| %61:ptr<private, i32, read_write> = access %obj, 0u, %x_361 |
| %62:i32 = load %param_3 |
| %63:ptr<private, i32, read_write> = access %obj, 0u, %62 |
| %64:i32 = load %63 |
| store %61, %64 |
| %65:i32 = load %param_3 |
| %x_366:i32 = let %65 |
| %67:ptr<private, i32, read_write> = access %obj, 0u, %x_366 |
| %68:i32 = load %x_314 |
| store %67, %68 |
| if false [t: $B8, f: $B9] { # if_3 |
| $B8: { # true |
| exit_if # if_3 |
| } |
| $B9: { # false |
| %69:i32 = load %i_1 |
| %x_372:i32 = let %69 |
| %71:i32 = add %x_372, 1i |
| ret %71 |
| } |
| } |
| ret 0i |
| } |
| } |
| %main_1 = func():void { |
| $B10: { |
| %x_91:ptr<function, i32, read_write> = var |
| %x_92:ptr<function, i32, read_write> = var |
| %x_93:ptr<function, i32, read_write> = var |
| %x_94:ptr<function, array<i32, 10>, read_write> = var |
| %x_95:ptr<function, i32, read_write> = var |
| %x_96:ptr<function, i32, read_write> = var |
| %x_97:ptr<function, i32, read_write> = var |
| %i_2:ptr<function, i32, read_write> = var |
| %uv:ptr<function, vec2<f32>, read_write> = var |
| %color:ptr<function, vec3<f32>, read_write> = var |
| %83:vec4<f32> = load %x_GLF_pos |
| %84:vec4<f32> = add %83, vec4<f32>(1.0f, 1.0f, 0.0f, 0.0f) |
| %85:vec4<f32> = mul %84, vec4<f32>(128.0f, 128.0f, 1.0f, 1.0f) |
| store %x_GLF_FragCoord, %85 |
| store %i_2, 0i |
| loop [b: $B11, c: $B12] { # loop_2 |
| $B11: { # body |
| %86:i32 = load %i_2 |
| %87:bool = lt %86, 10i |
| if %87 [t: $B13, f: $B14] { # if_4 |
| $B13: { # true |
| exit_if # if_4 |
| } |
| $B14: { # false |
| exit_loop # loop_2 |
| } |
| } |
| %88:i32 = load %i_2 |
| %x_108:i32 = let %88 |
| %90:ptr<private, i32, read_write> = access %obj, 0u, %x_108 |
| %91:i32 = load %i_2 |
| %92:i32 = sub 10i, %91 |
| store %90, %92 |
| %93:i32 = load %i_2 |
| %x_112:i32 = let %93 |
| %95:ptr<private, i32, read_write> = access %obj, 0u, %x_112 |
| %96:i32 = load %i_2 |
| %97:ptr<private, i32, read_write> = access %obj, 0u, %96 |
| %98:i32 = load %97 |
| %99:i32 = load %i_2 |
| %100:ptr<private, i32, read_write> = access %obj, 0u, %99 |
| %101:i32 = load %100 |
| %102:i32 = mul %98, %101 |
| store %95, %102 |
| continue # -> $B12 |
| } |
| $B12: { # continuing |
| %103:i32 = load %i_2 |
| %104:i32 = add %103, 1i |
| store %i_2, %104 |
| next_iteration # -> $B11 |
| } |
| } |
| store %x_91, 0i |
| store %x_92, 9i |
| store %x_93, -1i |
| %105:i32 = load %x_93 |
| %106:i32 = add %105, 1i |
| %x_124:i32 = let %106 |
| store %x_93, %x_124 |
| %108:ptr<function, i32, read_write> = access %x_94, %x_124 |
| %109:i32 = load %x_91 |
| store %108, %109 |
| %110:i32 = load %x_93 |
| %111:i32 = add %110, 1i |
| %x_128:i32 = let %111 |
| store %x_93, %x_128 |
| %113:ptr<function, i32, read_write> = access %x_94, %x_128 |
| %114:i32 = load %x_92 |
| store %113, %114 |
| loop [b: $B15, c: $B16] { # loop_3 |
| $B15: { # body |
| %115:i32 = load %x_93 |
| %116:bool = gte %115, 0i |
| if %116 [t: $B17, f: $B18] { # if_5 |
| $B17: { # true |
| exit_if # if_5 |
| } |
| $B18: { # false |
| exit_loop # loop_3 |
| } |
| } |
| %117:i32 = load %x_93 |
| %x_138:i32 = let %117 |
| %119:i32 = load %x_93 |
| %120:i32 = sub %119, 1i |
| store %x_93, %120 |
| %121:ptr<function, i32, read_write> = access %x_94, %x_138 |
| %122:i32 = load %121 |
| store %x_92, %122 |
| %123:i32 = load %x_93 |
| %x_142:i32 = let %123 |
| %125:i32 = load %x_93 |
| %126:i32 = sub %125, 1i |
| store %x_93, %126 |
| %127:ptr<function, i32, read_write> = access %x_94, %x_142 |
| %128:i32 = load %127 |
| store %x_91, %128 |
| %129:i32 = load %x_91 |
| store %x_96, %129 |
| %130:i32 = load %x_92 |
| store %x_97, %130 |
| %131:i32 = call %performPartition_i1_i1_, %x_96, %x_97 |
| %x_148:i32 = let %131 |
| store %x_95, %x_148 |
| %133:i32 = load %x_95 |
| %134:i32 = sub %133, 1i |
| %135:i32 = load %x_91 |
| %136:bool = gt %134, %135 |
| if %136 [t: $B19] { # if_6 |
| $B19: { # true |
| %137:i32 = load %x_93 |
| %138:i32 = add %137, 1i |
| %x_156:i32 = let %138 |
| store %x_93, %x_156 |
| %140:ptr<function, i32, read_write> = access %x_94, %x_156 |
| %141:i32 = load %x_91 |
| store %140, %141 |
| %142:i32 = load %x_93 |
| %143:i32 = add %142, 1i |
| %x_160:i32 = let %143 |
| store %x_93, %x_160 |
| %145:ptr<function, i32, read_write> = access %x_94, %x_160 |
| %146:i32 = load %x_95 |
| %147:i32 = sub %146, 1i |
| store %145, %147 |
| exit_if # if_6 |
| } |
| } |
| %148:i32 = load %x_95 |
| %149:i32 = add %148, 1i |
| %150:i32 = load %x_92 |
| %151:bool = lt %149, %150 |
| if %151 [t: $B20] { # if_7 |
| $B20: { # true |
| %152:i32 = load %x_93 |
| %153:i32 = add %152, 1i |
| %x_171:i32 = let %153 |
| store %x_93, %x_171 |
| %155:ptr<function, i32, read_write> = access %x_94, %x_171 |
| %156:i32 = load %x_95 |
| %157:i32 = add %156, 1i |
| store %155, %157 |
| %158:i32 = load %x_93 |
| %159:i32 = add %158, 1i |
| %x_176:i32 = let %159 |
| store %x_93, %x_176 |
| %161:ptr<function, i32, read_write> = access %x_94, %x_176 |
| %162:i32 = load %x_92 |
| store %161, %162 |
| exit_if # if_7 |
| } |
| } |
| continue # -> $B16 |
| } |
| $B16: { # continuing |
| next_iteration # -> $B15 |
| } |
| } |
| %163:vec4<f32> = load %x_GLF_FragCoord |
| %164:vec2<f32> = swizzle %163, xy |
| %165:ptr<uniform, vec2<f32>, read> = access %x_34, 0u |
| %166:vec2<f32> = load %165 |
| %167:vec2<f32> = div %164, %166 |
| store %uv, %167 |
| store %color, vec3<f32>(1.0f, 2.0f, 3.0f) |
| %168:f32 = load_vector_element %color, 0u |
| %169:f32 = let %168 |
| %170:ptr<private, i32, read_write> = access %obj, 0u, 0i |
| %171:i32 = load %170 |
| %172:f32 = convert %171 |
| %173:f32 = add %169, %172 |
| store_vector_element %color, 0u, %173 |
| %174:f32 = load_vector_element %uv, 0u |
| %175:bool = gt %174, 0.25f |
| if %175 [t: $B21] { # if_8 |
| $B21: { # true |
| %176:f32 = load_vector_element %color, 0u |
| %177:f32 = let %176 |
| %178:ptr<private, i32, read_write> = access %obj, 0u, 1i |
| %179:i32 = load %178 |
| %180:f32 = convert %179 |
| %181:f32 = add %177, %180 |
| store_vector_element %color, 0u, %181 |
| exit_if # if_8 |
| } |
| } |
| %182:f32 = load_vector_element %uv, 0u |
| %183:bool = gt %182, 0.5f |
| if %183 [t: $B22] { # if_9 |
| $B22: { # true |
| %184:f32 = load_vector_element %color, 1u |
| %185:f32 = let %184 |
| %186:ptr<private, i32, read_write> = access %obj, 0u, 2i |
| %187:i32 = load %186 |
| %188:f32 = convert %187 |
| %189:f32 = add %185, %188 |
| store_vector_element %color, 1u, %189 |
| exit_if # if_9 |
| } |
| } |
| %190:f32 = load_vector_element %uv, 0u |
| %191:bool = gt %190, 0.75f |
| if %191 [t: $B23] { # if_10 |
| $B23: { # true |
| %192:f32 = load_vector_element %color, 2u |
| %193:f32 = let %192 |
| %194:ptr<private, i32, read_write> = access %obj, 0u, 3i |
| %195:i32 = load %194 |
| %196:f32 = convert %195 |
| %197:f32 = add %193, %196 |
| store_vector_element %color, 2u, %197 |
| exit_if # if_10 |
| } |
| } |
| %198:f32 = load_vector_element %color, 1u |
| %199:f32 = let %198 |
| %200:ptr<private, i32, read_write> = access %obj, 0u, 4i |
| %201:i32 = load %200 |
| %202:f32 = convert %201 |
| %203:f32 = add %199, %202 |
| store_vector_element %color, 1u, %203 |
| %204:f32 = load_vector_element %uv, 1u |
| %205:bool = gt %204, 0.25f |
| if %205 [t: $B24] { # if_11 |
| $B24: { # true |
| %206:f32 = load_vector_element %color, 0u |
| %207:f32 = let %206 |
| %208:ptr<private, i32, read_write> = access %obj, 0u, 5i |
| %209:i32 = load %208 |
| %210:f32 = convert %209 |
| %211:f32 = add %207, %210 |
| store_vector_element %color, 0u, %211 |
| exit_if # if_11 |
| } |
| } |
| %212:f32 = load_vector_element %uv, 1u |
| %213:bool = gt %212, 0.5f |
| if %213 [t: $B25] { # if_12 |
| $B25: { # true |
| %214:f32 = load_vector_element %color, 1u |
| %215:f32 = let %214 |
| %216:ptr<private, i32, read_write> = access %obj, 0u, 6i |
| %217:i32 = load %216 |
| %218:f32 = convert %217 |
| %219:f32 = add %215, %218 |
| store_vector_element %color, 1u, %219 |
| exit_if # if_12 |
| } |
| } |
| %220:f32 = load_vector_element %uv, 1u |
| %221:bool = gt %220, 0.75f |
| if %221 [t: $B26] { # if_13 |
| $B26: { # true |
| %222:f32 = load_vector_element %color, 2u |
| %223:f32 = let %222 |
| %224:ptr<private, i32, read_write> = access %obj, 0u, 7i |
| %225:i32 = load %224 |
| %226:f32 = convert %225 |
| %227:f32 = add %223, %226 |
| store_vector_element %color, 2u, %227 |
| exit_if # if_13 |
| } |
| } |
| %228:f32 = load_vector_element %color, 2u |
| %229:f32 = let %228 |
| %230:ptr<private, i32, read_write> = access %obj, 0u, 8i |
| %231:i32 = load %230 |
| %232:f32 = convert %231 |
| %233:f32 = add %229, %232 |
| store_vector_element %color, 2u, %233 |
| %234:f32 = load_vector_element %uv, 0u |
| %235:f32 = load_vector_element %uv, 1u |
| %236:f32 = sub %234, %235 |
| %237:f32 = abs %236 |
| %238:bool = lt %237, 0.25f |
| if %238 [t: $B27] { # if_14 |
| $B27: { # true |
| %239:f32 = load_vector_element %color, 0u |
| %240:f32 = let %239 |
| %241:ptr<private, i32, read_write> = access %obj, 0u, 9i |
| %242:i32 = load %241 |
| %243:f32 = convert %242 |
| %244:f32 = add %240, %243 |
| store_vector_element %color, 0u, %244 |
| exit_if # if_14 |
| } |
| } |
| %245:vec3<f32> = load %color |
| %246:vec3<f32> = normalize %245 |
| %x_294:vec3<f32> = let %246 |
| %248:f32 = access %x_294, 0u |
| %249:f32 = access %x_294, 1u |
| %250:f32 = access %x_294, 2u |
| %251:vec4<f32> = construct %248, %249, %250, 1.0f |
| store %frag_color, %251 |
| %252:vec4<f32> = load %x_GLF_pos |
| store %gl_Position, %252 |
| ret |
| } |
| } |
| %tint_symbol = @vertex func(%x_GLF_pos_param:vec4<f32> [@location(0)]):main_out { |
| $B28: { |
| store %x_GLF_pos, %x_GLF_pos_param |
| %255:void = call %main_1 |
| %256:vec4<f32> = load %frag_color |
| %257:vec4<f32> = load %gl_Position |
| %258:main_out = construct %256, %257 |
| ret %258 |
| } |
| } |
| %swap_i1_i1_ = func(%i:ptr<function, i32, read_write>, %j:ptr<function, i32, read_write>):void { |
| $B29: { |
| %temp:ptr<function, i32, read_write> = var |
| %263:i32 = load %i |
| %264:ptr<private, i32, read_write> = access %obj, 0u, %263 |
| %265:i32 = load %264 |
| store %temp, %265 |
| %266:i32 = load %i |
| %x_305:i32 = let %266 |
| %268:ptr<private, i32, read_write> = access %obj, 0u, %x_305 |
| %269:i32 = load %j |
| %270:ptr<private, i32, read_write> = access %obj, 0u, %269 |
| %271:i32 = load %270 |
| store %268, %271 |
| %272:i32 = load %j |
| %x_310:i32 = let %272 |
| %274:ptr<private, i32, read_write> = access %obj, 0u, %x_310 |
| %275:i32 = load %temp |
| store %274, %275 |
| ret |
| } |
| } |
| %quicksort_ = func():void { |
| $B30: { |
| %l_1:ptr<function, i32, read_write> = var |
| %h_1:ptr<function, i32, read_write> = var |
| %top:ptr<function, i32, read_write> = var |
| %stack:ptr<function, array<i32, 10>, read_write> = var |
| %p:ptr<function, i32, read_write> = var |
| %param_4:ptr<function, i32, read_write> = var |
| %param_5:ptr<function, i32, read_write> = var |
| store %l_1, 0i |
| store %h_1, 9i |
| store %top, -1i |
| %284:i32 = load %top |
| %285:i32 = add %284, 1i |
| %x_377:i32 = let %285 |
| store %top, %x_377 |
| %287:ptr<function, i32, read_write> = access %stack, %x_377 |
| %288:i32 = load %l_1 |
| store %287, %288 |
| %289:i32 = load %top |
| %290:i32 = add %289, 1i |
| %x_381:i32 = let %290 |
| store %top, %x_381 |
| %292:ptr<function, i32, read_write> = access %stack, %x_381 |
| %293:i32 = load %h_1 |
| store %292, %293 |
| loop [b: $B31, c: $B32] { # loop_4 |
| $B31: { # body |
| %294:i32 = load %top |
| %295:bool = gte %294, 0i |
| if %295 [t: $B33, f: $B34] { # if_15 |
| $B33: { # true |
| exit_if # if_15 |
| } |
| $B34: { # false |
| exit_loop # loop_4 |
| } |
| } |
| %296:i32 = load %top |
| %x_391:i32 = let %296 |
| %298:i32 = load %top |
| %299:i32 = sub %298, 1i |
| store %top, %299 |
| %300:ptr<function, i32, read_write> = access %stack, %x_391 |
| %301:i32 = load %300 |
| store %h_1, %301 |
| %302:i32 = load %top |
| %x_395:i32 = let %302 |
| %304:i32 = load %top |
| %305:i32 = sub %304, 1i |
| store %top, %305 |
| %306:ptr<function, i32, read_write> = access %stack, %x_395 |
| %307:i32 = load %306 |
| store %l_1, %307 |
| %308:i32 = load %l_1 |
| store %param_4, %308 |
| %309:i32 = load %h_1 |
| store %param_5, %309 |
| %310:i32 = call %performPartition_i1_i1_, %param_4, %param_5 |
| %x_401:i32 = let %310 |
| store %p, %x_401 |
| %312:i32 = load %p |
| %313:i32 = sub %312, 1i |
| %314:i32 = load %l_1 |
| %315:bool = gt %313, %314 |
| if %315 [t: $B35] { # if_16 |
| $B35: { # true |
| %316:i32 = load %top |
| %317:i32 = add %316, 1i |
| %x_409:i32 = let %317 |
| store %top, %x_409 |
| %319:ptr<function, i32, read_write> = access %stack, %x_409 |
| %320:i32 = load %l_1 |
| store %319, %320 |
| %321:i32 = load %top |
| %322:i32 = add %321, 1i |
| %x_413:i32 = let %322 |
| store %top, %x_413 |
| %324:ptr<function, i32, read_write> = access %stack, %x_413 |
| %325:i32 = load %p |
| %326:i32 = sub %325, 1i |
| store %324, %326 |
| exit_if # if_16 |
| } |
| } |
| %327:i32 = load %p |
| %328:i32 = add %327, 1i |
| %329:i32 = load %h_1 |
| %330:bool = lt %328, %329 |
| if %330 [t: $B36] { # if_17 |
| $B36: { # true |
| %331:i32 = load %top |
| %332:i32 = add %331, 1i |
| %x_424:i32 = let %332 |
| store %top, %x_424 |
| %334:ptr<function, i32, read_write> = access %stack, %x_424 |
| %335:i32 = load %p |
| %336:i32 = add %335, 1i |
| store %334, %336 |
| %337:i32 = load %top |
| %338:i32 = add %337, 1i |
| %x_429:i32 = let %338 |
| store %top, %x_429 |
| %340:ptr<function, i32, read_write> = access %stack, %x_429 |
| %341:i32 = load %h_1 |
| store %340, %341 |
| exit_if # if_17 |
| } |
| } |
| continue # -> $B32 |
| } |
| $B32: { # continuing |
| next_iteration # -> $B31 |
| } |
| } |
| ret |
| } |
| } |
| |
| 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. * |
| ******************************************************************** |
