| ... | @@ -1421,7 +1421,7 @@ fn asmCmovccRegisterRegister(self: *CodeGen, cc: Condition, reg1: Register, reg2 | ... | @@ -1421,7 +1421,7 @@ fn asmCmovccRegisterRegister(self: *CodeGen, cc: Condition, reg1: Register, reg2 |
| 1421 | }, | 1421 | }, |
| 1422 | .data = .{ .rr = .{ | 1422 | .data = .{ .rr = .{ |
| 1423 | .fixes = switch (cc) { | 1423 | .fixes = switch (cc) { |
| 1424 | else => .fromCondition(cc), | 1424 | else => .fromCond(cc), |
| 1425 | .z_and_np, .nz_or_p => ._, | 1425 | .z_and_np, .nz_or_p => ._, |
| 1426 | }, | 1426 | }, |
| 1427 | .r1 = reg1, | 1427 | .r1 = reg1, |
| ... | @@ -1449,7 +1449,7 @@ fn asmCmovccRegisterMemory(self: *CodeGen, cc: Condition, reg: Register, m: Memo | ... | @@ -1449,7 +1449,7 @@ fn asmCmovccRegisterMemory(self: *CodeGen, cc: Condition, reg: Register, m: Memo |
| 1449 | }, | 1449 | }, |
| 1450 | .data = .{ .rx = .{ | 1450 | .data = .{ .rx = .{ |
| 1451 | .fixes = switch (cc) { | 1451 | .fixes = switch (cc) { |
| 1452 | else => .fromCondition(cc), | 1452 | else => .fromCond(cc), |
| 1453 | .z_and_np => unreachable, | 1453 | .z_and_np => unreachable, |
| 1454 | .nz_or_p => ._, | 1454 | .nz_or_p => ._, |
| 1455 | }, | 1455 | }, |
| ... | @@ -1476,7 +1476,7 @@ fn asmSetccRegister(self: *CodeGen, cc: Condition, reg: Register) !void { | ... | @@ -1476,7 +1476,7 @@ fn asmSetccRegister(self: *CodeGen, cc: Condition, reg: Register) !void { |
| 1476 | }, | 1476 | }, |
| 1477 | .data = switch (cc) { | 1477 | .data = switch (cc) { |
| 1478 | else => .{ .r = .{ | 1478 | else => .{ .r = .{ |
| 1479 | .fixes = .fromCondition(cc), | 1479 | .fixes = .fromCond(cc), |
| 1480 | .r1 = reg, | 1480 | .r1 = reg, |
| 1481 | } }, | 1481 | } }, |
| 1482 | .z_and_np, .nz_or_p => .{ .rr = .{ | 1482 | .z_and_np, .nz_or_p => .{ .rr = .{ |
| ... | @@ -1501,7 +1501,7 @@ fn asmSetccMemory(self: *CodeGen, cc: Condition, m: Memory) !void { | ... | @@ -1501,7 +1501,7 @@ fn asmSetccMemory(self: *CodeGen, cc: Condition, m: Memory) !void { |
| 1501 | }, | 1501 | }, |
| 1502 | .data = switch (cc) { | 1502 | .data = switch (cc) { |
| 1503 | else => .{ .x = .{ | 1503 | else => .{ .x = .{ |
| 1504 | .fixes = .fromCondition(cc), | 1504 | .fixes = .fromCond(cc), |
| 1505 | .payload = payload, | 1505 | .payload = payload, |
| 1506 | } }, | 1506 | } }, |
| 1507 | .z_and_np, .nz_or_p => .{ .rx = .{ | 1507 | .z_and_np, .nz_or_p => .{ .rx = .{ |
| ... | @@ -1536,7 +1536,7 @@ fn asmJccReloc(self: *CodeGen, cc: Condition, target: Mir.Inst.Index) !Mir.Inst. | ... | @@ -1536,7 +1536,7 @@ fn asmJccReloc(self: *CodeGen, cc: Condition, target: Mir.Inst.Index) !Mir.Inst. |
| 1536 | }, | 1536 | }, |
| 1537 | .data = .{ .inst = .{ | 1537 | .data = .{ .inst = .{ |
| 1538 | .fixes = switch (cc) { | 1538 | .fixes = switch (cc) { |
| 1539 | else => .fromCondition(cc), | 1539 | else => .fromCond(cc), |
| 1540 | .z_and_np, .nz_or_p => ._, | 1540 | .z_and_np, .nz_or_p => ._, |
| 1541 | }, | 1541 | }, |
| 1542 | .inst = target, | 1542 | .inst = target, |
| ... | @@ -2224,7 +2224,7 @@ fn gen(self: *CodeGen) InnerError!void { | ... | @@ -2224,7 +2224,7 @@ fn gen(self: *CodeGen) InnerError!void { |
| 2224 | else => |cc| return self.fail("{s} does not support var args", .{@tagName(cc)}), | 2224 | else => |cc| return self.fail("{s} does not support var args", .{@tagName(cc)}), |
| 2225 | }; | 2225 | }; |
| 2226 | | 2226 | |
| 2227 | try self.asmPseudo(.pseudo_dbg_prologue_end_none); | 2227 | if (self.debug_output != .none) try self.asmPseudo(.pseudo_dbg_prologue_end_none); |
| 2228 | | 2228 | |
| 2229 | try self.genBody(self.air.getMainBody()); | 2229 | try self.genBody(self.air.getMainBody()); |
| 2230 | | 2230 | |
| ... | @@ -2235,7 +2235,7 @@ fn gen(self: *CodeGen) InnerError!void { | ... | @@ -2235,7 +2235,7 @@ fn gen(self: *CodeGen) InnerError!void { |
| 2235 | break :epilogue_relocs self.epilogue_relocs.items[0..epilogue_relocs_last_index]; | 2235 | break :epilogue_relocs self.epilogue_relocs.items[0..epilogue_relocs_last_index]; |
| 2236 | } else self.epilogue_relocs.items) |epilogue_reloc| self.performReloc(epilogue_reloc); | 2236 | } else self.epilogue_relocs.items) |epilogue_reloc| self.performReloc(epilogue_reloc); |
| 2237 | | 2237 | |
| 2238 | try self.asmPseudo(.pseudo_dbg_epilogue_begin_none); | 2238 | if (self.debug_output != .none) try self.asmPseudo(.pseudo_dbg_epilogue_begin_none); |
| 2239 | const backpatch_stack_dealloc = try self.asmPlaceholder(); | 2239 | const backpatch_stack_dealloc = try self.asmPlaceholder(); |
| 2240 | const backpatch_pop_callee_preserved_regs = try self.asmPlaceholder(); | 2240 | const backpatch_pop_callee_preserved_regs = try self.asmPlaceholder(); |
| 2241 | try self.asmRegister(.{ ._, .pop }, .rbp); | 2241 | try self.asmRegister(.{ ._, .pop }, .rbp); |
| ... | @@ -2354,15 +2354,15 @@ fn gen(self: *CodeGen) InnerError!void { | ... | @@ -2354,15 +2354,15 @@ fn gen(self: *CodeGen) InnerError!void { |
| 2354 | }); | 2354 | }); |
| 2355 | } | 2355 | } |
| 2356 | } else { | 2356 | } else { |
| 2357 | try self.asmPseudo(.pseudo_dbg_prologue_end_none); | 2357 | if (self.debug_output != .none) try self.asmPseudo(.pseudo_dbg_prologue_end_none); |
| 2358 | try self.genBody(self.air.getMainBody()); | 2358 | try self.genBody(self.air.getMainBody()); |
| 2359 | try self.asmPseudo(.pseudo_dbg_epilogue_begin_none); | 2359 | if (self.debug_output != .none) try self.asmPseudo(.pseudo_dbg_epilogue_begin_none); |
| 2360 | } | 2360 | } |
| 2361 | | 2361 | |
| 2362 | // Drop them off at the rbrace. | 2362 | // Drop them off at the rbrace. |
| 2363 | _ = try self.addInst(.{ | 2363 | if (self.debug_output != .none) _ = try self.addInst(.{ |
| 2364 | .tag = .pseudo, | 2364 | .tag = .pseudo, |
| 2365 | .ops = .pseudo_dbg_line_stmt_line_column, | 2365 | .ops = .pseudo_dbg_line_line_column, |
| 2366 | .data = .{ .line_column = .{ | 2366 | .data = .{ .line_column = .{ |
| 2367 | .line = self.end_di_line, | 2367 | .line = self.end_di_line, |
| 2368 | .column = self.end_di_column, | 2368 | .column = self.end_di_column, |
| ... | @@ -2387,13 +2387,13 @@ fn checkInvariantsAfterAirInst(self: *CodeGen) void { | ... | @@ -2387,13 +2387,13 @@ fn checkInvariantsAfterAirInst(self: *CodeGen) void { |
| 2387 | } | 2387 | } |
| 2388 | | 2388 | |
| 2389 | fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | 2389 | fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2390 | try self.asmPseudo(.pseudo_dbg_enter_block_none); | 2390 | if (self.debug_output != .none) try self.asmPseudo(.pseudo_dbg_enter_block_none); |
| 2391 | try self.genBody(body); | 2391 | try self.genBody(body); |
| 2392 | try self.asmPseudo(.pseudo_dbg_leave_block_none); | 2392 | if (self.debug_output != .none) try self.asmPseudo(.pseudo_dbg_leave_block_none); |
| 2393 | } | 2393 | } |
| 2394 | | 2394 | |
| 2395 | fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | 2395 | fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2396 | @setEvalBranchQuota(3_400); | 2396 | @setEvalBranchQuota(3_600); |
| 2397 | const pt = cg.pt; | 2397 | const pt = cg.pt; |
| 2398 | const zcu = pt.zcu; | 2398 | const zcu = pt.zcu; |
| 2399 | const ip = &zcu.intern_pool; | 2399 | const ip = &zcu.intern_pool; |
| ... | @@ -2543,7 +2543,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2543,7 +2543,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2543 | .reduce_optimized => try cg.airReduce(inst), | 2543 | .reduce_optimized => try cg.airReduce(inst), |
| 2544 | .int_from_float_optimized => try cg.airIntFromFloat(inst), | 2544 | .int_from_float_optimized => try cg.airIntFromFloat(inst), |
| 2545 | | 2545 | |
| 2546 | .arg => try cg.airDbgArg(inst), | 2546 | .arg => if (cg.debug_output != .none) { |
| | 2547 | // skip zero-bit arguments as they don't have a corresponding arg instruction |
| | 2548 | var arg_index = cg.arg_index; |
| | 2549 | while (cg.args[arg_index] == .none) arg_index += 1; |
| | 2550 | cg.arg_index = arg_index + 1; |
| | 2551 | |
| | 2552 | const name = air_datas[@intFromEnum(inst)].arg.name; |
| | 2553 | if (name != .none) try cg.genLocalDebugInfo(inst, cg.getResolvedInstValue(inst).short); |
| | 2554 | if (cg.liveness.isUnused(inst)) try cg.processDeath(inst); |
| | 2555 | |
| | 2556 | for (cg.args[arg_index + 1 ..]) |arg| { |
| | 2557 | if (arg != .none) break; |
| | 2558 | } else try cg.airDbgVarArgs(); |
| | 2559 | }, |
| 2547 | .ptr_add => |air_tag| if (use_old) try cg.airPtrArithmetic(inst, air_tag) else { | 2560 | .ptr_add => |air_tag| if (use_old) try cg.airPtrArithmetic(inst, air_tag) else { |
| 2548 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; | 2561 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| 2549 | const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; | 2562 | const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; |
| ... | @@ -2794,7 +2807,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2794,7 +2807,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2794 | }, | 2807 | }, |
| 2795 | .max => |air_tag| if (use_old) try cg.airBinOp(inst, air_tag) else fallback: { | 2808 | .max => |air_tag| if (use_old) try cg.airBinOp(inst, air_tag) else fallback: { |
| 2796 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; | 2809 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; |
| 2797 | if (cg.typeOf(bin_op.lhs).scalarType(zcu).isRuntimeFloat()) break :fallback try cg.airBinOp(inst, air_tag); | 2810 | const ty = cg.typeOf(bin_op.lhs); |
| | 2811 | if (ty.isVector(zcu) and cg.floatBits(ty.childType(zcu)) != null) break :fallback try cg.airBinOp(inst, air_tag); |
| 2798 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); | 2812 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 2799 | var res: [1]Temp = undefined; | 2813 | var res: [1]Temp = undefined; |
| 2800 | cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ | 2814 | cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ |
| ... | @@ -5359,6 +5373,409 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5359,6 +5373,409 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5359 | .{ ._, ._, .@"test", .tmp0p, .tmp0p, ._, ._ }, | 5373 | .{ ._, ._, .@"test", .tmp0p, .tmp0p, ._, ._ }, |
| 5360 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 5374 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 5361 | } }, | 5375 | } }, |
| | 5376 | }, .{ |
| | 5377 | .required_features = .{ .f16c, null, null, null }, |
| | 5378 | .src_constraints = .{ |
| | 5379 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| | 5380 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| | 5381 | }, |
| | 5382 | .patterns = &.{ |
| | 5383 | .{ .src = .{ .to_sse, .to_sse } }, |
| | 5384 | }, |
| | 5385 | .extra_temps = .{ |
| | 5386 | .{ .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| | 5387 | .{ .kind = .{ .rc = .sse } }, |
| | 5388 | .unused, |
| | 5389 | .unused, |
| | 5390 | .unused, |
| | 5391 | .unused, |
| | 5392 | .unused, |
| | 5393 | .unused, |
| | 5394 | .unused, |
| | 5395 | }, |
| | 5396 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| | 5397 | .each = .{ .once = &.{ |
| | 5398 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0x, ._, ._ }, |
| | 5399 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1x, ._, ._ }, |
| | 5400 | .{ ._, .v_ss, .cmp, .tmp1x, .dst0x, .dst0x, .vp(.unord) }, |
| | 5401 | .{ ._, .v_ss, .max, .dst0x, .tmp0x, .dst0x, ._ }, |
| | 5402 | .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp0x, .tmp1x }, |
| | 5403 | .{ ._, .v_, .cvtps2ph, .dst0x, .dst0x, .rm(.{}), ._ }, |
| | 5404 | } }, |
| | 5405 | }, .{ |
| | 5406 | .required_features = .{ .sse, null, null, null }, |
| | 5407 | .src_constraints = .{ |
| | 5408 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| | 5409 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| | 5410 | }, |
| | 5411 | .patterns = &.{ |
| | 5412 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 } } }, |
| | 5413 | }, |
| | 5414 | .call_frame = .{ .alignment = .@"16" }, |
| | 5415 | .extra_temps = .{ |
| | 5416 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmaxh" } } }, |
| | 5417 | .unused, |
| | 5418 | .unused, |
| | 5419 | .unused, |
| | 5420 | .unused, |
| | 5421 | .unused, |
| | 5422 | .unused, |
| | 5423 | .unused, |
| | 5424 | .unused, |
| | 5425 | }, |
| | 5426 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| | 5427 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 5428 | .each = .{ .once = &.{ |
| | 5429 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| | 5430 | } }, |
| | 5431 | }, .{ |
| | 5432 | .required_features = .{ .avx, null, null, null }, |
| | 5433 | .src_constraints = .{ |
| | 5434 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| | 5435 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| | 5436 | }, |
| | 5437 | .patterns = &.{ |
| | 5438 | .{ .src = .{ .to_sse, .to_sse } }, |
| | 5439 | }, |
| | 5440 | .extra_temps = .{ |
| | 5441 | .{ .kind = .{ .rc = .sse } }, |
| | 5442 | .unused, |
| | 5443 | .unused, |
| | 5444 | .unused, |
| | 5445 | .unused, |
| | 5446 | .unused, |
| | 5447 | .unused, |
| | 5448 | .unused, |
| | 5449 | .unused, |
| | 5450 | }, |
| | 5451 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| | 5452 | .each = .{ .once = &.{ |
| | 5453 | .{ ._, .v_ss, .cmp, .tmp0x, .src0x, .src0x, .vp(.unord) }, |
| | 5454 | .{ ._, .v_ss, .max, .dst0x, .src1x, .src0x, ._ }, |
| | 5455 | .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .src1x, .tmp0x }, |
| | 5456 | } }, |
| | 5457 | }, .{ |
| | 5458 | .required_features = .{ .sse4_1, null, null, null }, |
| | 5459 | .src_constraints = .{ |
| | 5460 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| | 5461 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| | 5462 | }, |
| | 5463 | .patterns = &.{ |
| | 5464 | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse } }, |
| | 5465 | }, |
| | 5466 | .dst_temps = .{.{ .rc = .sse }}, |
| | 5467 | .each = .{ .once = &.{ |
| | 5468 | .{ ._, ._ps, .mova, .dst0x, .src1x, ._, ._ }, |
| | 5469 | .{ ._, ._ss, .max, .dst0x, .src0x, ._, ._ }, |
| | 5470 | .{ ._, ._ss, .cmp, .src0x, .src0x, .vp(.unord), ._ }, |
| | 5471 | .{ ._, ._ps, .blendv, .dst0x, .src1x, .src0x, ._ }, |
| | 5472 | } }, |
| | 5473 | }, .{ |
| | 5474 | .required_features = .{ .sse, null, null, null }, |
| | 5475 | .src_constraints = .{ |
| | 5476 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| | 5477 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| | 5478 | }, |
| | 5479 | .patterns = &.{ |
| | 5480 | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| | 5481 | }, |
| | 5482 | .extra_temps = .{ |
| | 5483 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| | 5484 | .unused, |
| | 5485 | .unused, |
| | 5486 | .unused, |
| | 5487 | .unused, |
| | 5488 | .unused, |
| | 5489 | .unused, |
| | 5490 | .unused, |
| | 5491 | .unused, |
| | 5492 | }, |
| | 5493 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 5494 | .each = .{ .once = &.{ |
| | 5495 | .{ ._, ._ps, .mova, .tmp0x, .src1x, ._, ._ }, |
| | 5496 | .{ ._, ._ss, .max, .tmp0x, .src0x, ._, ._ }, |
| | 5497 | .{ ._, ._ss, .cmp, .dst0x, .src0x, .vp(.ord), ._ }, |
| | 5498 | .{ ._, ._ps, .@"and", .tmp0x, .dst0x, ._, ._ }, |
| | 5499 | .{ ._, ._ps, .andn, .dst0x, .src1x, ._, ._ }, |
| | 5500 | .{ ._, ._ps, .@"or", .dst0x, .tmp0x, ._, ._ }, |
| | 5501 | } }, |
| | 5502 | }, .{ |
| | 5503 | .required_features = .{ .avx, null, null, null }, |
| | 5504 | .src_constraints = .{ |
| | 5505 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 5506 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 5507 | }, |
| | 5508 | .patterns = &.{ |
| | 5509 | .{ .src = .{ .to_sse, .to_sse } }, |
| | 5510 | }, |
| | 5511 | .extra_temps = .{ |
| | 5512 | .{ .kind = .{ .rc = .sse } }, |
| | 5513 | .unused, |
| | 5514 | .unused, |
| | 5515 | .unused, |
| | 5516 | .unused, |
| | 5517 | .unused, |
| | 5518 | .unused, |
| | 5519 | .unused, |
| | 5520 | .unused, |
| | 5521 | }, |
| | 5522 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| | 5523 | .each = .{ .once = &.{ |
| | 5524 | .{ ._, .v_sd, .cmp, .tmp0x, .src0x, .src0x, .vp(.unord) }, |
| | 5525 | .{ ._, .v_sd, .max, .dst0x, .src1x, .src0x, ._ }, |
| | 5526 | .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .src1x, .tmp0x }, |
| | 5527 | } }, |
| | 5528 | }, .{ |
| | 5529 | .required_features = .{ .sse4_1, null, null, null }, |
| | 5530 | .src_constraints = .{ |
| | 5531 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 5532 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 5533 | }, |
| | 5534 | .patterns = &.{ |
| | 5535 | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse } }, |
| | 5536 | }, |
| | 5537 | .dst_temps = .{.{ .rc = .sse }}, |
| | 5538 | .each = .{ .once = &.{ |
| | 5539 | .{ ._, ._pd, .mova, .dst0x, .src1x, ._, ._ }, |
| | 5540 | .{ ._, ._sd, .max, .dst0x, .src0x, ._, ._ }, |
| | 5541 | .{ ._, ._sd, .cmp, .src0x, .src0x, .vp(.unord), ._ }, |
| | 5542 | .{ ._, ._pd, .blendv, .dst0x, .src1x, .src0x, ._ }, |
| | 5543 | } }, |
| | 5544 | }, .{ |
| | 5545 | .required_features = .{ .sse2, null, null, null }, |
| | 5546 | .src_constraints = .{ |
| | 5547 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 5548 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 5549 | }, |
| | 5550 | .patterns = &.{ |
| | 5551 | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| | 5552 | }, |
| | 5553 | .extra_temps = .{ |
| | 5554 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| | 5555 | .unused, |
| | 5556 | .unused, |
| | 5557 | .unused, |
| | 5558 | .unused, |
| | 5559 | .unused, |
| | 5560 | .unused, |
| | 5561 | .unused, |
| | 5562 | .unused, |
| | 5563 | }, |
| | 5564 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 5565 | .each = .{ .once = &.{ |
| | 5566 | .{ ._, ._pd, .mova, .tmp0x, .src1x, ._, ._ }, |
| | 5567 | .{ ._, ._sd, .max, .tmp0x, .src0x, ._, ._ }, |
| | 5568 | .{ ._, ._sd, .cmp, .dst0x, .src0x, .vp(.ord), ._ }, |
| | 5569 | .{ ._, ._pd, .@"and", .tmp0x, .dst0x, ._, ._ }, |
| | 5570 | .{ ._, ._pd, .andn, .dst0x, .src1x, ._, ._ }, |
| | 5571 | .{ ._, ._pd, .@"or", .dst0x, .tmp0x, ._, ._ }, |
| | 5572 | } }, |
| | 5573 | }, .{ |
| | 5574 | .required_features = .{ .sse, null, null, null }, |
| | 5575 | .src_constraints = .{ |
| | 5576 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 5577 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 5578 | }, |
| | 5579 | .patterns = &.{ |
| | 5580 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 } } }, |
| | 5581 | }, |
| | 5582 | .call_frame = .{ .alignment = .@"16" }, |
| | 5583 | .extra_temps = .{ |
| | 5584 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmax" } } }, |
| | 5585 | .unused, |
| | 5586 | .unused, |
| | 5587 | .unused, |
| | 5588 | .unused, |
| | 5589 | .unused, |
| | 5590 | .unused, |
| | 5591 | .unused, |
| | 5592 | .unused, |
| | 5593 | }, |
| | 5594 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| | 5595 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 5596 | .each = .{ .once = &.{ |
| | 5597 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| | 5598 | } }, |
| | 5599 | }, .{ |
| | 5600 | .required_features = .{ .x87, .cmov, null, null }, |
| | 5601 | .src_constraints = .{ |
| | 5602 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 5603 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 5604 | }, |
| | 5605 | .patterns = &.{ |
| | 5606 | .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, |
| | 5607 | .{ .src = .{ .mem, .to_x87 } }, |
| | 5608 | .{ .src = .{ .to_x87, .to_x87 } }, |
| | 5609 | }, |
| | 5610 | .extra_temps = .{ |
| | 5611 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| | 5612 | .unused, |
| | 5613 | .unused, |
| | 5614 | .unused, |
| | 5615 | .unused, |
| | 5616 | .unused, |
| | 5617 | .unused, |
| | 5618 | .unused, |
| | 5619 | .unused, |
| | 5620 | }, |
| | 5621 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src1, .rc = .x87 } }}, |
| | 5622 | .clobbers = .{ .eflags = true }, |
| | 5623 | .each = .{ .once = &.{ |
| | 5624 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| | 5625 | .{ ._, .f_, .ucomi, .tmp0t, .tmp0t, ._, ._ }, |
| | 5626 | .{ ._, .f_u, .cmov, .tmp0t, .src1t, ._, ._ }, |
| | 5627 | .{ ._, .f_, .xch, .src1t, ._, ._, ._ }, |
| | 5628 | .{ ._, .f_, .ucomi, .tmp0t, .src1t, ._, ._ }, |
| | 5629 | .{ ._, .f_, .xch, .src1t, ._, ._, ._ }, |
| | 5630 | .{ ._, .f_nb, .cmov, .tmp0t, .src1t, ._, ._ }, |
| | 5631 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| | 5632 | } }, |
| | 5633 | }, .{ |
| | 5634 | .required_features = .{ .sahf, .x87, null, null }, |
| | 5635 | .src_constraints = .{ |
| | 5636 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 5637 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 5638 | }, |
| | 5639 | .patterns = &.{ |
| | 5640 | .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, |
| | 5641 | .{ .src = .{ .mem, .to_x87 } }, |
| | 5642 | .{ .src = .{ .to_x87, .to_x87 } }, |
| | 5643 | }, |
| | 5644 | .extra_temps = .{ |
| | 5645 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| | 5646 | .{ .type = .u8, .kind = .{ .reg = .ah } }, |
| | 5647 | .unused, |
| | 5648 | .unused, |
| | 5649 | .unused, |
| | 5650 | .unused, |
| | 5651 | .unused, |
| | 5652 | .unused, |
| | 5653 | .unused, |
| | 5654 | }, |
| | 5655 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src1, .rc = .x87 } }}, |
| | 5656 | .clobbers = .{ .eflags = true }, |
| | 5657 | .each = .{ .once = &.{ |
| | 5658 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| | 5659 | .{ ._, .f_, .ucom, .tmp0t, ._, ._, ._ }, |
| | 5660 | .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ }, |
| | 5661 | .{ ._, ._, .sahf, ._, ._, ._, ._ }, |
| | 5662 | .{ ._, ._p, .j, .@"0f", ._, ._, ._ }, |
| | 5663 | .{ ._, .f_, .xch, .src1t, ._, ._, ._ }, |
| | 5664 | .{ ._, .f_, .ucom, .src1t, ._, ._, ._ }, |
| | 5665 | .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ }, |
| | 5666 | .{ ._, .f_, .xch, .src1t, ._, ._, ._ }, |
| | 5667 | .{ ._, ._, .sahf, ._, ._, ._, ._ }, |
| | 5668 | .{ ._, ._b, .j, .@"1f", ._, ._, ._ }, |
| | 5669 | .{ .@"0:", .f_p, .st, .tmp0t, ._, ._, ._ }, |
| | 5670 | .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, |
| | 5671 | .{ .@"1:", .f_p, .st, .dst0t, ._, ._, ._ }, |
| | 5672 | } }, |
| | 5673 | }, .{ |
| | 5674 | .required_features = .{ .@"64bit", .x87, null, null }, |
| | 5675 | .src_constraints = .{ |
| | 5676 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 5677 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 5678 | }, |
| | 5679 | .patterns = &.{ |
| | 5680 | .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, |
| | 5681 | .{ .src = .{ .mem, .to_x87 } }, |
| | 5682 | .{ .src = .{ .to_x87, .to_x87 } }, |
| | 5683 | }, |
| | 5684 | .extra_temps = .{ |
| | 5685 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| | 5686 | .{ .type = .u8, .kind = .{ .reg = .ah } }, |
| | 5687 | .unused, |
| | 5688 | .unused, |
| | 5689 | .unused, |
| | 5690 | .unused, |
| | 5691 | .unused, |
| | 5692 | .unused, |
| | 5693 | .unused, |
| | 5694 | }, |
| | 5695 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src1, .rc = .x87 } }}, |
| | 5696 | .clobbers = .{ .eflags = true }, |
| | 5697 | .each = .{ .once = &.{ |
| | 5698 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| | 5699 | .{ ._, .f_, .xam, ._, ._, ._, ._ }, |
| | 5700 | .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ }, |
| | 5701 | .{ ._, ._, .@"test", .tmp1b, .si(0b0_1_000_100), ._, ._ }, |
| | 5702 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| | 5703 | .{ ._, .f_, .xch, .src1t, ._, ._, ._ }, |
| | 5704 | .{ ._, .f_, .ucom, .src1t, ._, ._, ._ }, |
| | 5705 | .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ }, |
| | 5706 | .{ ._, .f_, .xch, .src1t, ._, ._, ._ }, |
| | 5707 | .{ ._, ._, .@"test", .tmp1b, .si(0b0_0_000_001), ._, ._ }, |
| | 5708 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| | 5709 | .{ .@"0:", .f_p, .st, .tmp0t, ._, ._, ._ }, |
| | 5710 | .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, |
| | 5711 | .{ .@"1:", .f_p, .st, .dst0t, ._, ._, ._ }, |
| | 5712 | } }, |
| | 5713 | }, .{ |
| | 5714 | .required_features = .{ .x87, null, null, null }, |
| | 5715 | .src_constraints = .{ |
| | 5716 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 5717 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 5718 | }, |
| | 5719 | .patterns = &.{ |
| | 5720 | .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, |
| | 5721 | .{ .src = .{ .mem, .to_x87 } }, |
| | 5722 | .{ .src = .{ .to_x87, .to_x87 } }, |
| | 5723 | }, |
| | 5724 | .extra_temps = .{ |
| | 5725 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| | 5726 | .{ .type = .u8, .kind = .{ .reg = .ah } }, |
| | 5727 | .unused, |
| | 5728 | .unused, |
| | 5729 | .unused, |
| | 5730 | .unused, |
| | 5731 | .unused, |
| | 5732 | .unused, |
| | 5733 | .unused, |
| | 5734 | }, |
| | 5735 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src1, .rc = .x87 } }}, |
| | 5736 | .clobbers = .{ .eflags = true }, |
| | 5737 | .each = .{ .once = &.{ |
| | 5738 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| | 5739 | .{ ._, .f_, .ucom, .tmp0t, ._, ._, ._ }, |
| | 5740 | .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ }, |
| | 5741 | .{ ._, ._, .sahf, ._, ._, ._, ._ }, |
| | 5742 | .{ ._, ._p, .j, .@"0f", ._, ._, ._ }, |
| | 5743 | .{ ._, .f_, .xch, .src1t, ._, ._, ._ }, |
| | 5744 | .{ ._, .f_, .ucom, .src1t, ._, ._, ._ }, |
| | 5745 | .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ }, |
| | 5746 | .{ ._, .f_, .xch, .src1t, ._, ._, ._ }, |
| | 5747 | .{ ._, ._, .sahf, ._, ._, ._, ._ }, |
| | 5748 | .{ ._, ._b, .j, .@"1f", ._, ._, ._ }, |
| | 5749 | .{ .@"0:", .f_p, .st, .tmp0t, ._, ._, ._ }, |
| | 5750 | .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, |
| | 5751 | .{ .@"1:", .f_p, .st, .dst0t, ._, ._, ._ }, |
| | 5752 | } }, |
| | 5753 | }, .{ |
| | 5754 | .required_features = .{ .sse, null, null, null }, |
| | 5755 | .src_constraints = .{ |
| | 5756 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 5757 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 5758 | }, |
| | 5759 | .patterns = &.{ |
| | 5760 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 } } }, |
| | 5761 | }, |
| | 5762 | .call_frame = .{ .alignment = .@"16" }, |
| | 5763 | .extra_temps = .{ |
| | 5764 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmaxq" } } }, |
| | 5765 | .unused, |
| | 5766 | .unused, |
| | 5767 | .unused, |
| | 5768 | .unused, |
| | 5769 | .unused, |
| | 5770 | .unused, |
| | 5771 | .unused, |
| | 5772 | .unused, |
| | 5773 | }, |
| | 5774 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| | 5775 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 5776 | .each = .{ .once = &.{ |
| | 5777 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| | 5778 | } }, |
| 5362 | } }) catch |err| switch (err) { | 5779 | } }) catch |err| switch (err) { |
| 5363 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ | 5780 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 5364 | @tagName(air_tag), | 5781 | @tagName(air_tag), |
| ... | @@ -5372,7 +5789,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5372,7 +5789,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5372 | }, | 5789 | }, |
| 5373 | .min => |air_tag| if (use_old) try cg.airBinOp(inst, air_tag) else fallback: { | 5790 | .min => |air_tag| if (use_old) try cg.airBinOp(inst, air_tag) else fallback: { |
| 5374 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; | 5791 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; |
| 5375 | if (cg.typeOf(bin_op.lhs).scalarType(zcu).isRuntimeFloat()) break :fallback try cg.airBinOp(inst, air_tag); | 5792 | const ty = cg.typeOf(bin_op.lhs); |
| | 5793 | if (ty.isVector(zcu) and cg.floatBits(ty.childType(zcu)) != null) break :fallback try cg.airBinOp(inst, air_tag); |
| 5376 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); | 5794 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 5377 | var res: [1]Temp = undefined; | 5795 | var res: [1]Temp = undefined; |
| 5378 | cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ | 5796 | cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ |
| ... | @@ -7943,6 +8361,401 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7943,6 +8361,401 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7943 | .{ ._, ._, .@"test", .tmp0p, .tmp0p, ._, ._ }, | 8361 | .{ ._, ._, .@"test", .tmp0p, .tmp0p, ._, ._ }, |
| 7944 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 8362 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 7945 | } }, | 8363 | } }, |
| | 8364 | }, .{ |
| | 8365 | .required_features = .{ .f16c, null, null, null }, |
| | 8366 | .src_constraints = .{ |
| | 8367 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| | 8368 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| | 8369 | }, |
| | 8370 | .patterns = &.{ |
| | 8371 | .{ .src = .{ .to_sse, .to_sse } }, |
| | 8372 | }, |
| | 8373 | .extra_temps = .{ |
| | 8374 | .{ .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| | 8375 | .{ .kind = .{ .rc = .sse } }, |
| | 8376 | .unused, |
| | 8377 | .unused, |
| | 8378 | .unused, |
| | 8379 | .unused, |
| | 8380 | .unused, |
| | 8381 | .unused, |
| | 8382 | .unused, |
| | 8383 | }, |
| | 8384 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| | 8385 | .each = .{ .once = &.{ |
| | 8386 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0x, ._, ._ }, |
| | 8387 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1x, ._, ._ }, |
| | 8388 | .{ ._, .v_ss, .cmp, .tmp1x, .dst0x, .dst0x, .vp(.unord) }, |
| | 8389 | .{ ._, .v_ss, .min, .dst0x, .tmp0x, .dst0x, ._ }, |
| | 8390 | .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp0x, .tmp1x }, |
| | 8391 | .{ ._, .v_, .cvtps2ph, .dst0x, .dst0x, .rm(.{}), ._ }, |
| | 8392 | } }, |
| | 8393 | }, .{ |
| | 8394 | .required_features = .{ .sse, null, null, null }, |
| | 8395 | .src_constraints = .{ |
| | 8396 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| | 8397 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| | 8398 | }, |
| | 8399 | .patterns = &.{ |
| | 8400 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 } } }, |
| | 8401 | }, |
| | 8402 | .call_frame = .{ .alignment = .@"16" }, |
| | 8403 | .extra_temps = .{ |
| | 8404 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fminh" } } }, |
| | 8405 | .unused, |
| | 8406 | .unused, |
| | 8407 | .unused, |
| | 8408 | .unused, |
| | 8409 | .unused, |
| | 8410 | .unused, |
| | 8411 | .unused, |
| | 8412 | .unused, |
| | 8413 | }, |
| | 8414 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| | 8415 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 8416 | .each = .{ .once = &.{ |
| | 8417 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| | 8418 | } }, |
| | 8419 | }, .{ |
| | 8420 | .required_features = .{ .avx, null, null, null }, |
| | 8421 | .src_constraints = .{ |
| | 8422 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| | 8423 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| | 8424 | }, |
| | 8425 | .patterns = &.{ |
| | 8426 | .{ .src = .{ .to_sse, .to_sse } }, |
| | 8427 | }, |
| | 8428 | .extra_temps = .{ |
| | 8429 | .{ .kind = .{ .rc = .sse } }, |
| | 8430 | .unused, |
| | 8431 | .unused, |
| | 8432 | .unused, |
| | 8433 | .unused, |
| | 8434 | .unused, |
| | 8435 | .unused, |
| | 8436 | .unused, |
| | 8437 | .unused, |
| | 8438 | }, |
| | 8439 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| | 8440 | .each = .{ .once = &.{ |
| | 8441 | .{ ._, .v_ss, .cmp, .tmp0x, .src0x, .src0x, .vp(.unord) }, |
| | 8442 | .{ ._, .v_ss, .min, .dst0x, .src1x, .src0x, ._ }, |
| | 8443 | .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .src1x, .tmp0x }, |
| | 8444 | } }, |
| | 8445 | }, .{ |
| | 8446 | .required_features = .{ .sse4_1, null, null, null }, |
| | 8447 | .src_constraints = .{ |
| | 8448 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| | 8449 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| | 8450 | }, |
| | 8451 | .patterns = &.{ |
| | 8452 | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse } }, |
| | 8453 | }, |
| | 8454 | .dst_temps = .{.{ .rc = .sse }}, |
| | 8455 | .each = .{ .once = &.{ |
| | 8456 | .{ ._, ._ps, .mova, .dst0x, .src1x, ._, ._ }, |
| | 8457 | .{ ._, ._ss, .min, .dst0x, .src0x, ._, ._ }, |
| | 8458 | .{ ._, ._ss, .cmp, .src0x, .src0x, .vp(.unord), ._ }, |
| | 8459 | .{ ._, ._ps, .blendv, .dst0x, .src1x, .src0x, ._ }, |
| | 8460 | } }, |
| | 8461 | }, .{ |
| | 8462 | .required_features = .{ .sse, null, null, null }, |
| | 8463 | .src_constraints = .{ |
| | 8464 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| | 8465 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| | 8466 | }, |
| | 8467 | .patterns = &.{ |
| | 8468 | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| | 8469 | }, |
| | 8470 | .extra_temps = .{ |
| | 8471 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| | 8472 | .unused, |
| | 8473 | .unused, |
| | 8474 | .unused, |
| | 8475 | .unused, |
| | 8476 | .unused, |
| | 8477 | .unused, |
| | 8478 | .unused, |
| | 8479 | .unused, |
| | 8480 | }, |
| | 8481 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 8482 | .each = .{ .once = &.{ |
| | 8483 | .{ ._, ._ps, .mova, .tmp0x, .src1x, ._, ._ }, |
| | 8484 | .{ ._, ._ss, .min, .tmp0x, .src0x, ._, ._ }, |
| | 8485 | .{ ._, ._ss, .cmp, .dst0x, .src0x, .vp(.ord), ._ }, |
| | 8486 | .{ ._, ._ps, .@"and", .tmp0x, .dst0x, ._, ._ }, |
| | 8487 | .{ ._, ._ps, .andn, .dst0x, .src1x, ._, ._ }, |
| | 8488 | .{ ._, ._ps, .@"or", .dst0x, .tmp0x, ._, ._ }, |
| | 8489 | } }, |
| | 8490 | }, .{ |
| | 8491 | .required_features = .{ .avx, null, null, null }, |
| | 8492 | .src_constraints = .{ |
| | 8493 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 8494 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 8495 | }, |
| | 8496 | .patterns = &.{ |
| | 8497 | .{ .src = .{ .to_sse, .to_sse } }, |
| | 8498 | }, |
| | 8499 | .extra_temps = .{ |
| | 8500 | .{ .kind = .{ .rc = .sse } }, |
| | 8501 | .unused, |
| | 8502 | .unused, |
| | 8503 | .unused, |
| | 8504 | .unused, |
| | 8505 | .unused, |
| | 8506 | .unused, |
| | 8507 | .unused, |
| | 8508 | .unused, |
| | 8509 | }, |
| | 8510 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| | 8511 | .each = .{ .once = &.{ |
| | 8512 | .{ ._, .v_sd, .cmp, .tmp0x, .src0x, .src0x, .vp(.unord) }, |
| | 8513 | .{ ._, .v_sd, .min, .dst0x, .src1x, .src0x, ._ }, |
| | 8514 | .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .src1x, .tmp0x }, |
| | 8515 | } }, |
| | 8516 | }, .{ |
| | 8517 | .required_features = .{ .sse4_1, null, null, null }, |
| | 8518 | .src_constraints = .{ |
| | 8519 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 8520 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 8521 | }, |
| | 8522 | .patterns = &.{ |
| | 8523 | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse } }, |
| | 8524 | }, |
| | 8525 | .dst_temps = .{.{ .rc = .sse }}, |
| | 8526 | .each = .{ .once = &.{ |
| | 8527 | .{ ._, ._pd, .mova, .dst0x, .src1x, ._, ._ }, |
| | 8528 | .{ ._, ._sd, .min, .dst0x, .src0x, ._, ._ }, |
| | 8529 | .{ ._, ._sd, .cmp, .src0x, .src0x, .vp(.unord), ._ }, |
| | 8530 | .{ ._, ._pd, .blendv, .dst0x, .src1x, .src0x, ._ }, |
| | 8531 | } }, |
| | 8532 | }, .{ |
| | 8533 | .required_features = .{ .sse2, null, null, null }, |
| | 8534 | .src_constraints = .{ |
| | 8535 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 8536 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 8537 | }, |
| | 8538 | .patterns = &.{ |
| | 8539 | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| | 8540 | }, |
| | 8541 | .extra_temps = .{ |
| | 8542 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| | 8543 | .unused, |
| | 8544 | .unused, |
| | 8545 | .unused, |
| | 8546 | .unused, |
| | 8547 | .unused, |
| | 8548 | .unused, |
| | 8549 | .unused, |
| | 8550 | .unused, |
| | 8551 | }, |
| | 8552 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 8553 | .each = .{ .once = &.{ |
| | 8554 | .{ ._, ._pd, .mova, .tmp0x, .src1x, ._, ._ }, |
| | 8555 | .{ ._, ._sd, .min, .tmp0x, .src0x, ._, ._ }, |
| | 8556 | .{ ._, ._sd, .cmp, .dst0x, .src0x, .vp(.ord), ._ }, |
| | 8557 | .{ ._, ._pd, .@"and", .tmp0x, .dst0x, ._, ._ }, |
| | 8558 | .{ ._, ._pd, .andn, .dst0x, .src1x, ._, ._ }, |
| | 8559 | .{ ._, ._pd, .@"or", .dst0x, .tmp0x, ._, ._ }, |
| | 8560 | } }, |
| | 8561 | }, .{ |
| | 8562 | .required_features = .{ .sse, null, null, null }, |
| | 8563 | .src_constraints = .{ |
| | 8564 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 8565 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 8566 | }, |
| | 8567 | .patterns = &.{ |
| | 8568 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 } } }, |
| | 8569 | }, |
| | 8570 | .call_frame = .{ .alignment = .@"16" }, |
| | 8571 | .extra_temps = .{ |
| | 8572 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmin" } } }, |
| | 8573 | .unused, |
| | 8574 | .unused, |
| | 8575 | .unused, |
| | 8576 | .unused, |
| | 8577 | .unused, |
| | 8578 | .unused, |
| | 8579 | .unused, |
| | 8580 | .unused, |
| | 8581 | }, |
| | 8582 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| | 8583 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 8584 | .each = .{ .once = &.{ |
| | 8585 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| | 8586 | } }, |
| | 8587 | }, .{ |
| | 8588 | .required_features = .{ .x87, .cmov, null, null }, |
| | 8589 | .src_constraints = .{ |
| | 8590 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 8591 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 8592 | }, |
| | 8593 | .patterns = &.{ |
| | 8594 | .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, |
| | 8595 | .{ .src = .{ .mem, .to_x87 } }, |
| | 8596 | .{ .src = .{ .to_x87, .to_x87 } }, |
| | 8597 | }, |
| | 8598 | .extra_temps = .{ |
| | 8599 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| | 8600 | .unused, |
| | 8601 | .unused, |
| | 8602 | .unused, |
| | 8603 | .unused, |
| | 8604 | .unused, |
| | 8605 | .unused, |
| | 8606 | .unused, |
| | 8607 | .unused, |
| | 8608 | }, |
| | 8609 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src1, .rc = .x87 } }}, |
| | 8610 | .clobbers = .{ .eflags = true }, |
| | 8611 | .each = .{ .once = &.{ |
| | 8612 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| | 8613 | .{ ._, .f_, .ucomi, .tmp0t, .tmp0t, ._, ._ }, |
| | 8614 | .{ ._, .f_u, .cmov, .tmp0t, .src1t, ._, ._ }, |
| | 8615 | .{ ._, .f_, .ucomi, .tmp0t, .src1t, ._, ._ }, |
| | 8616 | .{ ._, .f_nb, .cmov, .tmp0t, .src1t, ._, ._ }, |
| | 8617 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| | 8618 | } }, |
| | 8619 | }, .{ |
| | 8620 | .required_features = .{ .sahf, .x87, null, null }, |
| | 8621 | .src_constraints = .{ |
| | 8622 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 8623 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 8624 | }, |
| | 8625 | .patterns = &.{ |
| | 8626 | .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, |
| | 8627 | .{ .src = .{ .mem, .to_x87 } }, |
| | 8628 | .{ .src = .{ .to_x87, .to_x87 } }, |
| | 8629 | }, |
| | 8630 | .extra_temps = .{ |
| | 8631 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| | 8632 | .{ .type = .u8, .kind = .{ .reg = .ah } }, |
| | 8633 | .unused, |
| | 8634 | .unused, |
| | 8635 | .unused, |
| | 8636 | .unused, |
| | 8637 | .unused, |
| | 8638 | .unused, |
| | 8639 | .unused, |
| | 8640 | }, |
| | 8641 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src1, .rc = .x87 } }}, |
| | 8642 | .clobbers = .{ .eflags = true }, |
| | 8643 | .each = .{ .once = &.{ |
| | 8644 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| | 8645 | .{ ._, .f_, .ucom, .tmp0t, ._, ._, ._ }, |
| | 8646 | .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ }, |
| | 8647 | .{ ._, ._, .sahf, ._, ._, ._, ._ }, |
| | 8648 | .{ ._, ._p, .j, .@"0f", ._, ._, ._ }, |
| | 8649 | .{ ._, .f_, .ucom, .src1t, ._, ._, ._ }, |
| | 8650 | .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ }, |
| | 8651 | .{ ._, ._, .sahf, ._, ._, ._, ._ }, |
| | 8652 | .{ ._, ._b, .j, .@"1f", ._, ._, ._ }, |
| | 8653 | .{ .@"0:", .f_p, .st, .tmp0t, ._, ._, ._ }, |
| | 8654 | .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, |
| | 8655 | .{ .@"1:", .f_p, .st, .dst0t, ._, ._, ._ }, |
| | 8656 | } }, |
| | 8657 | }, .{ |
| | 8658 | .required_features = .{ .@"64bit", .x87, null, null }, |
| | 8659 | .src_constraints = .{ |
| | 8660 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 8661 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 8662 | }, |
| | 8663 | .patterns = &.{ |
| | 8664 | .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, |
| | 8665 | .{ .src = .{ .mem, .to_x87 } }, |
| | 8666 | .{ .src = .{ .to_x87, .to_x87 } }, |
| | 8667 | }, |
| | 8668 | .extra_temps = .{ |
| | 8669 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| | 8670 | .{ .type = .u8, .kind = .{ .reg = .ah } }, |
| | 8671 | .unused, |
| | 8672 | .unused, |
| | 8673 | .unused, |
| | 8674 | .unused, |
| | 8675 | .unused, |
| | 8676 | .unused, |
| | 8677 | .unused, |
| | 8678 | }, |
| | 8679 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src1, .rc = .x87 } }}, |
| | 8680 | .clobbers = .{ .eflags = true }, |
| | 8681 | .each = .{ .once = &.{ |
| | 8682 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| | 8683 | .{ ._, .f_, .xam, ._, ._, ._, ._ }, |
| | 8684 | .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ }, |
| | 8685 | .{ ._, ._, .@"test", .tmp1b, .si(0b0_1_000_100), ._, ._ }, |
| | 8686 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| | 8687 | .{ ._, .f_, .ucom, .src1t, ._, ._, ._ }, |
| | 8688 | .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ }, |
| | 8689 | .{ ._, ._, .@"test", .tmp1b, .si(0b0_0_000_001), ._, ._ }, |
| | 8690 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| | 8691 | .{ .@"0:", .f_p, .st, .tmp0t, ._, ._, ._ }, |
| | 8692 | .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, |
| | 8693 | .{ .@"1:", .f_p, .st, .dst0t, ._, ._, ._ }, |
| | 8694 | } }, |
| | 8695 | }, .{ |
| | 8696 | .required_features = .{ .x87, null, null, null }, |
| | 8697 | .src_constraints = .{ |
| | 8698 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 8699 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 8700 | }, |
| | 8701 | .patterns = &.{ |
| | 8702 | .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, |
| | 8703 | .{ .src = .{ .mem, .to_x87 } }, |
| | 8704 | .{ .src = .{ .to_x87, .to_x87 } }, |
| | 8705 | }, |
| | 8706 | .extra_temps = .{ |
| | 8707 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| | 8708 | .{ .type = .u8, .kind = .{ .reg = .ah } }, |
| | 8709 | .unused, |
| | 8710 | .unused, |
| | 8711 | .unused, |
| | 8712 | .unused, |
| | 8713 | .unused, |
| | 8714 | .unused, |
| | 8715 | .unused, |
| | 8716 | }, |
| | 8717 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src1, .rc = .x87 } }}, |
| | 8718 | .clobbers = .{ .eflags = true }, |
| | 8719 | .each = .{ .once = &.{ |
| | 8720 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| | 8721 | .{ ._, .f_, .ucom, .tmp0t, ._, ._, ._ }, |
| | 8722 | .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ }, |
| | 8723 | .{ ._, ._, .sahf, ._, ._, ._, ._ }, |
| | 8724 | .{ ._, ._p, .j, .@"0f", ._, ._, ._ }, |
| | 8725 | .{ ._, .f_, .ucom, .src1t, ._, ._, ._ }, |
| | 8726 | .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ }, |
| | 8727 | .{ ._, ._, .sahf, ._, ._, ._, ._ }, |
| | 8728 | .{ ._, ._b, .j, .@"1f", ._, ._, ._ }, |
| | 8729 | .{ .@"0:", .f_p, .st, .tmp0t, ._, ._, ._ }, |
| | 8730 | .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, |
| | 8731 | .{ .@"1:", .f_p, .st, .dst0t, ._, ._, ._ }, |
| | 8732 | } }, |
| | 8733 | }, .{ |
| | 8734 | .required_features = .{ .sse, null, null, null }, |
| | 8735 | .src_constraints = .{ |
| | 8736 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 8737 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 8738 | }, |
| | 8739 | .patterns = &.{ |
| | 8740 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 } } }, |
| | 8741 | }, |
| | 8742 | .call_frame = .{ .alignment = .@"16" }, |
| | 8743 | .extra_temps = .{ |
| | 8744 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fminq" } } }, |
| | 8745 | .unused, |
| | 8746 | .unused, |
| | 8747 | .unused, |
| | 8748 | .unused, |
| | 8749 | .unused, |
| | 8750 | .unused, |
| | 8751 | .unused, |
| | 8752 | .unused, |
| | 8753 | }, |
| | 8754 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| | 8755 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 8756 | .each = .{ .once = &.{ |
| | 8757 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| | 8758 | } }, |
| 7946 | } }) catch |err| switch (err) { | 8759 | } }) catch |err| switch (err) { |
| 7947 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ | 8760 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 7948 | @tagName(air_tag), | 8761 | @tagName(air_tag), |
| ... | @@ -8591,7 +9404,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8591,7 +9404,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8591 | }, | 9404 | }, |
| 8592 | .dst_temps = .{.{ .rc = .sse }}, | 9405 | .dst_temps = .{.{ .rc = .sse }}, |
| 8593 | .each = .{ .once = &.{ | 9406 | .each = .{ .once = &.{ |
| 8594 | .{ ._, .v_pd, .cmp, .dst0y, .dst0y, .dst0y, .ui(0b01111) }, | 9407 | .{ ._, .v_pd, .cmp, .dst0y, .dst0y, .dst0y, .vp(.true) }, |
| 8595 | .{ ._, .v_pd, .xor, .dst0y, .dst0y, .src0y, ._ }, | 9408 | .{ ._, .v_pd, .xor, .dst0y, .dst0y, .src0y, ._ }, |
| 8596 | } }, | 9409 | } }, |
| 8597 | }, .{ | 9410 | }, .{ |
| ... | @@ -8693,7 +9506,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8693,7 +9506,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8693 | .clobbers = .{ .eflags = true }, | 9506 | .clobbers = .{ .eflags = true }, |
| 8694 | .each = .{ .once = &.{ | 9507 | .each = .{ .once = &.{ |
| 8695 | .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_size), ._, ._ }, | 9508 | .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_size), ._, ._ }, |
| 8696 | .{ ._, .v_pd, .cmp, .tmp1y, .tmp1y, .tmp1y, .ui(0b01111) }, | 9509 | .{ ._, .v_pd, .cmp, .tmp1y, .tmp1y, .tmp1y, .vp(.true) }, |
| 8697 | .{ .@"0:", .v_pd, .xor, .tmp2y, .tmp1y, .memiad(.src0y, .tmp0, .add_size, -16), ._ }, | 9510 | .{ .@"0:", .v_pd, .xor, .tmp2y, .tmp1y, .memiad(.src0y, .tmp0, .add_size, -16), ._ }, |
| 8698 | .{ ._, .v_pd, .movu, .memiad(.dst0y, .tmp0, .add_size, -16), .tmp2y, ._, ._ }, | 9511 | .{ ._, .v_pd, .movu, .memiad(.dst0y, .tmp0, .add_size, -16), .tmp2y, ._, ._ }, |
| 8699 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, | 9512 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| ... | @@ -8722,7 +9535,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8722,7 +9535,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8722 | .clobbers = .{ .eflags = true }, | 9535 | .clobbers = .{ .eflags = true }, |
| 8723 | .each = .{ .once = &.{ | 9536 | .each = .{ .once = &.{ |
| 8724 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 9537 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 8725 | .{ ._, .v_pd, .cmp, .tmp1y, .tmp1y, .tmp1y, .ui(0b01111) }, | 9538 | .{ ._, .v_pd, .cmp, .tmp1y, .tmp1y, .tmp1y, .vp(.true) }, |
| 8726 | .{ .@"0:", .v_pd, .xor, .tmp2y, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._ }, | 9539 | .{ .@"0:", .v_pd, .xor, .tmp2y, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._ }, |
| 8727 | .{ ._, .v_pd, .movu, .memia(.dst0y, .tmp0, .add_size), .tmp2y, ._, ._ }, | 9540 | .{ ._, .v_pd, .movu, .memia(.dst0y, .tmp0, .add_size), .tmp2y, ._, ._ }, |
| 8728 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, | 9541 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| ... | @@ -9406,7 +10219,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9406,7 +10219,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9406 | }, | 10219 | }, |
| 9407 | .dst_temps = .{.{ .rc = .sse }}, | 10220 | .dst_temps = .{.{ .rc = .sse }}, |
| 9408 | .each = .{ .once = &.{ | 10221 | .each = .{ .once = &.{ |
| 9409 | .{ ._, .v_pd, .cmp, .dst0y, .dst0y, .dst0y, .ui(0b01111) }, | 10222 | .{ ._, .v_pd, .cmp, .dst0y, .dst0y, .dst0y, .vp(.true) }, |
| 9410 | .{ ._, .v_pd, .xor, .dst0y, .dst0y, .src0y, ._ }, | 10223 | .{ ._, .v_pd, .xor, .dst0y, .dst0y, .src0y, ._ }, |
| 9411 | } }, | 10224 | } }, |
| 9412 | }, .{ | 10225 | }, .{ |
| ... | @@ -9493,12 +10306,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9493,12 +10306,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9493 | try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); | 10306 | try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 9494 | }, | 10307 | }, |
| 9495 | | 10308 | |
| 9496 | .block => if (use_old) try cg.airBlock(inst) else { | 10309 | .block => { |
| 9497 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; | 10310 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| 9498 | const extra = cg.air.extraData(Air.Block, ty_pl.payload); | 10311 | const extra = cg.air.extraData(Air.Block, ty_pl.payload); |
| 9499 | try cg.asmPseudo(.pseudo_dbg_enter_block_none); | 10312 | if (cg.debug_output != .none) try cg.asmPseudo(.pseudo_dbg_enter_block_none); |
| 9500 | try cg.lowerBlock(inst, @ptrCast(cg.air.extra[extra.end..][0..extra.data.body_len])); | 10313 | try cg.lowerBlock(inst, @ptrCast(cg.air.extra[extra.end..][0..extra.data.body_len])); |
| 9501 | try cg.asmPseudo(.pseudo_dbg_leave_block_none); | 10314 | if (cg.debug_output != .none) try cg.asmPseudo(.pseudo_dbg_leave_block_none); |
| 9502 | }, | 10315 | }, |
| 9503 | .loop => if (use_old) try cg.airLoop(inst) else { | 10316 | .loop => if (use_old) try cg.airLoop(inst) else { |
| 9504 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; | 10317 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| ... | @@ -13852,7 +14665,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13852,7 +14665,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13852 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | 14665 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, |
| 13853 | .{ .@"0:", ._, .mov, .tmp2b, .memia(.src0b, .tmp0, .add_size), ._, ._ }, | 14666 | .{ .@"0:", ._, .mov, .tmp2b, .memia(.src0b, .tmp0, .add_size), ._, ._ }, |
| 13854 | .{ ._, ._, .cmp, .tmp2b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, | 14667 | .{ ._, ._, .cmp, .tmp2b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, |
| 13855 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 14668 | .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ }, |
| 13856 | .{ ._, ._l, .sh, .tmp2b, .tmp1b, ._, ._ }, | 14669 | .{ ._, ._l, .sh, .tmp2b, .tmp1b, ._, ._ }, |
| 13857 | .{ ._, ._, .@"or", .dst0b, .tmp2b, ._, ._ }, | 14670 | .{ ._, ._, .@"or", .dst0b, .tmp2b, ._, ._ }, |
| 13858 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, | 14671 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, |
| ... | @@ -13884,7 +14697,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13884,7 +14697,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13884 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | 14697 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, |
| 13885 | .{ .@"0:", ._, .mov, .tmp2w, .memia(.src0w, .tmp0, .add_size), ._, ._ }, | 14698 | .{ .@"0:", ._, .mov, .tmp2w, .memia(.src0w, .tmp0, .add_size), ._, ._ }, |
| 13886 | .{ ._, ._, .cmp, .tmp2w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, | 14699 | .{ ._, ._, .cmp, .tmp2w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, |
| 13887 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 14700 | .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ }, |
| 13888 | .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, | 14701 | .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, |
| 13889 | .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, | 14702 | .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, |
| 13890 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, | 14703 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, |
| ... | @@ -13916,7 +14729,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13916,7 +14729,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13916 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | 14729 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, |
| 13917 | .{ .@"0:", ._, .mov, .tmp2d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, | 14730 | .{ .@"0:", ._, .mov, .tmp2d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, |
| 13918 | .{ ._, ._, .cmp, .tmp2d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, | 14731 | .{ ._, ._, .cmp, .tmp2d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, |
| 13919 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 14732 | .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ }, |
| 13920 | .{ ._, ._l, .sh, .tmp2b, .tmp1b, ._, ._ }, | 14733 | .{ ._, ._l, .sh, .tmp2b, .tmp1b, ._, ._ }, |
| 13921 | .{ ._, ._, .@"or", .dst0b, .tmp2b, ._, ._ }, | 14734 | .{ ._, ._, .@"or", .dst0b, .tmp2b, ._, ._ }, |
| 13922 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, | 14735 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, |
| ... | @@ -13949,7 +14762,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13949,7 +14762,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13949 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | 14762 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, |
| 13950 | .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, | 14763 | .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 13951 | .{ ._, ._, .cmp, .tmp2q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, | 14764 | .{ ._, ._, .cmp, .tmp2q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 13952 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 14765 | .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ }, |
| 13953 | .{ ._, ._l, .sh, .tmp2b, .tmp1b, ._, ._ }, | 14766 | .{ ._, ._l, .sh, .tmp2b, .tmp1b, ._, ._ }, |
| 13954 | .{ ._, ._, .@"or", .dst0b, .tmp2b, ._, ._ }, | 14767 | .{ ._, ._, .@"or", .dst0b, .tmp2b, ._, ._ }, |
| 13955 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, | 14768 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, |
| ... | @@ -13988,7 +14801,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13988,7 +14801,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13988 | .{ ._, ._, .sub, .tmp2d, .si(1), ._, ._ }, | 14801 | .{ ._, ._, .sub, .tmp2d, .si(1), ._, ._ }, |
| 13989 | .{ ._, ._b, .j, .@"1b", ._, ._, ._ }, | 14802 | .{ ._, ._b, .j, .@"1b", ._, ._, ._ }, |
| 13990 | .{ ._, ._, .@"test", .tmp3p, .tmp3p, ._, ._ }, | 14803 | .{ ._, ._, .@"test", .tmp3p, .tmp3p, ._, ._ }, |
| 13991 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 14804 | .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ }, |
| 13992 | .{ ._, ._l, .sh, .tmp2b, .tmp1b, ._, ._ }, | 14805 | .{ ._, ._l, .sh, .tmp2b, .tmp1b, ._, ._ }, |
| 13993 | .{ ._, ._, .@"or", .dst0b, .tmp2b, ._, ._ }, | 14806 | .{ ._, ._, .@"or", .dst0b, .tmp2b, ._, ._ }, |
| 13994 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, | 14807 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, |
| ... | @@ -14021,7 +14834,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14021,7 +14834,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14021 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | 14834 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 14022 | .{ ._, ._, .mov, .tmp3b, .memia(.src0b, .tmp0, .add_size), ._, ._ }, | 14835 | .{ ._, ._, .mov, .tmp3b, .memia(.src0b, .tmp0, .add_size), ._, ._ }, |
| 14023 | .{ ._, ._, .cmp, .tmp3b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, | 14836 | .{ ._, ._, .cmp, .tmp3b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, |
| 14024 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 14837 | .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ }, |
| 14025 | .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, | 14838 | .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, |
| 14026 | .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, | 14839 | .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, |
| 14027 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, | 14840 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, |
| ... | @@ -14054,7 +14867,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14054,7 +14867,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14054 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | 14867 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 14055 | .{ ._, ._, .mov, .tmp3w, .memia(.src0w, .tmp0, .add_size), ._, ._ }, | 14868 | .{ ._, ._, .mov, .tmp3w, .memia(.src0w, .tmp0, .add_size), ._, ._ }, |
| 14056 | .{ ._, ._, .cmp, .tmp3w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, | 14869 | .{ ._, ._, .cmp, .tmp3w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, |
| 14057 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 14870 | .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ }, |
| 14058 | .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, | 14871 | .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, |
| 14059 | .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, | 14872 | .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, |
| 14060 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, | 14873 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, |
| ... | @@ -14087,7 +14900,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14087,7 +14900,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14087 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | 14900 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 14088 | .{ ._, ._, .mov, .tmp3d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, | 14901 | .{ ._, ._, .mov, .tmp3d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, |
| 14089 | .{ ._, ._, .cmp, .tmp3d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, | 14902 | .{ ._, ._, .cmp, .tmp3d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, |
| 14090 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 14903 | .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ }, |
| 14091 | .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, | 14904 | .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, |
| 14092 | .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, | 14905 | .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, |
| 14093 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, | 14906 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, |
| ... | @@ -14121,7 +14934,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14121,7 +14934,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14121 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | 14934 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 14122 | .{ ._, ._, .mov, .tmp3q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, | 14935 | .{ ._, ._, .mov, .tmp3q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 14123 | .{ ._, ._, .cmp, .tmp3q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, | 14936 | .{ ._, ._, .cmp, .tmp3q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 14124 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 14937 | .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ }, |
| 14125 | .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, | 14938 | .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, |
| 14126 | .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, | 14939 | .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, |
| 14127 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, | 14940 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, |
| ... | @@ -14161,7 +14974,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14161,7 +14974,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14161 | .{ ._, ._b, .j, .@"1b", ._, ._, ._ }, | 14974 | .{ ._, ._b, .j, .@"1b", ._, ._, ._ }, |
| 14162 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | 14975 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 14163 | .{ ._, ._, .@"test", .tmp3p, .tmp3p, ._, ._ }, | 14976 | .{ ._, ._, .@"test", .tmp3p, .tmp3p, ._, ._ }, |
| 14164 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 14977 | .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ }, |
| 14165 | .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, | 14978 | .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, |
| 14166 | .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, | 14979 | .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, |
| 14167 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, | 14980 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, |
| ... | @@ -14195,7 +15008,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14195,7 +15008,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14195 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | 15008 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 14196 | .{ ._, ._, .mov, .tmp3b, .memia(.src0b, .tmp0, .add_size), ._, ._ }, | 15009 | .{ ._, ._, .mov, .tmp3b, .memia(.src0b, .tmp0, .add_size), ._, ._ }, |
| 14197 | .{ ._, ._, .cmp, .tmp3b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, | 15010 | .{ ._, ._, .cmp, .tmp3b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, |
| 14198 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 15011 | .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ }, |
| 14199 | .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ }, | 15012 | .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ }, |
| 14200 | .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ }, | 15013 | .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ }, |
| 14201 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, | 15014 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, |
| ... | @@ -14228,7 +15041,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14228,7 +15041,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14228 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | 15041 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 14229 | .{ ._, ._, .mov, .tmp3w, .memia(.src0w, .tmp0, .add_size), ._, ._ }, | 15042 | .{ ._, ._, .mov, .tmp3w, .memia(.src0w, .tmp0, .add_size), ._, ._ }, |
| 14230 | .{ ._, ._, .cmp, .tmp3w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, | 15043 | .{ ._, ._, .cmp, .tmp3w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, |
| 14231 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 15044 | .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ }, |
| 14232 | .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ }, | 15045 | .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ }, |
| 14233 | .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ }, | 15046 | .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ }, |
| 14234 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, | 15047 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, |
| ... | @@ -14262,7 +15075,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14262,7 +15075,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14262 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | 15075 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 14263 | .{ ._, ._, .mov, .tmp3d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, | 15076 | .{ ._, ._, .mov, .tmp3d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, |
| 14264 | .{ ._, ._, .cmp, .tmp3d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, | 15077 | .{ ._, ._, .cmp, .tmp3d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, |
| 14265 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 15078 | .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ }, |
| 14266 | .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ }, | 15079 | .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ }, |
| 14267 | .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ }, | 15080 | .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ }, |
| 14268 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, | 15081 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, |
| ... | @@ -14296,7 +15109,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14296,7 +15109,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14296 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | 15109 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 14297 | .{ ._, ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, | 15110 | .{ ._, ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 14298 | .{ ._, ._, .cmp, .tmp2q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, | 15111 | .{ ._, ._, .cmp, .tmp2q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 14299 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 15112 | .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ }, |
| 14300 | .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ }, | 15113 | .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ }, |
| 14301 | .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ }, | 15114 | .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ }, |
| 14302 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, | 15115 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, |
| ... | @@ -14337,7 +15150,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14337,7 +15150,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14337 | .{ ._, ._b, .j, .@"1b", ._, ._, ._ }, | 15150 | .{ ._, ._b, .j, .@"1b", ._, ._, ._ }, |
| 14338 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | 15151 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 14339 | .{ ._, ._, .@"test", .tmp3p, .tmp3p, ._, ._ }, | 15152 | .{ ._, ._, .@"test", .tmp3p, .tmp3p, ._, ._ }, |
| 14340 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 15153 | .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ }, |
| 14341 | .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ }, | 15154 | .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ }, |
| 14342 | .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ }, | 15155 | .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ }, |
| 14343 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, | 15156 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, |
| ... | @@ -14369,7 +15182,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14369,7 +15182,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14369 | .{ .@"0:", ._, .xor, .tmp3d, .tmp3d, ._, ._ }, | 15182 | .{ .@"0:", ._, .xor, .tmp3d, .tmp3d, ._, ._ }, |
| 14370 | .{ ._, ._, .mov, .tmp4b, .memia(.src0b, .tmp0, .add_size), ._, ._ }, | 15183 | .{ ._, ._, .mov, .tmp4b, .memia(.src0b, .tmp0, .add_size), ._, ._ }, |
| 14371 | .{ ._, ._, .cmp, .tmp4b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, | 15184 | .{ ._, ._, .cmp, .tmp4b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, |
| 14372 | .{ ._, .fromCondition(cc), .set, .tmp3b, ._, ._, ._ }, | 15185 | .{ ._, .fromCond(cc), .set, .tmp3b, ._, ._, ._ }, |
| 14373 | .{ ._, ._l, .sh, .tmp3p, .tmp1b, ._, ._ }, | 15186 | .{ ._, ._l, .sh, .tmp3p, .tmp1b, ._, ._ }, |
| 14374 | .{ ._, ._, .@"or", .tmp2p, .tmp3p, ._, ._ }, | 15187 | .{ ._, ._, .@"or", .tmp2p, .tmp3p, ._, ._ }, |
| 14375 | .{ ._, ._, .add, .tmp1d, .si(1), ._, ._ }, | 15188 | .{ ._, ._, .add, .tmp1d, .si(1), ._, ._ }, |
| ... | @@ -14397,7 +15210,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14397,7 +15210,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14397 | .{ .src = .{ .to_sse, .to_sse } }, | 15210 | .{ .src = .{ .to_sse, .to_sse } }, |
| 14398 | }, | 15211 | }, |
| 14399 | .extra_temps = .{ | 15212 | .extra_temps = .{ |
| 14400 | .{ .kind = .{ .rc = .sse } }, | 15213 | .{ .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 14401 | .unused, | 15214 | .unused, |
| 14402 | .unused, | 15215 | .unused, |
| 14403 | .unused, | 15216 | .unused, |
| ... | @@ -14415,10 +15228,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14415,10 +15228,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14415 | .each = .{ .once = &.{ | 15228 | .each = .{ .once = &.{ |
| 14416 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0x, ._, ._ }, | 15229 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0x, ._, ._ }, |
| 14417 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1x, ._, ._ }, | 15230 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1x, ._, ._ }, |
| 14418 | .{ ._, .v_ss, .cmp, .dst0x, .dst0x, .tmp0x, .ui(switch (cc) { | 15231 | .{ ._, .v_ss, .cmp, .dst0x, .dst0x, .tmp0x, .vp(switch (cc) { |
| 14419 | else => unreachable, | 15232 | else => unreachable, |
| 14420 | .e => 0b00000, | 15233 | .e => .eq, |
| 14421 | .ne => 0b00100, | 15234 | .ne => .neq, |
| 14422 | }) }, | 15235 | }) }, |
| 14423 | } }, | 15236 | } }, |
| 14424 | }, .{ | 15237 | }, .{ |
| ... | @@ -14452,10 +15265,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14452,10 +15265,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14452 | .each = .{ .once = &.{ | 15265 | .each = .{ .once = &.{ |
| 14453 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, | 15266 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 14454 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, | 15267 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 14455 | .{ ._, .v_ps, .cmp, .dst0x, .dst0x, .tmp0x, .ui(switch (cc) { | 15268 | .{ ._, .v_ps, .cmp, .dst0x, .dst0x, .tmp0x, .vp(switch (cc) { |
| 14456 | else => unreachable, | 15269 | else => unreachable, |
| 14457 | .e => 0b00000, | 15270 | .e => .eq, |
| 14458 | .ne => 0b00100, | 15271 | .ne => .neq, |
| 14459 | }) }, | 15272 | }) }, |
| 14460 | } }, | 15273 | } }, |
| 14461 | }, .{ | 15274 | }, .{ |
| ... | @@ -14489,10 +15302,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14489,10 +15302,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14489 | .each = .{ .once = &.{ | 15302 | .each = .{ .once = &.{ |
| 14490 | .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ }, | 15303 | .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ }, |
| 14491 | .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ }, | 15304 | .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ }, |
| 14492 | .{ ._, .v_ps, .cmp, .dst0y, .dst0y, .tmp0y, .ui(switch (cc) { | 15305 | .{ ._, .v_ps, .cmp, .dst0y, .dst0y, .tmp0y, .vp(switch (cc) { |
| 14493 | else => unreachable, | 15306 | else => unreachable, |
| 14494 | .e => 0b00000, | 15307 | .e => .eq, |
| 14495 | .ne => 0b00100, | 15308 | .ne => .neq, |
| 14496 | }) }, | 15309 | }) }, |
| 14497 | } }, | 15310 | } }, |
| 14498 | }, .{ | 15311 | }, .{ |
| ... | @@ -14512,10 +15325,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14512,10 +15325,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14512 | .info = .{ .kind = .all, .scalar = .dword }, | 15325 | .info = .{ .kind = .all, .scalar = .dword }, |
| 14513 | } }}, | 15326 | } }}, |
| 14514 | .each = .{ .once = &.{ | 15327 | .each = .{ .once = &.{ |
| 14515 | .{ ._, .v_ss, .cmp, .dst0x, .src0x, .src1x, .ui(switch (cc) { | 15328 | .{ ._, .v_ss, .cmp, .dst0x, .src0x, .src1x, .vp(switch (cc) { |
| 14516 | else => unreachable, | 15329 | else => unreachable, |
| 14517 | .e => 0b00000, | 15330 | .e => .eq, |
| 14518 | .ne => 0b00100, | 15331 | .ne => .neq, |
| 14519 | }) }, | 15332 | }) }, |
| 14520 | } }, | 15333 | } }, |
| 14521 | }, .{ | 15334 | }, .{ |
| ... | @@ -14534,10 +15347,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14534,10 +15347,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14534 | .info = .{ .kind = .all, .scalar = .dword }, | 15347 | .info = .{ .kind = .all, .scalar = .dword }, |
| 14535 | } }}, | 15348 | } }}, |
| 14536 | .each = .{ .once = &.{ | 15349 | .each = .{ .once = &.{ |
| 14537 | .{ ._, ._ss, .cmp, .dst0x, .src1x, .ui(switch (cc) { | 15350 | .{ ._, ._ss, .cmp, .dst0x, .src1x, .vp(switch (cc) { |
| 14538 | else => unreachable, | 15351 | else => unreachable, |
| 14539 | .e => 0b00000, | 15352 | .e => .eq, |
| 14540 | .ne => 0b00100, | 15353 | .ne => .neq, |
| 14541 | }), ._ }, | 15354 | }), ._ }, |
| 14542 | } }, | 15355 | } }, |
| 14543 | }, .{ | 15356 | }, .{ |
| ... | @@ -14557,10 +15370,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14557,10 +15370,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14557 | .info = .{ .kind = .all, .scalar = .dword }, | 15370 | .info = .{ .kind = .all, .scalar = .dword }, |
| 14558 | } }}, | 15371 | } }}, |
| 14559 | .each = .{ .once = &.{ | 15372 | .each = .{ .once = &.{ |
| 14560 | .{ ._, .v_ps, .cmp, .dst0x, .src0x, .src1x, .ui(switch (cc) { | 15373 | .{ ._, .v_ps, .cmp, .dst0x, .src0x, .src1x, .vp(switch (cc) { |
| 14561 | else => unreachable, | 15374 | else => unreachable, |
| 14562 | .e => 0b00000, | 15375 | .e => .eq, |
| 14563 | .ne => 0b00100, | 15376 | .ne => .neq, |
| 14564 | }) }, | 15377 | }) }, |
| 14565 | } }, | 15378 | } }, |
| 14566 | }, .{ | 15379 | }, .{ |
| ... | @@ -14579,10 +15392,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14579,10 +15392,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14579 | .info = .{ .kind = .all, .scalar = .dword }, | 15392 | .info = .{ .kind = .all, .scalar = .dword }, |
| 14580 | } }}, | 15393 | } }}, |
| 14581 | .each = .{ .once = &.{ | 15394 | .each = .{ .once = &.{ |
| 14582 | .{ ._, ._ps, .cmp, .dst0x, .src1x, .ui(switch (cc) { | 15395 | .{ ._, ._ps, .cmp, .dst0x, .src1x, .vp(switch (cc) { |
| 14583 | else => unreachable, | 15396 | else => unreachable, |
| 14584 | .e => 0b00000, | 15397 | .e => .eq, |
| 14585 | .ne => 0b00100, | 15398 | .ne => .neq, |
| 14586 | }), ._ }, | 15399 | }), ._ }, |
| 14587 | } }, | 15400 | } }, |
| 14588 | }, .{ | 15401 | }, .{ |
| ... | @@ -14602,10 +15415,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14602,10 +15415,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14602 | .info = .{ .kind = .all, .scalar = .dword }, | 15415 | .info = .{ .kind = .all, .scalar = .dword }, |
| 14603 | } }}, | 15416 | } }}, |
| 14604 | .each = .{ .once = &.{ | 15417 | .each = .{ .once = &.{ |
| 14605 | .{ ._, .v_ps, .cmp, .dst0y, .src0y, .src1y, .ui(switch (cc) { | 15418 | .{ ._, .v_ps, .cmp, .dst0y, .src0y, .src1y, .vp(switch (cc) { |
| 14606 | else => unreachable, | 15419 | else => unreachable, |
| 14607 | .e => 0b00000, | 15420 | .e => .eq, |
| 14608 | .ne => 0b00100, | 15421 | .ne => .neq, |
| 14609 | }) }, | 15422 | }) }, |
| 14610 | } }, | 15423 | } }, |
| 14611 | }, .{ | 15424 | }, .{ |
| ... | @@ -14625,10 +15438,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14625,10 +15438,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14625 | .info = .{ .kind = .all, .scalar = .qword }, | 15438 | .info = .{ .kind = .all, .scalar = .qword }, |
| 14626 | } }}, | 15439 | } }}, |
| 14627 | .each = .{ .once = &.{ | 15440 | .each = .{ .once = &.{ |
| 14628 | .{ ._, .v_sd, .cmp, .dst0x, .src0x, .src1x, .ui(switch (cc) { | 15441 | .{ ._, .v_sd, .cmp, .dst0x, .src0x, .src1x, .vp(switch (cc) { |
| 14629 | else => unreachable, | 15442 | else => unreachable, |
| 14630 | .e => 0b00000, | 15443 | .e => .eq, |
| 14631 | .ne => 0b00100, | 15444 | .ne => .neq, |
| 14632 | }) }, | 15445 | }) }, |
| 14633 | } }, | 15446 | } }, |
| 14634 | }, .{ | 15447 | }, .{ |
| ... | @@ -14647,10 +15460,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14647,10 +15460,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14647 | .info = .{ .kind = .all, .scalar = .qword }, | 15460 | .info = .{ .kind = .all, .scalar = .qword }, |
| 14648 | } }}, | 15461 | } }}, |
| 14649 | .each = .{ .once = &.{ | 15462 | .each = .{ .once = &.{ |
| 14650 | .{ ._, ._sd, .cmp, .dst0x, .src1x, .ui(switch (cc) { | 15463 | .{ ._, ._sd, .cmp, .dst0x, .src1x, .vp(switch (cc) { |
| 14651 | else => unreachable, | 15464 | else => unreachable, |
| 14652 | .e => 0b00000, | 15465 | .e => .eq, |
| 14653 | .ne => 0b00100, | 15466 | .ne => .neq, |
| 14654 | }), ._ }, | 15467 | }), ._ }, |
| 14655 | } }, | 15468 | } }, |
| 14656 | }, .{ | 15469 | }, .{ |
| ... | @@ -14670,10 +15483,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14670,10 +15483,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14670 | .info = .{ .kind = .all, .scalar = .qword }, | 15483 | .info = .{ .kind = .all, .scalar = .qword }, |
| 14671 | } }}, | 15484 | } }}, |
| 14672 | .each = .{ .once = &.{ | 15485 | .each = .{ .once = &.{ |
| 14673 | .{ ._, .v_pd, .cmp, .dst0x, .src0x, .src1x, .ui(switch (cc) { | 15486 | .{ ._, .v_pd, .cmp, .dst0x, .src0x, .src1x, .vp(switch (cc) { |
| 14674 | else => unreachable, | 15487 | else => unreachable, |
| 14675 | .e => 0b00000, | 15488 | .e => .eq, |
| 14676 | .ne => 0b00100, | 15489 | .ne => .neq, |
| 14677 | }) }, | 15490 | }) }, |
| 14678 | } }, | 15491 | } }, |
| 14679 | }, .{ | 15492 | }, .{ |
| ... | @@ -14692,10 +15505,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14692,10 +15505,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14692 | .info = .{ .kind = .all, .scalar = .qword }, | 15505 | .info = .{ .kind = .all, .scalar = .qword }, |
| 14693 | } }}, | 15506 | } }}, |
| 14694 | .each = .{ .once = &.{ | 15507 | .each = .{ .once = &.{ |
| 14695 | .{ ._, ._pd, .cmp, .dst0x, .src1x, .ui(switch (cc) { | 15508 | .{ ._, ._pd, .cmp, .dst0x, .src1x, .vp(switch (cc) { |
| 14696 | else => unreachable, | 15509 | else => unreachable, |
| 14697 | .e => 0b00000, | 15510 | .e => .eq, |
| 14698 | .ne => 0b00100, | 15511 | .ne => .neq, |
| 14699 | }), ._ }, | 15512 | }), ._ }, |
| 14700 | } }, | 15513 | } }, |
| 14701 | }, .{ | 15514 | }, .{ |
| ... | @@ -14715,10 +15528,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14715,10 +15528,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14715 | .info = .{ .kind = .all, .scalar = .qword }, | 15528 | .info = .{ .kind = .all, .scalar = .qword }, |
| 14716 | } }}, | 15529 | } }}, |
| 14717 | .each = .{ .once = &.{ | 15530 | .each = .{ .once = &.{ |
| 14718 | .{ ._, .v_pd, .cmp, .dst0y, .src0y, .src1y, .ui(switch (cc) { | 15531 | .{ ._, .v_pd, .cmp, .dst0y, .src0y, .src1y, .vp(switch (cc) { |
| 14719 | else => unreachable, | 15532 | else => unreachable, |
| 14720 | .e => 0b00000, | 15533 | .e => .eq, |
| 14721 | .ne => 0b00100, | 15534 | .ne => .neq, |
| 14722 | }) }, | 15535 | }) }, |
| 14723 | } }, | 15536 | } }, |
| 14724 | }, .{ | 15537 | }, .{ |
| ... | @@ -14748,10 +15561,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14748,10 +15561,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14748 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 15561 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 14749 | .{ .@"0:", .v_ps, .cvtph2, .tmp2y, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 15562 | .{ .@"0:", .v_ps, .cvtph2, .tmp2y, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 14750 | .{ ._, .v_ps, .cvtph2, .tmp3y, .memia(.src1x, .tmp0, .add_size), ._, ._ }, | 15563 | .{ ._, .v_ps, .cvtph2, .tmp3y, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 14751 | .{ ._, .v_ps, .cmp, .tmp2y, .tmp2y, .tmp3y, .ui(switch (cc) { | 15564 | .{ ._, .v_ps, .cmp, .tmp2y, .tmp2y, .tmp3y, .vp(switch (cc) { |
| 14752 | else => unreachable, | 15565 | else => unreachable, |
| 14753 | .e => 0b00000, | 15566 | .e => .eq, |
| 14754 | .ne => 0b00100, | 15567 | .ne => .neq, |
| 14755 | }) }, | 15568 | }) }, |
| 14756 | .{ ._, .v_ps, .movmsk, .tmp4d, .tmp2y, ._, ._ }, | 15569 | .{ ._, .v_ps, .movmsk, .tmp4d, .tmp2y, ._, ._ }, |
| 14757 | .{ ._, ._, .mov, .lea(.byte, .tmp1), .tmp4b, ._, ._ }, | 15570 | .{ ._, ._, .mov, .lea(.byte, .tmp1), .tmp4b, ._, ._ }, |
| ... | @@ -14786,10 +15599,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14786,10 +15599,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14786 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 15599 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 14787 | .{ .@"0:", .v_ps, .cvtph2, .tmp2y, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 15600 | .{ .@"0:", .v_ps, .cvtph2, .tmp2y, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 14788 | .{ ._, .v_ps, .cvtph2, .tmp3y, .memia(.src1x, .tmp0, .add_size), ._, ._ }, | 15601 | .{ ._, .v_ps, .cvtph2, .tmp3y, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 14789 | .{ ._, .v_ps, .cmp, .tmp2y, .tmp2y, .tmp3y, .ui(switch (cc) { | 15602 | .{ ._, .v_ps, .cmp, .tmp2y, .tmp2y, .tmp3y, .vp(switch (cc) { |
| 14790 | else => unreachable, | 15603 | else => unreachable, |
| 14791 | .e => 0b00000, | 15604 | .e => .eq, |
| 14792 | .ne => 0b00100, | 15605 | .ne => .neq, |
| 14793 | }) }, | 15606 | }) }, |
| 14794 | .{ ._, .v_ps, .movmsk, .tmp4d, .tmp2y, ._, ._ }, | 15607 | .{ ._, .v_ps, .movmsk, .tmp4d, .tmp2y, ._, ._ }, |
| 14795 | .{ ._, ._, .mov, .lea(.byte, .tmp1), .tmp4b, ._, ._ }, | 15608 | .{ ._, ._, .mov, .lea(.byte, .tmp1), .tmp4b, ._, ._ }, |
| ... | @@ -14834,7 +15647,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14834,7 +15647,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14834 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, | 15647 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 14835 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, | 15648 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| 14836 | .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ }, | 15649 | .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ }, |
| 14837 | .{ ._, .fromCondition(cc), .set, .tmp6b, ._, ._, ._ }, | 15650 | .{ ._, .fromCond(cc), .set, .tmp6b, ._, ._, ._ }, |
| 14838 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, | 15651 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, |
| 14839 | .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ }, | 15652 | .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ }, |
| 14840 | .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ }, | 15653 | .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ }, |
| ... | @@ -14879,7 +15692,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14879,7 +15692,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14879 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, | 15692 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 14880 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, | 15693 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| 14881 | .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ }, | 15694 | .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ }, |
| 14882 | .{ ._, .fromCondition(cc), .set, .tmp6b, ._, ._, ._ }, | 15695 | .{ ._, .fromCond(cc), .set, .tmp6b, ._, ._, ._ }, |
| 14883 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, | 15696 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, |
| 14884 | .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ }, | 15697 | .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ }, |
| 14885 | .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ }, | 15698 | .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ }, |
| ... | @@ -14925,7 +15738,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14925,7 +15738,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14925 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, | 15738 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 14926 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, | 15739 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| 14927 | .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ }, | 15740 | .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ }, |
| 14928 | .{ ._, .fromCondition(cc), .set, .tmp6b, ._, ._, ._ }, | 15741 | .{ ._, .fromCond(cc), .set, .tmp6b, ._, ._, ._ }, |
| 14929 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, | 15742 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, |
| 14930 | .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ }, | 15743 | .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ }, |
| 14931 | .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ }, | 15744 | .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ }, |
| ... | @@ -14971,7 +15784,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14971,7 +15784,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14971 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, | 15784 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 14972 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, | 15785 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| 14973 | .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ }, | 15786 | .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ }, |
| 14974 | .{ ._, .fromCondition(cc), .set, .tmp6b, ._, ._, ._ }, | 15787 | .{ ._, .fromCond(cc), .set, .tmp6b, ._, ._, ._ }, |
| 14975 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, | 15788 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, |
| 14976 | .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ }, | 15789 | .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ }, |
| 14977 | .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ }, | 15790 | .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ }, |
| ... | @@ -15019,7 +15832,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15019,7 +15832,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15019 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, | 15832 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 15020 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, | 15833 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| 15021 | .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ }, | 15834 | .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ }, |
| 15022 | .{ ._, .fromCondition(cc), .set, .tmp6b, ._, ._, ._ }, | 15835 | .{ ._, .fromCond(cc), .set, .tmp6b, ._, ._, ._ }, |
| 15023 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, | 15836 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, |
| 15024 | .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ }, | 15837 | .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ }, |
| 15025 | .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ }, | 15838 | .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ }, |
| ... | @@ -15067,7 +15880,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15067,7 +15880,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15067 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, | 15880 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 15068 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, | 15881 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| 15069 | .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ }, | 15882 | .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ }, |
| 15070 | .{ ._, .fromCondition(cc), .set, .tmp6b, ._, ._, ._ }, | 15883 | .{ ._, .fromCond(cc), .set, .tmp6b, ._, ._, ._ }, |
| 15071 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, | 15884 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, |
| 15072 | .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ }, | 15885 | .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ }, |
| 15073 | .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ }, | 15886 | .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ }, |
| ... | @@ -15111,7 +15924,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15111,7 +15924,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15111 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, | 15924 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 15112 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, | 15925 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| 15113 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, | 15926 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, |
| 15114 | .{ ._, .fromCondition(cc), .set, .tmp7b, ._, ._, ._ }, | 15927 | .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, |
| 15115 | .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ }, | 15928 | .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ }, |
| 15116 | .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ }, | 15929 | .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ }, |
| 15117 | .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ }, | 15930 | .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ }, |
| ... | @@ -15166,7 +15979,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15166,7 +15979,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15166 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, | 15979 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 15167 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, | 15980 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| 15168 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, | 15981 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, |
| 15169 | .{ ._, .fromCondition(cc), .set, .tmp7b, ._, ._, ._ }, | 15982 | .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, |
| 15170 | .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ }, | 15983 | .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ }, |
| 15171 | .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ }, | 15984 | .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ }, |
| 15172 | .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ }, | 15985 | .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ }, |
| ... | @@ -15222,7 +16035,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15222,7 +16035,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15222 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, | 16035 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 15223 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, | 16036 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| 15224 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, | 16037 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, |
| 15225 | .{ ._, .fromCondition(cc), .set, .tmp7b, ._, ._, ._ }, | 16038 | .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, |
| 15226 | .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ }, | 16039 | .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ }, |
| 15227 | .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ }, | 16040 | .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ }, |
| 15228 | .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ }, | 16041 | .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ }, |
| ... | @@ -15278,7 +16091,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15278,7 +16091,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15278 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, | 16091 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 15279 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, | 16092 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| 15280 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, | 16093 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, |
| 15281 | .{ ._, .fromCondition(cc), .set, .tmp7b, ._, ._, ._ }, | 16094 | .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, |
| 15282 | .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ }, | 16095 | .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ }, |
| 15283 | .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ }, | 16096 | .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ }, |
| 15284 | .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ }, | 16097 | .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ }, |
| ... | @@ -15336,7 +16149,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15336,7 +16149,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15336 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, | 16149 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 15337 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, | 16150 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| 15338 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, | 16151 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, |
| 15339 | .{ ._, .fromCondition(cc), .set, .tmp7b, ._, ._, ._ }, | 16152 | .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, |
| 15340 | .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ }, | 16153 | .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ }, |
| 15341 | .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ }, | 16154 | .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ }, |
| 15342 | .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ }, | 16155 | .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ }, |
| ... | @@ -15394,7 +16207,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15394,7 +16207,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15394 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, | 16207 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 15395 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, | 16208 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| 15396 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, | 16209 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, |
| 15397 | .{ ._, .fromCondition(cc), .set, .tmp7b, ._, ._, ._ }, | 16210 | .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, |
| 15398 | .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ }, | 16211 | .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ }, |
| 15399 | .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ }, | 16212 | .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ }, |
| 15400 | .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ }, | 16213 | .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ }, |
| ... | @@ -15439,10 +16252,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15439,10 +16252,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15439 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 16252 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 15440 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 16253 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 15441 | .{ .@"0:", .v_ps, .mova, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, | 16254 | .{ .@"0:", .v_ps, .mova, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 15442 | .{ ._, .v_ps, .cmp, .tmp2y, .tmp2y, .memia(.src1y, .tmp0, .add_size), .ui(switch (cc) { | 16255 | .{ ._, .v_ps, .cmp, .tmp2y, .tmp2y, .memia(.src1y, .tmp0, .add_size), .vp(switch (cc) { |
| 15443 | else => unreachable, | 16256 | else => unreachable, |
| 15444 | .e => 0b00000, | 16257 | .e => .eq, |
| 15445 | .ne => 0b00100, | 16258 | .ne => .neq, |
| 15446 | }) }, | 16259 | }) }, |
| 15447 | .{ ._, .v_ps, .movmsk, .tmp3d, .tmp2y, ._, ._ }, | 16260 | .{ ._, .v_ps, .movmsk, .tmp3d, .tmp2y, ._, ._ }, |
| 15448 | .{ ._, ._, .mov, .lea(.byte, .tmp1), .tmp3b, ._, ._ }, | 16261 | .{ ._, ._, .mov, .lea(.byte, .tmp1), .tmp3b, ._, ._ }, |
| ... | @@ -15476,10 +16289,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15476,10 +16289,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15476 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 16289 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 15477 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 16290 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 15478 | .{ .@"0:", .v_ps, .mova, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, | 16291 | .{ .@"0:", .v_ps, .mova, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 15479 | .{ ._, .v_ps, .cmp, .tmp2y, .tmp2y, .memia(.src1y, .tmp0, .add_size), .ui(switch (cc) { | 16292 | .{ ._, .v_ps, .cmp, .tmp2y, .tmp2y, .memia(.src1y, .tmp0, .add_size), .vp(switch (cc) { |
| 15480 | else => unreachable, | 16293 | else => unreachable, |
| 15481 | .e => 0b00000, | 16294 | .e => .eq, |
| 15482 | .ne => 0b00100, | 16295 | .ne => .neq, |
| 15483 | }) }, | 16296 | }) }, |
| 15484 | .{ ._, .v_ps, .movmsk, .tmp3d, .tmp2y, ._, ._ }, | 16297 | .{ ._, .v_ps, .movmsk, .tmp3d, .tmp2y, ._, ._ }, |
| 15485 | .{ ._, ._, .mov, .lea(.byte, .tmp1), .tmp3b, ._, ._ }, | 16298 | .{ ._, ._, .mov, .lea(.byte, .tmp1), .tmp3b, ._, ._ }, |
| ... | @@ -15514,15 +16327,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15514,15 +16327,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15514 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 16327 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 15515 | .{ .@"0:", ._ps, .mova, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 16328 | .{ .@"0:", ._ps, .mova, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 15516 | .{ ._, ._ps, .mova, .tmp3x, .memiad(.src0x, .tmp0, .add_size, 16), ._, ._ }, | 16329 | .{ ._, ._ps, .mova, .tmp3x, .memiad(.src0x, .tmp0, .add_size, 16), ._, ._ }, |
| 15517 | .{ ._, ._ps, .cmp, .tmp2x, .memia(.src1x, .tmp0, .add_size), .ui(switch (cc) { | 16330 | .{ ._, ._ps, .cmp, .tmp2x, .memia(.src1x, .tmp0, .add_size), .vp(switch (cc) { |
| 15518 | else => unreachable, | 16331 | else => unreachable, |
| 15519 | .e => 0b00000, | 16332 | .e => .eq, |
| 15520 | .ne => 0b00100, | 16333 | .ne => .neq, |
| 15521 | }), ._ }, | 16334 | }), ._ }, |
| 15522 | .{ ._, ._ps, .cmp, .tmp3x, .memiad(.src1x, .tmp0, .add_size, 16), .ui(switch (cc) { | 16335 | .{ ._, ._ps, .cmp, .tmp3x, .memiad(.src1x, .tmp0, .add_size, 16), .vp(switch (cc) { |
| 15523 | else => unreachable, | 16336 | else => unreachable, |
| 15524 | .e => 0b00000, | 16337 | .e => .eq, |
| 15525 | .ne => 0b00100, | 16338 | .ne => .neq, |
| 15526 | }), ._ }, | 16339 | }), ._ }, |
| 15527 | .{ ._, .p_w, .ackssd, .tmp2x, .tmp3x, ._, ._ }, | 16340 | .{ ._, .p_w, .ackssd, .tmp2x, .tmp3x, ._, ._ }, |
| 15528 | .{ ._, .p_b, .ackssw, .tmp2x, .tmp2x, ._, ._ }, | 16341 | .{ ._, .p_b, .ackssw, .tmp2x, .tmp2x, ._, ._ }, |
| ... | @@ -15558,17 +16371,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15558,17 +16371,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15558 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 16371 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 15559 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 16372 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 15560 | .{ .@"0:", ._ps, .mova, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 16373 | .{ .@"0:", ._ps, .mova, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 15561 | .{ ._, ._ps, .cmp, .tmp2x, .memia(.src1x, .tmp0, .add_size), .ui(switch (cc) { | 16374 | .{ ._, ._ps, .cmp, .tmp2x, .memia(.src1x, .tmp0, .add_size), .vp(switch (cc) { |
| 15562 | else => unreachable, | 16375 | else => unreachable, |
| 15563 | .e => 0b00000, | 16376 | .e => .eq, |
| 15564 | .ne => 0b00100, | 16377 | .ne => .neq, |
| 15565 | }), ._ }, | 16378 | }), ._ }, |
| 15566 | .{ ._, ._ps, .movmsk, .tmp3d, .tmp2x, ._, ._ }, | 16379 | .{ ._, ._ps, .movmsk, .tmp3d, .tmp2x, ._, ._ }, |
| 15567 | .{ ._, ._ps, .mova, .tmp2x, .memiad(.src0x, .tmp0, .add_size, 16), ._, ._ }, | 16380 | .{ ._, ._ps, .mova, .tmp2x, .memiad(.src0x, .tmp0, .add_size, 16), ._, ._ }, |
| 15568 | .{ ._, ._ps, .cmp, .tmp2x, .memiad(.src1x, .tmp0, .add_size, 16), .ui(switch (cc) { | 16381 | .{ ._, ._ps, .cmp, .tmp2x, .memiad(.src1x, .tmp0, .add_size, 16), .vp(switch (cc) { |
| 15569 | else => unreachable, | 16382 | else => unreachable, |
| 15570 | .e => 0b00000, | 16383 | .e => .eq, |
| 15571 | .ne => 0b00100, | 16384 | .ne => .neq, |
| 15572 | }), ._ }, | 16385 | }), ._ }, |
| 15573 | .{ ._, ._ps, .movmsk, .tmp4d, .tmp2x, ._, ._ }, | 16386 | .{ ._, ._ps, .movmsk, .tmp4d, .tmp2x, ._, ._ }, |
| 15574 | .{ ._, ._l, .sh, .tmp4b, .ui(4), ._, ._ }, | 16387 | .{ ._, ._l, .sh, .tmp4b, .ui(4), ._, ._ }, |
| ... | @@ -15605,10 +16418,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15605,10 +16418,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15605 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 16418 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 15606 | .{ ._, ._mp, .j, .@"1f", ._, ._, ._ }, | 16419 | .{ ._, ._mp, .j, .@"1f", ._, ._, ._ }, |
| 15607 | .{ .@"0:", ._ps, .mova, .tmp2x, .memiad(.src0x, .tmp0, .add_size, -16), ._, ._ }, | 16420 | .{ .@"0:", ._ps, .mova, .tmp2x, .memiad(.src0x, .tmp0, .add_size, -16), ._, ._ }, |
| 15608 | .{ ._, ._ps, .cmp, .tmp2x, .memiad(.src1x, .tmp0, .add_size, -16), .ui(switch (cc) { | 16421 | .{ ._, ._ps, .cmp, .tmp2x, .memiad(.src1x, .tmp0, .add_size, -16), .vp(switch (cc) { |
| 15609 | else => unreachable, | 16422 | else => unreachable, |
| 15610 | .e => 0b00000, | 16423 | .e => .eq, |
| 15611 | .ne => 0b00100, | 16424 | .ne => .neq, |
| 15612 | }), ._ }, | 16425 | }), ._ }, |
| 15613 | .{ ._, ._ps, .movmsk, .tmp4d, .tmp2x, ._, ._ }, | 16426 | .{ ._, ._ps, .movmsk, .tmp4d, .tmp2x, ._, ._ }, |
| 15614 | .{ ._, ._l, .sh, .tmp4b, .ui(4), ._, ._ }, | 16427 | .{ ._, ._l, .sh, .tmp4b, .ui(4), ._, ._ }, |
| ... | @@ -15616,10 +16429,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15616,10 +16429,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15616 | .{ ._, ._, .mov, .lea(.byte, .tmp1), .tmp3b, ._, ._ }, | 16429 | .{ ._, ._, .mov, .lea(.byte, .tmp1), .tmp3b, ._, ._ }, |
| 15617 | .{ ._, ._, .lea, .tmp1p, .lead(.none, .tmp1, 1), ._, ._ }, | 16430 | .{ ._, ._, .lea, .tmp1p, .lead(.none, .tmp1, 1), ._, ._ }, |
| 15618 | .{ .@"1:", ._ps, .mova, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 16431 | .{ .@"1:", ._ps, .mova, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 15619 | .{ ._, ._ps, .cmp, .tmp2x, .memia(.src1x, .tmp0, .add_size), .ui(switch (cc) { | 16432 | .{ ._, ._ps, .cmp, .tmp2x, .memia(.src1x, .tmp0, .add_size), .vp(switch (cc) { |
| 15620 | else => unreachable, | 16433 | else => unreachable, |
| 15621 | .e => 0b00000, | 16434 | .e => .eq, |
| 15622 | .ne => 0b00100, | 16435 | .ne => .neq, |
| 15623 | }), ._ }, | 16436 | }), ._ }, |
| 15624 | .{ ._, ._ps, .movmsk, .tmp3d, .tmp2x, ._, ._ }, | 16437 | .{ ._, ._ps, .movmsk, .tmp3d, .tmp2x, ._, ._ }, |
| 15625 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, | 16438 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| ... | @@ -15653,15 +16466,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15653,15 +16466,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15653 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 16466 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 15654 | .{ .@"0:", .v_pd, .mova, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, | 16467 | .{ .@"0:", .v_pd, .mova, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 15655 | .{ ._, .v_pd, .mova, .tmp3y, .memiad(.src0y, .tmp0, .add_size, 32), ._, ._ }, | 16468 | .{ ._, .v_pd, .mova, .tmp3y, .memiad(.src0y, .tmp0, .add_size, 32), ._, ._ }, |
| 15656 | .{ ._, .v_pd, .cmp, .tmp2y, .tmp2y, .memia(.src1y, .tmp0, .add_size), .ui(switch (cc) { | 16469 | .{ ._, .v_pd, .cmp, .tmp2y, .tmp2y, .memia(.src1y, .tmp0, .add_size), .vp(switch (cc) { |
| 15657 | else => unreachable, | 16470 | else => unreachable, |
| 15658 | .e => 0b00000, | 16471 | .e => .eq, |
| 15659 | .ne => 0b00100, | 16472 | .ne => .neq, |
| 15660 | }) }, | 16473 | }) }, |
| 15661 | .{ ._, .v_pd, .cmp, .tmp3y, .tmp3y, .memiad(.src1y, .tmp0, .add_size, 32), .ui(switch (cc) { | 16474 | .{ ._, .v_pd, .cmp, .tmp3y, .tmp3y, .memiad(.src1y, .tmp0, .add_size, 32), .vp(switch (cc) { |
| 15662 | else => unreachable, | 16475 | else => unreachable, |
| 15663 | .e => 0b00000, | 16476 | .e => .eq, |
| 15664 | .ne => 0b00100, | 16477 | .ne => .neq, |
| 15665 | }) }, | 16478 | }) }, |
| 15666 | .{ ._, .v_pd, .movmsk, .tmp4d, .tmp2y, ._, ._ }, | 16479 | .{ ._, .v_pd, .movmsk, .tmp4d, .tmp2y, ._, ._ }, |
| 15667 | .{ ._, .v_pd, .movmsk, .tmp5d, .tmp3y, ._, ._ }, | 16480 | .{ ._, .v_pd, .movmsk, .tmp5d, .tmp3y, ._, ._ }, |
| ... | @@ -15699,15 +16512,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15699,15 +16512,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15699 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 16512 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 15700 | .{ .@"0:", .v_pd, .mova, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, | 16513 | .{ .@"0:", .v_pd, .mova, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 15701 | .{ ._, .v_pd, .mova, .tmp3y, .memiad(.src0y, .tmp0, .add_size, 32), ._, ._ }, | 16514 | .{ ._, .v_pd, .mova, .tmp3y, .memiad(.src0y, .tmp0, .add_size, 32), ._, ._ }, |
| 15702 | .{ ._, .v_pd, .cmp, .tmp2y, .tmp2y, .memia(.src1y, .tmp0, .add_size), .ui(switch (cc) { | 16515 | .{ ._, .v_pd, .cmp, .tmp2y, .tmp2y, .memia(.src1y, .tmp0, .add_size), .vp(switch (cc) { |
| 15703 | else => unreachable, | 16516 | else => unreachable, |
| 15704 | .e => 0b00000, | 16517 | .e => .eq, |
| 15705 | .ne => 0b00100, | 16518 | .ne => .neq, |
| 15706 | }) }, | 16519 | }) }, |
| 15707 | .{ ._, .v_pd, .cmp, .tmp3y, .tmp3y, .memiad(.src1y, .tmp0, .add_size, 32), .ui(switch (cc) { | 16520 | .{ ._, .v_pd, .cmp, .tmp3y, .tmp3y, .memiad(.src1y, .tmp0, .add_size, 32), .vp(switch (cc) { |
| 15708 | else => unreachable, | 16521 | else => unreachable, |
| 15709 | .e => 0b00000, | 16522 | .e => .eq, |
| 15710 | .ne => 0b00100, | 16523 | .ne => .neq, |
| 15711 | }) }, | 16524 | }) }, |
| 15712 | .{ ._, .v_pd, .movmsk, .tmp4d, .tmp2y, ._, ._ }, | 16525 | .{ ._, .v_pd, .movmsk, .tmp4d, .tmp2y, ._, ._ }, |
| 15713 | .{ ._, .v_pd, .movmsk, .tmp5d, .tmp3y, ._, ._ }, | 16526 | .{ ._, .v_pd, .movmsk, .tmp5d, .tmp3y, ._, ._ }, |
| ... | @@ -15745,10 +16558,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15745,10 +16558,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15745 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 16558 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 15746 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | 16559 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 15747 | .{ .@"0:", .v_pd, .mova, .tmp3y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, | 16560 | .{ .@"0:", .v_pd, .mova, .tmp3y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 15748 | .{ ._, .v_pd, .cmp, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_size), .ui(switch (cc) { | 16561 | .{ ._, .v_pd, .cmp, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_size), .vp(switch (cc) { |
| 15749 | else => unreachable, | 16562 | else => unreachable, |
| 15750 | .e => 0b00000, | 16563 | .e => .eq, |
| 15751 | .ne => 0b00100, | 16564 | .ne => .neq, |
| 15752 | }) }, | 16565 | }) }, |
| 15753 | .{ ._, .v_pd, .movmsk, .tmp4d, .tmp3y, ._, ._ }, | 16566 | .{ ._, .v_pd, .movmsk, .tmp4d, .tmp3y, ._, ._ }, |
| 15754 | .{ ._, ._l, .ro, .tmp4b, .tmp1b, ._, ._ }, | 16567 | .{ ._, ._l, .ro, .tmp4b, .tmp1b, ._, ._ }, |
| ... | @@ -15795,10 +16608,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15795,10 +16608,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15795 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 16608 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 15796 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | 16609 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 15797 | .{ .@"0:", ._pd, .mova, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 16610 | .{ .@"0:", ._pd, .mova, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 15798 | .{ ._, ._pd, .cmp, .tmp3x, .memia(.src1x, .tmp0, .add_size), .ui(switch (cc) { | 16611 | .{ ._, ._pd, .cmp, .tmp3x, .memia(.src1x, .tmp0, .add_size), .vp(switch (cc) { |
| 15799 | else => unreachable, | 16612 | else => unreachable, |
| 15800 | .e => 0b00000, | 16613 | .e => .eq, |
| 15801 | .ne => 0b00100, | 16614 | .ne => .neq, |
| 15802 | }), ._ }, | 16615 | }), ._ }, |
| 15803 | .{ ._, ._pd, .movmsk, .tmp4d, .tmp3x, ._, ._ }, | 16616 | .{ ._, ._pd, .movmsk, .tmp4d, .tmp3x, ._, ._ }, |
| 15804 | .{ ._, ._l, .ro, .tmp4b, .tmp1b, ._, ._ }, | 16617 | .{ ._, ._l, .ro, .tmp4b, .tmp1b, ._, ._ }, |
| ... | @@ -15850,7 +16663,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15850,7 +16663,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15850 | .{ ._, .f_, .ld, .memia(.src0q, .tmp0, .add_size), ._, ._, ._ }, | 16663 | .{ ._, .f_, .ld, .memia(.src0q, .tmp0, .add_size), ._, ._, ._ }, |
| 15851 | .{ ._, .f_p, .ucomi, .tmp5t, .tmp6t, ._, ._ }, | 16664 | .{ ._, .f_p, .ucomi, .tmp5t, .tmp6t, ._, ._ }, |
| 15852 | .{ ._, .f_p, .st, .tmp6t, ._, ._, ._ }, | 16665 | .{ ._, .f_p, .st, .tmp6t, ._, ._, ._ }, |
| 15853 | .{ ._, .fromCondition(cc), .set, .tmp3b, ._, ._, ._ }, | 16666 | .{ ._, .fromCond(cc), .set, .tmp3b, ._, ._, ._ }, |
| 15854 | .{ ._, switch (cc) { | 16667 | .{ ._, switch (cc) { |
| 15855 | else => unreachable, | 16668 | else => unreachable, |
| 15856 | .e => ._np, | 16669 | .e => ._np, |
| ... | @@ -15910,7 +16723,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15910,7 +16723,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15910 | .{ ._, .f_, .ld, .memia(.src0q, .tmp0, .add_size), ._, ._, ._ }, | 16723 | .{ ._, .f_, .ld, .memia(.src0q, .tmp0, .add_size), ._, ._, ._ }, |
| 15911 | .{ ._, .f_p, .ucomi, .tmp5t, .tmp6t, ._, ._ }, | 16724 | .{ ._, .f_p, .ucomi, .tmp5t, .tmp6t, ._, ._ }, |
| 15912 | .{ ._, .f_p, .st, .tmp6t, ._, ._, ._ }, | 16725 | .{ ._, .f_p, .st, .tmp6t, ._, ._, ._ }, |
| 15913 | .{ ._, .fromCondition(cc), .set, .tmp3b, ._, ._, ._ }, | 16726 | .{ ._, .fromCond(cc), .set, .tmp3b, ._, ._, ._ }, |
| 15914 | .{ ._, switch (cc) { | 16727 | .{ ._, switch (cc) { |
| 15915 | else => unreachable, | 16728 | else => unreachable, |
| 15916 | .e => ._np, | 16729 | .e => ._np, |
| ... | @@ -15971,7 +16784,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15971,7 +16784,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15971 | .{ ._, .fn_sw, .st, .tmp6w, ._, ._, ._ }, | 16784 | .{ ._, .fn_sw, .st, .tmp6w, ._, ._, ._ }, |
| 15972 | .{ ._, ._, .xor, .tmp6b, .si(0b0_1_000_000), ._, ._ }, | 16785 | .{ ._, ._, .xor, .tmp6b, .si(0b0_1_000_000), ._, ._ }, |
| 15973 | .{ ._, ._, .@"test", .tmp6b, .si(0b0_1_000_100), ._, ._ }, | 16786 | .{ ._, ._, .@"test", .tmp6b, .si(0b0_1_000_100), ._, ._ }, |
| 15974 | .{ ._, .fromCondition(cc), .set, .tmp3b, ._, ._, ._ }, | 16787 | .{ ._, .fromCond(cc), .set, .tmp3b, ._, ._, ._ }, |
| 15975 | .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ }, | 16788 | .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ }, |
| 15976 | .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ }, | 16789 | .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ }, |
| 15977 | .{ ._, ._c, .in, .tmp1d, ._, ._, ._ }, | 16790 | .{ ._, ._c, .in, .tmp1d, ._, ._, ._ }, |
| ... | @@ -16021,7 +16834,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16021,7 +16834,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16021 | .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ }, | 16834 | .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ }, |
| 16022 | .{ ._, .f_p, .ucomi, .tmp5t, .tmp6t, ._, ._ }, | 16835 | .{ ._, .f_p, .ucomi, .tmp5t, .tmp6t, ._, ._ }, |
| 16023 | .{ ._, .f_p, .st, .tmp6t, ._, ._, ._ }, | 16836 | .{ ._, .f_p, .st, .tmp6t, ._, ._, ._ }, |
| 16024 | .{ ._, .fromCondition(cc), .set, .tmp3b, ._, ._, ._ }, | 16837 | .{ ._, .fromCond(cc), .set, .tmp3b, ._, ._, ._ }, |
| 16025 | .{ ._, switch (cc) { | 16838 | .{ ._, switch (cc) { |
| 16026 | else => unreachable, | 16839 | else => unreachable, |
| 16027 | .e => ._np, | 16840 | .e => ._np, |
| ... | @@ -16081,7 +16894,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16081,7 +16894,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16081 | .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ }, | 16894 | .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ }, |
| 16082 | .{ ._, .f_p, .ucomi, .tmp5t, .tmp6t, ._, ._ }, | 16895 | .{ ._, .f_p, .ucomi, .tmp5t, .tmp6t, ._, ._ }, |
| 16083 | .{ ._, .f_p, .st, .tmp6t, ._, ._, ._ }, | 16896 | .{ ._, .f_p, .st, .tmp6t, ._, ._, ._ }, |
| 16084 | .{ ._, .fromCondition(cc), .set, .tmp3b, ._, ._, ._ }, | 16897 | .{ ._, .fromCond(cc), .set, .tmp3b, ._, ._, ._ }, |
| 16085 | .{ ._, switch (cc) { | 16898 | .{ ._, switch (cc) { |
| 16086 | else => unreachable, | 16899 | else => unreachable, |
| 16087 | .e => ._np, | 16900 | .e => ._np, |
| ... | @@ -16142,7 +16955,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16142,7 +16955,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16142 | .{ ._, .fn_sw, .st, .tmp6w, ._, ._, ._ }, | 16955 | .{ ._, .fn_sw, .st, .tmp6w, ._, ._, ._ }, |
| 16143 | .{ ._, ._, .xor, .tmp6b, .si(0b0_1_000_000), ._, ._ }, | 16956 | .{ ._, ._, .xor, .tmp6b, .si(0b0_1_000_000), ._, ._ }, |
| 16144 | .{ ._, ._, .@"test", .tmp6b, .si(0b0_1_000_100), ._, ._ }, | 16957 | .{ ._, ._, .@"test", .tmp6b, .si(0b0_1_000_100), ._, ._ }, |
| 16145 | .{ ._, .fromCondition(cc), .set, .tmp3b, ._, ._, ._ }, | 16958 | .{ ._, .fromCond(cc), .set, .tmp3b, ._, ._, ._ }, |
| 16146 | .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ }, | 16959 | .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ }, |
| 16147 | .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ }, | 16960 | .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ }, |
| 16148 | .{ ._, ._c, .in, .tmp1d, ._, ._, ._ }, | 16961 | .{ ._, ._c, .in, .tmp1d, ._, ._, ._ }, |
| ... | @@ -16197,7 +17010,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16197,7 +17010,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16197 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, | 17010 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 16198 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, | 17011 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| 16199 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, | 17012 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, |
| 16200 | .{ ._, .fromCondition(cc), .set, .tmp7b, ._, ._, ._ }, | 17013 | .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, |
| 16201 | .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ }, | 17014 | .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ }, |
| 16202 | .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ }, | 17015 | .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ }, |
| 16203 | .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ }, | 17016 | .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ }, |
| ... | @@ -16242,7 +17055,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16242,7 +17055,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16242 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, | 17055 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 16243 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, | 17056 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| 16244 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, | 17057 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, |
| 16245 | .{ ._, .fromCondition(cc), .set, .tmp7b, ._, ._, ._ }, | 17058 | .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, |
| 16246 | .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ }, | 17059 | .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ }, |
| 16247 | .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ }, | 17060 | .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ }, |
| 16248 | .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ }, | 17061 | .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ }, |
| ... | @@ -16287,7 +17100,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16287,7 +17100,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16287 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, | 17100 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 16288 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, | 17101 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| 16289 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, | 17102 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, |
| 16290 | .{ ._, .fromCondition(cc), .set, .tmp7b, ._, ._, ._ }, | 17103 | .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, |
| 16291 | .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ }, | 17104 | .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ }, |
| 16292 | .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ }, | 17105 | .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ }, |
| 16293 | .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ }, | 17106 | .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ }, |
| ... | @@ -16332,7 +17145,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16332,7 +17145,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16332 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, | 17145 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 16333 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, | 17146 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| 16334 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, | 17147 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, |
| 16335 | .{ ._, .fromCondition(cc), .set, .tmp7b, ._, ._, ._ }, | 17148 | .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, |
| 16336 | .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ }, | 17149 | .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ }, |
| 16337 | .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ }, | 17150 | .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ }, |
| 16338 | .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ }, | 17151 | .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ }, |
| ... | @@ -16377,7 +17190,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16377,7 +17190,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16377 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, | 17190 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 16378 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, | 17191 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| 16379 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, | 17192 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, |
| 16380 | .{ ._, .fromCondition(cc), .set, .tmp7b, ._, ._, ._ }, | 17193 | .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, |
| 16381 | .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ }, | 17194 | .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ }, |
| 16382 | .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ }, | 17195 | .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ }, |
| 16383 | .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ }, | 17196 | .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ }, |
| ... | @@ -16422,7 +17235,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16422,7 +17235,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16422 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, | 17235 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 16423 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, | 17236 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| 16424 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, | 17237 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, |
| 16425 | .{ ._, .fromCondition(cc), .set, .tmp7b, ._, ._, ._ }, | 17238 | .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, |
| 16426 | .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ }, | 17239 | .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ }, |
| 16427 | .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ }, | 17240 | .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ }, |
| 16428 | .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ }, | 17241 | .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ }, |
| ... | @@ -16466,7 +17279,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16466,7 +17279,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16466 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, | 17279 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 16467 | .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, | 17280 | .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, |
| 16468 | .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ }, | 17281 | .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ }, |
| 16469 | .{ ._, .fromCondition(cc), .set, .tmp8b, ._, ._, ._ }, | 17282 | .{ ._, .fromCond(cc), .set, .tmp8b, ._, ._, ._ }, |
| 16470 | .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ }, | 17283 | .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ }, |
| 16471 | .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ }, | 17284 | .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ }, |
| 16472 | .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, | 17285 | .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, |
| ... | @@ -16521,7 +17334,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16521,7 +17334,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16521 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, | 17334 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 16522 | .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, | 17335 | .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, |
| 16523 | .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ }, | 17336 | .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ }, |
| 16524 | .{ ._, .fromCondition(cc), .set, .tmp8b, ._, ._, ._ }, | 17337 | .{ ._, .fromCond(cc), .set, .tmp8b, ._, ._, ._ }, |
| 16525 | .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ }, | 17338 | .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ }, |
| 16526 | .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ }, | 17339 | .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ }, |
| 16527 | .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, | 17340 | .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, |
| ... | @@ -16576,7 +17389,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16576,7 +17389,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16576 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, | 17389 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 16577 | .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, | 17390 | .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, |
| 16578 | .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ }, | 17391 | .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ }, |
| 16579 | .{ ._, .fromCondition(cc), .set, .tmp8b, ._, ._, ._ }, | 17392 | .{ ._, .fromCond(cc), .set, .tmp8b, ._, ._, ._ }, |
| 16580 | .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ }, | 17393 | .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ }, |
| 16581 | .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ }, | 17394 | .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ }, |
| 16582 | .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, | 17395 | .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, |
| ... | @@ -16631,7 +17444,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16631,7 +17444,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16631 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, | 17444 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 16632 | .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, | 17445 | .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, |
| 16633 | .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ }, | 17446 | .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ }, |
| 16634 | .{ ._, .fromCondition(cc), .set, .tmp8b, ._, ._, ._ }, | 17447 | .{ ._, .fromCond(cc), .set, .tmp8b, ._, ._, ._ }, |
| 16635 | .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ }, | 17448 | .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ }, |
| 16636 | .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ }, | 17449 | .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ }, |
| 16637 | .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, | 17450 | .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, |
| ... | @@ -16686,7 +17499,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16686,7 +17499,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16686 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, | 17499 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 16687 | .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, | 17500 | .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, |
| 16688 | .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ }, | 17501 | .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ }, |
| 16689 | .{ ._, .fromCondition(cc), .set, .tmp8b, ._, ._, ._ }, | 17502 | .{ ._, .fromCond(cc), .set, .tmp8b, ._, ._, ._ }, |
| 16690 | .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ }, | 17503 | .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ }, |
| 16691 | .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ }, | 17504 | .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ }, |
| 16692 | .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, | 17505 | .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, |
| ... | @@ -16741,7 +17554,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16741,7 +17554,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16741 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, | 17554 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 16742 | .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, | 17555 | .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, |
| 16743 | .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ }, | 17556 | .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ }, |
| 16744 | .{ ._, .fromCondition(cc), .set, .tmp8b, ._, ._, ._ }, | 17557 | .{ ._, .fromCond(cc), .set, .tmp8b, ._, ._, ._ }, |
| 16745 | .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ }, | 17558 | .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ }, |
| 16746 | .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ }, | 17559 | .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ }, |
| 16747 | .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, | 17560 | .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, |
| ... | @@ -18419,7 +19232,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18419,7 +19232,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18419 | .{ ._, ._, .mov, .tmp1p, .memia(.src0p, .tmp0, .add_size), ._, ._ }, | 19232 | .{ ._, ._, .mov, .tmp1p, .memia(.src0p, .tmp0, .add_size), ._, ._ }, |
| 18420 | .{ ._, ._, .sbb, .tmp1p, .memia(.src1p, .tmp0, .add_size), ._, ._ }, | 19233 | .{ ._, ._, .sbb, .tmp1p, .memia(.src1p, .tmp0, .add_size), ._, ._ }, |
| 18421 | .{ ._, ._c, .set, .tmp1b, ._, ._, ._ }, | 19234 | .{ ._, ._c, .set, .tmp1b, ._, ._, ._ }, |
| 18422 | .{ ._, .fromCondition(switch (cc) { | 19235 | .{ ._, .fromCond(switch (cc) { |
| 18423 | else => unreachable, | 19236 | else => unreachable, |
| 18424 | .l, .ge, .b, .ae => cc, | 19237 | .l, .ge, .b, .ae => cc, |
| 18425 | .le, .g, .be, .a => cc.commute(), | 19238 | .le, .g, .be, .a => cc.commute(), |
| ... | @@ -18979,8 +19792,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18979,8 +19792,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18979 | .{ .src = .{ .to_sse, .to_sse } }, | 19792 | .{ .src = .{ .to_sse, .to_sse } }, |
| 18980 | }, | 19793 | }, |
| 18981 | .extra_temps = .{ | 19794 | .extra_temps = .{ |
| 18982 | .{ .kind = .{ .rc = .sse } }, | 19795 | .{ .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| 18983 | .{ .kind = .{ .rc = .sse } }, | 19796 | .{ .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 18984 | .unused, | 19797 | .unused, |
| 18985 | .unused, | 19798 | .unused, |
| 18986 | .unused, | 19799 | .unused, |
| ... | @@ -18996,9 +19809,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18996,9 +19809,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18996 | } }}, | 19809 | } }}, |
| 18997 | .clobbers = .{ .eflags = true }, | 19810 | .clobbers = .{ .eflags = true }, |
| 18998 | .each = .{ .once = &.{ | 19811 | .each = .{ .once = &.{ |
| 18999 | .{ ._, .vp_, .unpcklwd, .tmp0x, .src0x, .src1x, ._ }, | 19812 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src0x, ._, ._ }, |
| 19000 | .{ ._, .v_ps, .cvtph2, .tmp0x, .tmp0x, ._, ._ }, | 19813 | .{ ._, .v_ps, .cvtph2, .tmp1x, .src1x, ._, ._ }, |
| 19001 | .{ ._, .v_, .movshdup, .tmp1x, .tmp0x, ._, ._ }, | | |
| 19002 | .{ ._, .v_ss, .ucomi, .tmp0x, .tmp1x, ._, ._ }, | 19814 | .{ ._, .v_ss, .ucomi, .tmp0x, .tmp1x, ._, ._ }, |
| 19003 | } }, | 19815 | } }, |
| 19004 | }, .{ | 19816 | }, .{ |
| ... | @@ -19197,35 +20009,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19197,35 +20009,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19197 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, | 20009 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 19198 | .{ ._, ._, .@"test", .tmp1d, .tmp1d, ._, ._ }, | 20010 | .{ ._, ._, .@"test", .tmp1d, .tmp1d, ._, ._ }, |
| 19199 | } }, | 20011 | } }, |
| 19200 | }, .{ | | |
| 19201 | .required_features = .{ .x87, .cmov, null, null }, | | |
| 19202 | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte } }, | | |
| 19203 | .patterns = &.{ | | |
| 19204 | .{ .src = .{ .mem, .mem } }, | | |
| 19205 | }, | | |
| 19206 | .extra_temps = .{ | | |
| 19207 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, | | |
| 19208 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | | |
| 19209 | .unused, | | |
| 19210 | .unused, | | |
| 19211 | .unused, | | |
| 19212 | .unused, | | |
| 19213 | .unused, | | |
| 19214 | .unused, | | |
| 19215 | .unused, | | |
| 19216 | }, | | |
| 19217 | .dst_temps = .{.{ .cc = switch (cc) { | | |
| 19218 | else => unreachable, | | |
| 19219 | .e => .z_and_np, | | |
| 19220 | .ne => .nz_or_p, | | |
| 19221 | } }}, | | |
| 19222 | .clobbers = .{ .eflags = true }, | | |
| 19223 | .each = .{ .once = &.{ | | |
| 19224 | .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, | | |
| 19225 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, | | |
| 19226 | .{ ._, .f_p, .ucomi, .tmp0t, .tmp1t, ._, ._ }, | | |
| 19227 | .{ ._, .f_p, .st, .tmp1t, ._, ._, ._ }, | | |
| 19228 | } }, | | |
| 19229 | }, .{ | 20012 | }, .{ |
| 19230 | .required_features = .{ .x87, .cmov, null, null }, | 20013 | .required_features = .{ .x87, .cmov, null, null }, |
| 19231 | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte } }, | 20014 | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte } }, |
| ... | @@ -19479,46 +20262,59 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19479,46 +20262,59 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19479 | .switch_dispatch => try cg.airSwitchDispatch(inst), | 20262 | .switch_dispatch => try cg.airSwitchDispatch(inst), |
| 19480 | .@"try", .try_cold => try cg.airTry(inst), | 20263 | .@"try", .try_cold => try cg.airTry(inst), |
| 19481 | .try_ptr, .try_ptr_cold => try cg.airTryPtr(inst), | 20264 | .try_ptr, .try_ptr_cold => try cg.airTryPtr(inst), |
| 19482 | .dbg_stmt => if (use_old) try cg.airDbgStmt(inst) else { | 20265 | .dbg_stmt => if (cg.debug_output != .none) { |
| 19483 | const dbg_stmt = air_datas[@intFromEnum(inst)].dbg_stmt; | 20266 | const dbg_stmt = air_datas[@intFromEnum(inst)].dbg_stmt; |
| 19484 | _ = try cg.addInst(.{ | 20267 | _ = try cg.addInst(.{ |
| 19485 | .tag = .pseudo, | 20268 | .tag = .pseudo, |
| 19486 | .ops = .pseudo_dbg_line_line_column, | 20269 | .ops = .pseudo_dbg_line_stmt_line_column, |
| 19487 | .data = .{ .line_column = .{ | 20270 | .data = .{ .line_column = .{ |
| 19488 | .line = dbg_stmt.line, | 20271 | .line = dbg_stmt.line, |
| 19489 | .column = dbg_stmt.column, | 20272 | .column = dbg_stmt.column, |
| 19490 | } }, | 20273 | } }, |
| 19491 | }); | 20274 | }); |
| 19492 | }, | 20275 | }, |
| 19493 | .dbg_empty_stmt => if (use_old) try cg.airDbgEmptyStmt() else { | 20276 | .dbg_empty_stmt => if (cg.debug_output != .none) { |
| 19494 | if (cg.mir_instructions.len > 0) { | 20277 | if (cg.mir_instructions.len > 0) { |
| 19495 | const prev_mir_op = &cg.mir_instructions.items(.ops)[cg.mir_instructions.len - 1]; | 20278 | const prev_mir_op = &cg.mir_instructions.items(.ops)[cg.mir_instructions.len - 1]; |
| 19496 | if (prev_mir_op.* == .pseudo_dbg_line_stmt_line_column) | 20279 | if (prev_mir_op.* == .pseudo_dbg_line_line_column) |
| 19497 | prev_mir_op.* = .pseudo_dbg_line_line_column; | 20280 | prev_mir_op.* = .pseudo_dbg_line_stmt_line_column; |
| 19498 | } | 20281 | } |
| 19499 | try cg.asmOpOnly(.{ ._, .nop }); | 20282 | try cg.asmOpOnly(.{ ._, .nop }); |
| 19500 | }, | 20283 | }, |
| 19501 | .dbg_inline_block => if (use_old) try cg.airDbgInlineBlock(inst) else { | 20284 | .dbg_inline_block => { |
| 19502 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; | 20285 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| 19503 | const extra = cg.air.extraData(Air.DbgInlineBlock, ty_pl.payload); | 20286 | const extra = cg.air.extraData(Air.DbgInlineBlock, ty_pl.payload); |
| 19504 | const old_inline_func = cg.inline_func; | 20287 | const old_inline_func = cg.inline_func; |
| 19505 | defer cg.inline_func = old_inline_func; | 20288 | defer cg.inline_func = old_inline_func; |
| 19506 | cg.inline_func = extra.data.func; | 20289 | cg.inline_func = extra.data.func; |
| 19507 | _ = try cg.addInst(.{ | 20290 | if (cg.debug_output != .none) _ = try cg.addInst(.{ |
| 19508 | .tag = .pseudo, | 20291 | .tag = .pseudo, |
| 19509 | .ops = .pseudo_dbg_enter_inline_func, | 20292 | .ops = .pseudo_dbg_enter_inline_func, |
| 19510 | .data = .{ .func = extra.data.func }, | 20293 | .data = .{ .func = extra.data.func }, |
| 19511 | }); | 20294 | }); |
| 19512 | try cg.lowerBlock(inst, @ptrCast(cg.air.extra[extra.end..][0..extra.data.body_len])); | 20295 | try cg.lowerBlock(inst, @ptrCast(cg.air.extra[extra.end..][0..extra.data.body_len])); |
| 19513 | _ = try cg.addInst(.{ | 20296 | if (cg.debug_output != .none) _ = try cg.addInst(.{ |
| 19514 | .tag = .pseudo, | 20297 | .tag = .pseudo, |
| 19515 | .ops = .pseudo_dbg_leave_inline_func, | 20298 | .ops = .pseudo_dbg_leave_inline_func, |
| 19516 | .data = .{ .func = old_inline_func }, | 20299 | .data = .{ .func = old_inline_func }, |
| 19517 | }); | 20300 | }); |
| 19518 | }, | 20301 | }, |
| 19519 | .dbg_var_ptr, .dbg_var_val, .dbg_arg_inline => if (use_old) try cg.airDbgVar(inst) else { | 20302 | .dbg_var_ptr, .dbg_var_val, .dbg_arg_inline => if (use_old) try cg.airDbgVar(inst) else if (cg.debug_output != .none) { |
| 19520 | const pl_op = air_datas[@intFromEnum(inst)].pl_op; | 20303 | const pl_op = air_datas[@intFromEnum(inst)].pl_op; |
| 19521 | var ops = try cg.tempsFromOperands(inst, .{pl_op.operand}); | 20304 | var ops = try cg.tempsFromOperands(inst, .{pl_op.operand}); |
| | 20305 | var mcv = ops[0].tracking(cg).short; |
| | 20306 | switch (mcv) { |
| | 20307 | else => {}, |
| | 20308 | .eflags => |cc| switch (cc) { |
| | 20309 | else => {}, |
| | 20310 | // These values would self destruct. Maybe we make them use their |
| | 20311 | // turing complete dwarf expression interpreters for once? |
| | 20312 | .z_and_np, .nz_or_p => { |
| | 20313 | try cg.spillEflagsIfOccupied(); |
| | 20314 | mcv = ops[0].tracking(cg).short; |
| | 20315 | }, |
| | 20316 | }, |
| | 20317 | } |
| 19522 | try cg.genLocalDebugInfo(inst, ops[0].tracking(cg).short); | 20318 | try cg.genLocalDebugInfo(inst, ops[0].tracking(cg).short); |
| 19523 | try ops[0].die(cg); | 20319 | try ops[0].die(cg); |
| 19524 | }, | 20320 | }, |
| ... | @@ -20725,7 +21521,7 @@ fn airFptrunc(self: *CodeGen, inst: Air.Inst.Index) !void { | ... | @@ -20725,7 +21521,7 @@ fn airFptrunc(self: *CodeGen, inst: Air.Inst.Index) !void { |
| 20725 | .{ .v_, .cvtps2ph }, | 21521 | .{ .v_, .cvtps2ph }, |
| 20726 | dst_reg, | 21522 | dst_reg, |
| 20727 | mat_src_reg.to128(), | 21523 | mat_src_reg.to128(), |
| 20728 | .u(@as(u5, @bitCast(RoundMode{ .mode = .mxcsr }))), | 21524 | bits.RoundMode.imm(.{}), |
| 20729 | ); | 21525 | ); |
| 20730 | }, | 21526 | }, |
| 20731 | else => unreachable, | 21527 | else => unreachable, |
| ... | @@ -24896,26 +25692,7 @@ fn airFloatSign(self: *CodeGen, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void { | ... | @@ -24896,26 +25692,7 @@ fn airFloatSign(self: *CodeGen, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void { |
| 24896 | return self.floatSign(inst, tag, un_op, ty); | 25692 | return self.floatSign(inst, tag, un_op, ty); |
| 24897 | } | 25693 | } |
| 24898 | | 25694 | |
| 24899 | const RoundMode = packed struct(u5) { | 25695 | fn airRound(self: *CodeGen, inst: Air.Inst.Index, mode: bits.RoundMode) !void { |
| 24900 | mode: enum(u4) { | | |
| 24901 | /// Round to nearest (even) | | |
| 24902 | nearest = 0b0_00, | | |
| 24903 | /// Round down (toward -∞) | | |
| 24904 | down = 0b0_01, | | |
| 24905 | /// Round up (toward +∞) | | |
| 24906 | up = 0b0_10, | | |
| 24907 | /// Round toward zero (truncate) | | |
| 24908 | zero = 0b0_11, | | |
| 24909 | /// Use current rounding mode of MXCSR.RC | | |
| 24910 | mxcsr = 0b1_00, | | |
| 24911 | }, | | |
| 24912 | precision: enum(u1) { | | |
| 24913 | normal = 0b0, | | |
| 24914 | inexact = 0b1, | | |
| 24915 | } = .normal, | | |
| 24916 | }; | | |
| 24917 | | | |
| 24918 | fn airRound(self: *CodeGen, inst: Air.Inst.Index, mode: RoundMode) !void { | | |
| 24919 | const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; | 25696 | const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; |
| 24920 | const ty = self.typeOf(un_op); | 25697 | const ty = self.typeOf(un_op); |
| 24921 | | 25698 | |
| ... | @@ -24972,7 +25749,7 @@ fn getRoundTag(self: *CodeGen, ty: Type) ?Mir.Inst.FixedTag { | ... | @@ -24972,7 +25749,7 @@ fn getRoundTag(self: *CodeGen, ty: Type) ?Mir.Inst.FixedTag { |
| 24972 | } else null; | 25749 | } else null; |
| 24973 | } | 25750 | } |
| 24974 | | 25751 | |
| 24975 | fn genRoundLibcall(self: *CodeGen, ty: Type, src_mcv: MCValue, mode: RoundMode) !MCValue { | 25752 | fn genRoundLibcall(self: *CodeGen, ty: Type, src_mcv: MCValue, mode: bits.RoundMode) !MCValue { |
| 24976 | const pt = self.pt; | 25753 | const pt = self.pt; |
| 24977 | const zcu = pt.zcu; | 25754 | const zcu = pt.zcu; |
| 24978 | if (self.getRoundTag(ty)) |_| return .none; | 25755 | if (self.getRoundTag(ty)) |_| return .none; |
| ... | @@ -24997,7 +25774,7 @@ fn genRoundLibcall(self: *CodeGen, ty: Type, src_mcv: MCValue, mode: RoundMode) | ... | @@ -24997,7 +25774,7 @@ fn genRoundLibcall(self: *CodeGen, ty: Type, src_mcv: MCValue, mode: RoundMode) |
| 24997 | } }, &.{ty}, &.{src_mcv}, .{}); | 25774 | } }, &.{ty}, &.{src_mcv}, .{}); |
| 24998 | } | 25775 | } |
| 24999 | | 25776 | |
| 25000 | fn genRound(self: *CodeGen, ty: Type, dst_reg: Register, src_mcv: MCValue, mode: RoundMode) !void { | 25777 | fn genRound(self: *CodeGen, ty: Type, dst_reg: Register, src_mcv: MCValue, mode: bits.RoundMode) !void { |
| 25001 | const pt = self.pt; | 25778 | const pt = self.pt; |
| 25002 | const mir_tag = self.getRoundTag(ty) orelse { | 25779 | const mir_tag = self.getRoundTag(ty) orelse { |
| 25003 | const result = try self.genRoundLibcall(ty, src_mcv, mode); | 25780 | const result = try self.genRoundLibcall(ty, src_mcv, mode); |
| ... | @@ -25011,7 +25788,7 @@ fn genRound(self: *CodeGen, ty: Type, dst_reg: Register, src_mcv: MCValue, mode: | ... | @@ -25011,7 +25788,7 @@ fn genRound(self: *CodeGen, ty: Type, dst_reg: Register, src_mcv: MCValue, mode: |
| 25011 | dst_alias, | 25788 | dst_alias, |
| 25012 | dst_alias, | 25789 | dst_alias, |
| 25013 | try src_mcv.mem(self, .{ .size = .fromSize(abi_size) }), | 25790 | try src_mcv.mem(self, .{ .size = .fromSize(abi_size) }), |
| 25014 | .u(@as(u5, @bitCast(mode))), | 25791 | mode.imm(), |
| 25015 | ) else try self.asmRegisterRegisterRegisterImmediate( | 25792 | ) else try self.asmRegisterRegisterRegisterImmediate( |
| 25016 | mir_tag, | 25793 | mir_tag, |
| 25017 | dst_alias, | 25794 | dst_alias, |
| ... | @@ -25020,13 +25797,13 @@ fn genRound(self: *CodeGen, ty: Type, dst_reg: Register, src_mcv: MCValue, mode: | ... | @@ -25020,13 +25797,13 @@ fn genRound(self: *CodeGen, ty: Type, dst_reg: Register, src_mcv: MCValue, mode: |
| 25020 | src_mcv.getReg().? | 25797 | src_mcv.getReg().? |
| 25021 | else | 25798 | else |
| 25022 | try self.copyToTmpRegister(ty, src_mcv), abi_size), | 25799 | try self.copyToTmpRegister(ty, src_mcv), abi_size), |
| 25023 | .u(@as(u5, @bitCast(mode))), | 25800 | mode.imm(), |
| 25024 | ), | 25801 | ), |
| 25025 | else => if (src_mcv.isBase()) try self.asmRegisterMemoryImmediate( | 25802 | else => if (src_mcv.isBase()) try self.asmRegisterMemoryImmediate( |
| 25026 | mir_tag, | 25803 | mir_tag, |
| 25027 | dst_alias, | 25804 | dst_alias, |
| 25028 | try src_mcv.mem(self, .{ .size = .fromSize(abi_size) }), | 25805 | try src_mcv.mem(self, .{ .size = .fromSize(abi_size) }), |
| 25029 | .u(@as(u5, @bitCast(mode))), | 25806 | mode.imm(), |
| 25030 | ) else try self.asmRegisterRegisterImmediate( | 25807 | ) else try self.asmRegisterRegisterImmediate( |
| 25031 | mir_tag, | 25808 | mir_tag, |
| 25032 | dst_alias, | 25809 | dst_alias, |
| ... | @@ -25034,7 +25811,7 @@ fn genRound(self: *CodeGen, ty: Type, dst_reg: Register, src_mcv: MCValue, mode: | ... | @@ -25034,7 +25811,7 @@ fn genRound(self: *CodeGen, ty: Type, dst_reg: Register, src_mcv: MCValue, mode: |
| 25034 | src_mcv.getReg().? | 25811 | src_mcv.getReg().? |
| 25035 | else | 25812 | else |
| 25036 | try self.copyToTmpRegister(ty, src_mcv), abi_size), | 25813 | try self.copyToTmpRegister(ty, src_mcv), abi_size), |
| 25037 | .u(@as(u5, @bitCast(mode))), | 25814 | mode.imm(), |
| 25038 | ), | 25815 | ), |
| 25039 | } | 25816 | } |
| 25040 | } | 25817 | } |
| ... | @@ -25294,7 +26071,7 @@ fn airSqrt(self: *CodeGen, inst: Air.Inst.Index) !void { | ... | @@ -25294,7 +26071,7 @@ fn airSqrt(self: *CodeGen, inst: Air.Inst.Index) !void { |
| 25294 | .{ .v_, .cvtps2ph }, | 26071 | .{ .v_, .cvtps2ph }, |
| 25295 | dst_reg, | 26072 | dst_reg, |
| 25296 | dst_reg, | 26073 | dst_reg, |
| 25297 | .u(@as(u5, @bitCast(RoundMode{ .mode = .mxcsr }))), | 26074 | bits.RoundMode.imm(.{}), |
| 25298 | ); | 26075 | ); |
| 25299 | break :result dst_mcv; | 26076 | break :result dst_mcv; |
| 25300 | }, | 26077 | }, |
| ... | @@ -25324,7 +26101,7 @@ fn airSqrt(self: *CodeGen, inst: Air.Inst.Index) !void { | ... | @@ -25324,7 +26101,7 @@ fn airSqrt(self: *CodeGen, inst: Air.Inst.Index) !void { |
| 25324 | .{ .v_, .cvtps2ph }, | 26101 | .{ .v_, .cvtps2ph }, |
| 25325 | dst_reg, | 26102 | dst_reg, |
| 25326 | dst_reg, | 26103 | dst_reg, |
| 25327 | .u(@as(u5, @bitCast(RoundMode{ .mode = .mxcsr }))), | 26104 | bits.RoundMode.imm(.{}), |
| 25328 | ); | 26105 | ); |
| 25329 | break :result dst_mcv; | 26106 | break :result dst_mcv; |
| 25330 | }, | 26107 | }, |
| ... | @@ -25349,7 +26126,7 @@ fn airSqrt(self: *CodeGen, inst: Air.Inst.Index) !void { | ... | @@ -25349,7 +26126,7 @@ fn airSqrt(self: *CodeGen, inst: Air.Inst.Index) !void { |
| 25349 | .{ .v_, .cvtps2ph }, | 26126 | .{ .v_, .cvtps2ph }, |
| 25350 | dst_reg, | 26127 | dst_reg, |
| 25351 | wide_reg, | 26128 | wide_reg, |
| 25352 | .u(@as(u5, @bitCast(RoundMode{ .mode = .mxcsr }))), | 26129 | bits.RoundMode.imm(.{}), |
| 25353 | ); | 26130 | ); |
| 25354 | break :result dst_mcv; | 26131 | break :result dst_mcv; |
| 25355 | }, | 26132 | }, |
| ... | @@ -27613,7 +28390,7 @@ fn genBinOp( | ... | @@ -27613,7 +28390,7 @@ fn genBinOp( |
| 27613 | .{ .v_, .cvtps2ph }, | 28390 | .{ .v_, .cvtps2ph }, |
| 27614 | dst_reg, | 28391 | dst_reg, |
| 27615 | dst_reg, | 28392 | dst_reg, |
| 27616 | .u(@as(u5, @bitCast(RoundMode{ .mode = .mxcsr }))), | 28393 | bits.RoundMode.imm(.{}), |
| 27617 | ); | 28394 | ); |
| 27618 | break :adjusted .{ .register = dst_reg }; | 28395 | break :adjusted .{ .register = dst_reg }; |
| 27619 | }, | 28396 | }, |
| ... | @@ -28086,14 +28863,14 @@ fn genBinOp( | ... | @@ -28086,14 +28863,14 @@ fn genBinOp( |
| 28086 | dst_reg, | 28863 | dst_reg, |
| 28087 | dst_reg, | 28864 | dst_reg, |
| 28088 | dst_reg, | 28865 | dst_reg, |
| 28089 | .u(@as(u5, @bitCast(RoundMode{ | 28866 | bits.RoundMode.imm(.{ |
| 28090 | .mode = switch (air_tag) { | 28867 | .mode = switch (air_tag) { |
| 28091 | .div_trunc => .zero, | 28868 | .div_trunc => .zero, |
| 28092 | .div_floor => .down, | 28869 | .div_floor => .down, |
| 28093 | else => unreachable, | 28870 | else => unreachable, |
| 28094 | }, | 28871 | }, |
| 28095 | .precision = .inexact, | 28872 | .precision = .inexact, |
| 28096 | }))), | 28873 | }), |
| 28097 | ), | 28874 | ), |
| 28098 | else => {}, | 28875 | else => {}, |
| 28099 | } | 28876 | } |
| ... | @@ -28101,7 +28878,7 @@ fn genBinOp( | ... | @@ -28101,7 +28878,7 @@ fn genBinOp( |
| 28101 | .{ .v_, .cvtps2ph }, | 28878 | .{ .v_, .cvtps2ph }, |
| 28102 | dst_reg, | 28879 | dst_reg, |
| 28103 | dst_reg, | 28880 | dst_reg, |
| 28104 | .u(@as(u5, @bitCast(RoundMode{ .mode = .mxcsr }))), | 28881 | bits.RoundMode.imm(.{}), |
| 28105 | ); | 28882 | ); |
| 28106 | return dst_mcv; | 28883 | return dst_mcv; |
| 28107 | }, | 28884 | }, |
| ... | @@ -28529,7 +29306,7 @@ fn genBinOp( | ... | @@ -28529,7 +29306,7 @@ fn genBinOp( |
| 28529 | .{ .v_, .cvtps2ph }, | 29306 | .{ .v_, .cvtps2ph }, |
| 28530 | dst_reg, | 29307 | dst_reg, |
| 28531 | dst_reg, | 29308 | dst_reg, |
| 28532 | .u(@as(u5, @bitCast(RoundMode{ .mode = .mxcsr }))), | 29309 | bits.RoundMode.imm(.{}), |
| 28533 | ); | 29310 | ); |
| 28534 | return dst_mcv; | 29311 | return dst_mcv; |
| 28535 | }, | 29312 | }, |
| ... | @@ -28581,7 +29358,7 @@ fn genBinOp( | ... | @@ -28581,7 +29358,7 @@ fn genBinOp( |
| 28581 | .{ .v_, .cvtps2ph }, | 29358 | .{ .v_, .cvtps2ph }, |
| 28582 | dst_reg, | 29359 | dst_reg, |
| 28583 | dst_reg, | 29360 | dst_reg, |
| 28584 | .u(@as(u5, @bitCast(RoundMode{ .mode = .mxcsr }))), | 29361 | bits.RoundMode.imm(.{}), |
| 28585 | ); | 29362 | ); |
| 28586 | return dst_mcv; | 29363 | return dst_mcv; |
| 28587 | }, | 29364 | }, |
| ... | @@ -28624,7 +29401,7 @@ fn genBinOp( | ... | @@ -28624,7 +29401,7 @@ fn genBinOp( |
| 28624 | .{ .v_, .cvtps2ph }, | 29401 | .{ .v_, .cvtps2ph }, |
| 28625 | dst_reg, | 29402 | dst_reg, |
| 28626 | dst_reg, | 29403 | dst_reg, |
| 28627 | .u(@as(u5, @bitCast(RoundMode{ .mode = .mxcsr }))), | 29404 | bits.RoundMode.imm(.{}), |
| 28628 | ); | 29405 | ); |
| 28629 | return dst_mcv; | 29406 | return dst_mcv; |
| 28630 | }, | 29407 | }, |
| ... | @@ -28667,7 +29444,7 @@ fn genBinOp( | ... | @@ -28667,7 +29444,7 @@ fn genBinOp( |
| 28667 | .{ .v_, .cvtps2ph }, | 29444 | .{ .v_, .cvtps2ph }, |
| 28668 | dst_reg, | 29445 | dst_reg, |
| 28669 | dst_reg.to256(), | 29446 | dst_reg.to256(), |
| 28670 | .u(@as(u5, @bitCast(RoundMode{ .mode = .mxcsr }))), | 29447 | bits.RoundMode.imm(.{}), |
| 28671 | ); | 29448 | ); |
| 28672 | return dst_mcv; | 29449 | return dst_mcv; |
| 28673 | }, | 29450 | }, |
| ... | @@ -28932,7 +29709,7 @@ fn genBinOp( | ... | @@ -28932,7 +29709,7 @@ fn genBinOp( |
| 28932 | mask_reg, | 29709 | mask_reg, |
| 28933 | rhs_copy_reg, | 29710 | rhs_copy_reg, |
| 28934 | rhs_copy_reg, | 29711 | rhs_copy_reg, |
| 28935 | .u(3), // unord | 29712 | bits.VexFloatPredicate.imm(.unord), |
| 28936 | ); | 29713 | ); |
| 28937 | try self.asmRegisterRegisterRegisterRegister( | 29714 | try self.asmRegisterRegisterRegisterRegister( |
| 28938 | @as(?Mir.Inst.FixedTag, switch (lhs_ty.zigTypeTag(zcu)) { | 29715 | @as(?Mir.Inst.FixedTag, switch (lhs_ty.zigTypeTag(zcu)) { |
| ... | @@ -28999,7 +29776,7 @@ fn genBinOp( | ... | @@ -28999,7 +29776,7 @@ fn genBinOp( |
| 28999 | }), | 29776 | }), |
| 29000 | mask_reg, | 29777 | mask_reg, |
| 29001 | mask_reg, | 29778 | mask_reg, |
| 29002 | .u(if (has_blend) 3 else 7), // unord, ord | 29779 | bits.SseFloatPredicate.imm(if (has_blend) .unord else .ord), |
| 29003 | ); | 29780 | ); |
| 29004 | if (has_blend) try self.asmRegisterRegisterRegister( | 29781 | if (has_blend) try self.asmRegisterRegisterRegister( |
| 29005 | @as(?Mir.Inst.FixedTag, switch (lhs_ty.zigTypeTag(zcu)) { | 29782 | @as(?Mir.Inst.FixedTag, switch (lhs_ty.zigTypeTag(zcu)) { |
| ... | @@ -29836,24 +30613,10 @@ fn airArg(self: *CodeGen, inst: Air.Inst.Index) !void { | ... | @@ -29836,24 +30613,10 @@ fn airArg(self: *CodeGen, inst: Air.Inst.Index) !void { |
| 29836 | return self.finishAir(inst, result, .{ .none, .none, .none }); | 30613 | return self.finishAir(inst, result, .{ .none, .none, .none }); |
| 29837 | } | 30614 | } |
| 29838 | | 30615 | |
| 29839 | fn airDbgArg(self: *CodeGen, inst: Air.Inst.Index) !void { | | |
| 29840 | // skip zero-bit arguments as they don't have a corresponding arg instruction | | |
| 29841 | var arg_index = self.arg_index; | | |
| 29842 | while (self.args[arg_index] == .none) arg_index += 1; | | |
| 29843 | self.arg_index = arg_index + 1; | | |
| 29844 | | | |
| 29845 | if (self.debug_output != .none) { | | |
| 29846 | const name = self.air.instructions.items(.data)[@intFromEnum(inst)].arg.name; | | |
| 29847 | if (name != .none) try self.genLocalDebugInfo(inst, self.getResolvedInstValue(inst).short); | | |
| 29848 | if (self.liveness.isUnused(inst)) try self.processDeath(inst); | | |
| 29849 | } | | |
| 29850 | for (self.args[self.arg_index..]) |arg| { | | |
| 29851 | if (arg != .none) break; | | |
| 29852 | } else try self.airDbgVarArgs(); | | |
| 29853 | } | | |
| 29854 | | | |
| 29855 | fn airDbgVarArgs(self: *CodeGen) !void { | 30616 | fn airDbgVarArgs(self: *CodeGen) !void { |
| 29856 | if (self.pt.zcu.typeToFunc(self.fn_type).?.is_var_args) try self.asmPseudo(.pseudo_dbg_var_args_none); | 30617 | if (self.debug_output == .none) return; |
| | 30618 | if (!self.pt.zcu.typeToFunc(self.fn_type).?.is_var_args) return; |
| | 30619 | try self.asmPseudo(.pseudo_dbg_var_args_none); |
| 29857 | } | 30620 | } |
| 29858 | | 30621 | |
| 29859 | fn genLocalDebugInfo( | 30622 | fn genLocalDebugInfo( |
| ... | @@ -30909,44 +31672,6 @@ fn genTry( | ... | @@ -30909,44 +31672,6 @@ fn genTry( |
| 30909 | return result; | 31672 | return result; |
| 30910 | } | 31673 | } |
| 30911 | | 31674 | |
| 30912 | fn airDbgStmt(self: *CodeGen, inst: Air.Inst.Index) !void { | | |
| 30913 | const dbg_stmt = self.air.instructions.items(.data)[@intFromEnum(inst)].dbg_stmt; | | |
| 30914 | _ = try self.addInst(.{ | | |
| 30915 | .tag = .pseudo, | | |
| 30916 | .ops = .pseudo_dbg_line_stmt_line_column, | | |
| 30917 | .data = .{ .line_column = .{ | | |
| 30918 | .line = dbg_stmt.line, | | |
| 30919 | .column = dbg_stmt.column, | | |
| 30920 | } }, | | |
| 30921 | }); | | |
| 30922 | } | | |
| 30923 | | | |
| 30924 | fn airDbgEmptyStmt(self: *CodeGen) !void { | | |
| 30925 | if (self.mir_instructions.len > 0 and | | |
| 30926 | self.mir_instructions.items(.ops)[self.mir_instructions.len - 1] == .pseudo_dbg_line_stmt_line_column) | | |
| 30927 | self.mir_instructions.items(.ops)[self.mir_instructions.len - 1] = .pseudo_dbg_line_line_column; | | |
| 30928 | try self.asmOpOnly(.{ ._, .nop }); | | |
| 30929 | } | | |
| 30930 | | | |
| 30931 | fn airDbgInlineBlock(self: *CodeGen, inst: Air.Inst.Index) !void { | | |
| 30932 | const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; | | |
| 30933 | const extra = self.air.extraData(Air.DbgInlineBlock, ty_pl.payload); | | |
| 30934 | const old_inline_func = self.inline_func; | | |
| 30935 | defer self.inline_func = old_inline_func; | | |
| 30936 | self.inline_func = extra.data.func; | | |
| 30937 | _ = try self.addInst(.{ | | |
| 30938 | .tag = .pseudo, | | |
| 30939 | .ops = .pseudo_dbg_enter_inline_func, | | |
| 30940 | .data = .{ .func = extra.data.func }, | | |
| 30941 | }); | | |
| 30942 | try self.lowerBlock(inst, @ptrCast(self.air.extra[extra.end..][0..extra.data.body_len])); | | |
| 30943 | _ = try self.addInst(.{ | | |
| 30944 | .tag = .pseudo, | | |
| 30945 | .ops = .pseudo_dbg_leave_inline_func, | | |
| 30946 | .data = .{ .func = old_inline_func }, | | |
| 30947 | }); | | |
| 30948 | } | | |
| 30949 | | | |
| 30950 | fn airDbgVar(self: *CodeGen, inst: Air.Inst.Index) !void { | 31675 | fn airDbgVar(self: *CodeGen, inst: Air.Inst.Index) !void { |
| 30951 | const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; | 31676 | const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; |
| 30952 | try self.genLocalDebugInfo(inst, try self.resolveInst(pl_op.operand)); | 31677 | try self.genLocalDebugInfo(inst, try self.resolveInst(pl_op.operand)); |
| ... | @@ -31392,14 +32117,6 @@ fn airLoop(self: *CodeGen, inst: Air.Inst.Index) !void { | ... | @@ -31392,14 +32117,6 @@ fn airLoop(self: *CodeGen, inst: Air.Inst.Index) !void { |
| 31392 | try self.genBodyBlock(body); | 32117 | try self.genBodyBlock(body); |
| 31393 | } | 32118 | } |
| 31394 | | 32119 | |
| 31395 | fn airBlock(self: *CodeGen, inst: Air.Inst.Index) !void { | | |
| 31396 | const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; | | |
| 31397 | const extra = self.air.extraData(Air.Block, ty_pl.payload); | | |
| 31398 | try self.asmPseudo(.pseudo_dbg_enter_block_none); | | |
| 31399 | try self.lowerBlock(inst, @ptrCast(self.air.extra[extra.end..][0..extra.data.body_len])); | | |
| 31400 | try self.asmPseudo(.pseudo_dbg_leave_block_none); | | |
| 31401 | } | | |
| 31402 | | | |
| 31403 | fn lowerBlock(self: *CodeGen, inst: Air.Inst.Index, body: []const Air.Inst.Index) !void { | 32120 | fn lowerBlock(self: *CodeGen, inst: Air.Inst.Index, body: []const Air.Inst.Index) !void { |
| 31404 | // A block is a setup to be able to jump to the end. | 32121 | // A block is a setup to be able to jump to the end. |
| 31405 | const inst_tracking_i = self.inst_tracking.count(); | 32122 | const inst_tracking_i = self.inst_tracking.count(); |
| ... | @@ -39918,46 +40635,46 @@ const Select = struct { | ... | @@ -39918,46 +40635,46 @@ const Select = struct { |
| 39918 | inline .rc_mask, .mut_rc_mask, .ref_mask => |mask| temp.asMask(mask.info, s.cg), | 40635 | inline .rc_mask, .mut_rc_mask, .ref_mask => |mask| temp.asMask(mask.info, s.cg), |
| 39919 | } | 40636 | } |
| 39920 | } | 40637 | } |
| 39921 | }; | | |
| 39922 | | 40638 | |
| 39923 | fn pass(spec: TempSpec) u2 { | 40639 | fn pass(kind: Kind) u2 { |
| 39924 | return switch (spec.kind) { | 40640 | return switch (kind) { |
| 39925 | .unused => 0, | 40641 | .unused => 0, |
| 39926 | .reg => 1, | 40642 | .reg => 1, |
| 39927 | else => 2, | 40643 | else => 2, |
| 39928 | }; | 40644 | }; |
| 39929 | } | 40645 | } |
| | 40646 | }; |
| 39930 | | 40647 | |
| 39931 | fn create(spec: TempSpec, s: *Select) !Temp { | 40648 | fn create(spec: TempSpec, s: *Select) !struct { Temp, bool } { |
| 39932 | const cg = s.cg; | 40649 | const cg = s.cg; |
| 39933 | return switch (spec.kind) { | 40650 | return switch (spec.kind) { |
| 39934 | .unused => unreachable, | 40651 | .unused => unreachable, |
| 39935 | .any => try cg.tempAlloc(spec.type), | 40652 | .any => .{ try cg.tempAlloc(spec.type), true }, |
| 39936 | .cc => |cc| try cg.tempInit(spec.type, .{ .eflags = cc }), | 40653 | .cc => |cc| .{ try cg.tempInit(spec.type, .{ .eflags = cc }), true }, |
| 39937 | .ref => |ref| ref.deref(s), | 40654 | .ref => |ref| .{ ref.deref(s), false }, |
| 39938 | .reg => |reg| try cg.tempInit(spec.type, .{ .register = reg }), | 40655 | .reg => |reg| .{ try cg.tempInit(spec.type, .{ .register = reg }), true }, |
| 39939 | .rc => |rc| try cg.tempAllocReg(spec.type, regSetForRegClass(rc)), | 40656 | .rc => |rc| .{ try cg.tempAllocReg(spec.type, regSetForRegClass(rc)), true }, |
| 39940 | .mut_rc => |ref_rc| { | 40657 | .mut_rc => |ref_rc| { |
| 39941 | const temp = ref_rc.ref.deref(s); | 40658 | const temp = ref_rc.ref.deref(s); |
| 39942 | if (temp.isMut(cg)) switch (temp.tracking(cg).short) { | 40659 | if (temp.isMut(cg)) switch (temp.tracking(cg).short) { |
| 39943 | .register => |reg| if (reg.class() == ref_rc.rc) return temp, | 40660 | .register => |reg| if (reg.class() == ref_rc.rc) return .{ temp, false }, |
| 39944 | .register_offset => |reg_off| if (reg_off.off == 0 and reg_off.reg.class() == ref_rc.rc) return temp, | 40661 | .register_offset => |reg_off| if (reg_off.off == 0 and reg_off.reg.class() == ref_rc.rc) return .{ temp, false }, |
| 39945 | else => {}, | 40662 | else => {}, |
| 39946 | }; | 40663 | }; |
| 39947 | return try cg.tempAllocReg(spec.type, regSetForRegClass(ref_rc.rc)); | 40664 | return .{ try cg.tempAllocReg(spec.type, regSetForRegClass(ref_rc.rc)), true }; |
| 39948 | }, | 40665 | }, |
| 39949 | .ref_mask => |ref_mask| ref_mask.ref.deref(s), | 40666 | .ref_mask => |ref_mask| .{ ref_mask.ref.deref(s), false }, |
| 39950 | .rc_mask => |rc_mask| try cg.tempAllocReg(spec.type, regSetForRegClass(rc_mask.rc)), | 40667 | .rc_mask => |rc_mask| .{ try cg.tempAllocReg(spec.type, regSetForRegClass(rc_mask.rc)), true }, |
| 39951 | .mut_rc_mask => |ref_rc_mask| { | 40668 | .mut_rc_mask => |ref_rc_mask| { |
| 39952 | const temp = ref_rc_mask.ref.deref(s); | 40669 | const temp = ref_rc_mask.ref.deref(s); |
| 39953 | if (temp.isMut(cg)) switch (temp.tracking(cg).short) { | 40670 | if (temp.isMut(cg)) switch (temp.tracking(cg).short) { |
| 39954 | .register => |reg| if (reg.class() == ref_rc_mask.rc) return temp, | 40671 | .register => |reg| if (reg.class() == ref_rc_mask.rc) return .{ temp, false }, |
| 39955 | .register_offset => |reg_off| if (reg_off.off == 0 and reg_off.reg.class() == ref_rc_mask.rc) return temp, | 40672 | .register_offset => |reg_off| if (reg_off.off == 0 and reg_off.reg.class() == ref_rc_mask.rc) return .{ temp, false }, |
| 39956 | else => {}, | 40673 | else => {}, |
| 39957 | }; | 40674 | }; |
| 39958 | return try cg.tempAllocReg(spec.type, regSetForRegClass(ref_rc_mask.rc)); | 40675 | return .{ try cg.tempAllocReg(spec.type, regSetForRegClass(ref_rc_mask.rc)), true }; |
| 39959 | }, | 40676 | }, |
| 39960 | .mem => try cg.tempAllocMem(spec.type), | 40677 | .mem => .{ try cg.tempAllocMem(spec.type), true }, |
| 39961 | .smin_mem, .smax_mem, .umin_mem, .umax_mem => |const_info| { | 40678 | .smin_mem, .smax_mem, .umin_mem, .umax_mem => |const_info| { |
| 39962 | const pt = cg.pt; | 40679 | const pt = cg.pt; |
| 39963 | const zcu = pt.zcu; | 40680 | const zcu = pt.zcu; |
| ... | @@ -40022,13 +40739,16 @@ const Select = struct { | ... | @@ -40022,13 +40739,16 @@ const Select = struct { |
| 40022 | })).toIntern(), | 40739 | })).toIntern(), |
| 40023 | .storage = .{ .repeated_elem = res_scalar_val.toIntern() }, | 40740 | .storage = .{ .repeated_elem = res_scalar_val.toIntern() }, |
| 40024 | } })) else res_scalar_val; | 40741 | } })) else res_scalar_val; |
| 40025 | return try cg.tempMemFromValue(res_val); | 40742 | return .{ try cg.tempMemFromValue(res_val), true }; |
| 40026 | }, | 40743 | }, |
| 40027 | .symbol => |symbol| if (cg.bin_file.cast(.elf)) |elf_file| try cg.tempInit(spec.type, .{ .lea_symbol = .{ | 40744 | .symbol => |symbol| .{ try cg.tempInit(spec.type, .{ .lea_symbol = .{ |
| 40028 | .sym_index = try elf_file.getGlobalSymbol(symbol.name, symbol.lib), | 40745 | .sym_index = if (cg.bin_file.cast(.elf)) |elf_file| |
| 40029 | } }) else if (cg.bin_file.cast(.macho)) |macho_file| try cg.tempInit(spec.type, .{ .lea_symbol = .{ | 40746 | try elf_file.getGlobalSymbol(symbol.name, symbol.lib) |
| 40030 | .sym_index = try macho_file.getGlobalSymbol(symbol.name, symbol.lib), | 40747 | else if (cg.bin_file.cast(.macho)) |macho_file| |
| 40031 | } }) else cg.fail("external symbols unimplemented for {s}", .{@tagName(cg.bin_file.tag)}), | 40748 | try macho_file.getGlobalSymbol(symbol.name, symbol.lib) |
| | 40749 | else |
| | 40750 | return cg.fail("external symbols unimplemented for {s}", .{@tagName(cg.bin_file.tag)}), |
| | 40751 | } }), true }, |
| 40032 | }; | 40752 | }; |
| 40033 | } | 40753 | } |
| 40034 | }; | 40754 | }; |
| ... | @@ -40390,14 +41110,24 @@ const Select = struct { | ... | @@ -40390,14 +41110,24 @@ const Select = struct { |
| 40390 | fn sia(imm: i32, base: Ref.Sized, adjust: Adjust) Select.Operand { | 41110 | fn sia(imm: i32, base: Ref.Sized, adjust: Adjust) Select.Operand { |
| 40391 | return .{ .tag = .simm, .base = base, .adjust = adjust, .imm = imm }; | 41111 | return .{ .tag = .simm, .base = base, .adjust = adjust, .imm = imm }; |
| 40392 | } | 41112 | } |
| 40393 | fn ui(imm: i32) Select.Operand { | 41113 | fn ui(imm: u32) Select.Operand { |
| 40394 | return .{ .tag = .uimm, .imm = imm }; | 41114 | return .{ .tag = .uimm, .imm = @bitCast(imm) }; |
| 40395 | } | 41115 | } |
| 40396 | fn ua(base: Ref.Sized, adjust: Adjust) Select.Operand { | 41116 | fn ua(base: Ref.Sized, adjust: Adjust) Select.Operand { |
| 40397 | return .{ .tag = .uimm, .base = base, .adjust = adjust }; | 41117 | return .{ .tag = .uimm, .base = base, .adjust = adjust }; |
| 40398 | } | 41118 | } |
| 40399 | fn uia(imm: i32, base: Ref.Sized, adjust: Adjust) Select.Operand { | 41119 | fn uia(imm: u32, base: Ref.Sized, adjust: Adjust) Select.Operand { |
| 40400 | return .{ .tag = .uimm, .base = base, .adjust = adjust, .imm = imm }; | 41120 | return .{ .tag = .uimm, .base = base, .adjust = adjust, .imm = @bitCast(imm) }; |
| | 41121 | } |
| | 41122 | |
| | 41123 | fn rm(mode: bits.RoundMode) Select.Operand { |
| | 41124 | return .{ .tag = .uimm, .imm = @intCast(mode.imm().unsigned) }; |
| | 41125 | } |
| | 41126 | fn sp(pred: bits.SseFloatPredicate) Select.Operand { |
| | 41127 | return .{ .tag = .uimm, .imm = @intCast(pred.imm().unsigned) }; |
| | 41128 | } |
| | 41129 | fn vp(pred: bits.VexFloatPredicate) Select.Operand { |
| | 41130 | return .{ .tag = .uimm, .imm = @intCast(pred.imm().unsigned) }; |
| 40401 | } | 41131 | } |
| 40402 | | 41132 | |
| 40403 | fn lea(size: Memory.Size, base: Ref) Select.Operand { | 41133 | fn lea(size: Memory.Size, base: Ref) Select.Operand { |
| ... | @@ -40705,6 +41435,7 @@ fn select( | ... | @@ -40705,6 +41435,7 @@ fn select( |
| 40705 | .ccc => cg.target.cCallingConvention().?, | 41435 | .ccc => cg.target.cCallingConvention().?, |
| 40706 | .zigcc => .auto, | 41436 | .zigcc => .auto, |
| 40707 | }; | 41437 | }; |
| | 41438 | assert(case.clobbers.eflags); |
| 40708 | const err_ret_trace_reg = if (cc == .auto and cg.pt.zcu.comp.config.any_error_tracing) err_ret_trace_reg: { | 41439 | const err_ret_trace_reg = if (cc == .auto and cg.pt.zcu.comp.config.any_error_tracing) err_ret_trace_reg: { |
| 40709 | const param_gpr = abi.getCAbiIntParamRegs(.auto); | 41440 | const param_gpr = abi.getCAbiIntParamRegs(.auto); |
| 40710 | break :err_ret_trace_reg param_gpr[param_gpr.len - 1]; | 41441 | break :err_ret_trace_reg param_gpr[param_gpr.len - 1]; |
| ... | @@ -40722,8 +41453,14 @@ fn select( | ... | @@ -40722,8 +41453,14 @@ fn select( |
| 40722 | | 41453 | |
| 40723 | @memcpy(src_slots[0..src_temps.len], src_temps); | 41454 | @memcpy(src_slots[0..src_temps.len], src_temps); |
| 40724 | std.mem.swap(Temp, &src_slots[pattern.commute[0]], &src_slots[pattern.commute[1]]); | 41455 | std.mem.swap(Temp, &src_slots[pattern.commute[0]], &src_slots[pattern.commute[1]]); |
| 40725 | for (1..3) |pass| for (tmp_slots, case.extra_temps) |*slot, spec| if (pass == spec.pass()) { | 41456 | for (dst_temps, dst_tys, case.dst_temps[0..dst_temps.len]) |*dst_temp, dst_ty, dst_kind| { |
| 40726 | slot.* = try spec.create(&s); | 41457 | if (dst_kind.pass() != 1) continue; |
| | 41458 | dst_temp.*, _ = try Select.TempSpec.create(.{ .type = dst_ty, .kind = dst_kind }, &s); |
| | 41459 | } |
| | 41460 | var tmp_owned: [tmp_slots.len]bool = @splat(false); |
| | 41461 | for (1..3) |pass| for (tmp_slots, &tmp_owned, case.extra_temps) |*slot, *owned, spec| { |
| | 41462 | if (spec.kind.pass() != pass) continue; |
| | 41463 | slot.*, owned.* = try spec.create(&s); |
| 40727 | }; | 41464 | }; |
| 40728 | | 41465 | |
| 40729 | while (true) for (pattern.src[0..src_temps.len], src_temps) |src_pattern, *src_temp| { | 41466 | while (true) for (pattern.src[0..src_temps.len], src_temps) |src_pattern, *src_temp| { |
| ... | @@ -40734,8 +41471,10 @@ fn select( | ... | @@ -40734,8 +41471,10 @@ fn select( |
| 40734 | | 41471 | |
| 40735 | if (case.clobbers.eflags) try cg.spillEflagsIfOccupied(); | 41472 | if (case.clobbers.eflags) try cg.spillEflagsIfOccupied(); |
| 40736 | | 41473 | |
| 40737 | for (dst_temps, dst_tys, case.dst_temps[0..dst_temps.len]) |*dst_temp, dst_ty, dst_kind| | 41474 | for (dst_temps, dst_tys, case.dst_temps[0..dst_temps.len]) |*dst_temp, dst_ty, dst_kind| { |
| 40738 | dst_temp.* = (try Select.TempSpec.create(.{ .type = dst_ty, .kind = dst_kind }, &s)); | 41475 | if (dst_kind.pass() != 2) continue; |
| | 41476 | dst_temp.*, _ = try Select.TempSpec.create(.{ .type = dst_ty, .kind = dst_kind }, &s); |
| | 41477 | } |
| 40739 | @memcpy(dst_slots[0..dst_temps.len], dst_temps); | 41478 | @memcpy(dst_slots[0..dst_temps.len], dst_temps); |
| 40740 | | 41479 | |
| 40741 | switch (case.each) { | 41480 | switch (case.each) { |
| ... | @@ -40765,7 +41504,7 @@ fn select( | ... | @@ -40765,7 +41504,7 @@ fn select( |
| 40765 | } | 41504 | } |
| 40766 | } | 41505 | } |
| 40767 | for (dst_temps, case.dst_temps[0..dst_temps.len]) |dst_temp, dst_kind| dst_kind.finish(dst_temp, &s); | 41506 | for (dst_temps, case.dst_temps[0..dst_temps.len]) |dst_temp, dst_kind| dst_kind.finish(dst_temp, &s); |
| 40768 | for (case.extra_temps, tmp_slots) |spec, temp| if (spec.kind != .unused) try temp.die(cg); | 41507 | for (tmp_owned, tmp_slots) |owned, temp| if (owned) try temp.die(cg); |
| 40769 | return; | 41508 | return; |
| 40770 | } | 41509 | } |
| 40771 | } | 41510 | } |
Jacob Young <jacobly@ziglang.org> 2025-01-25 15:06:35-05:00
lib