| ... | @@ -1390,7 +1390,7 @@ fn asmOps(self: *CodeGen, tag: Mir.Inst.FixedTag, ops: [4]Operand) !void { | ... | @@ -1390,7 +1390,7 @@ fn asmOps(self: *CodeGen, tag: Mir.Inst.FixedTag, ops: [4]Operand) !void { |
| 1390 | | 1390 | |
| 1391 | /// A `cc` of `.z_and_np` clobbers `reg2`! | 1391 | /// A `cc` of `.z_and_np` clobbers `reg2`! |
| 1392 | fn asmCmovccRegisterRegister(self: *CodeGen, cc: Condition, reg1: Register, reg2: Register) !void { | 1392 | fn asmCmovccRegisterRegister(self: *CodeGen, cc: Condition, reg1: Register, reg2: Register) !void { |
| 1393 | _ = try self.addInst(.{ | 1393 | if (self.hasFeature(.cmov)) _ = try self.addInst(.{ |
| 1394 | .tag = switch (cc) { | 1394 | .tag = switch (cc) { |
| 1395 | else => .cmov, | 1395 | else => .cmov, |
| 1396 | .z_and_np, .nz_or_p => .pseudo, | 1396 | .z_and_np, .nz_or_p => .pseudo, |
| ... | @@ -1408,12 +1408,16 @@ fn asmCmovccRegisterRegister(self: *CodeGen, cc: Condition, reg1: Register, reg2 | ... | @@ -1408,12 +1408,16 @@ fn asmCmovccRegisterRegister(self: *CodeGen, cc: Condition, reg1: Register, reg2 |
| 1408 | .r1 = reg1, | 1408 | .r1 = reg1, |
| 1409 | .r2 = reg2, | 1409 | .r2 = reg2, |
| 1410 | } }, | 1410 | } }, |
| 1411 | }); | 1411 | }) else { |
| | 1412 | const reloc = try self.asmJccReloc(cc.negate(), undefined); |
| | 1413 | try self.asmRegisterRegister(.{ ._, .mov }, reg1, reg2); |
| | 1414 | self.performReloc(reloc); |
| | 1415 | } |
| 1412 | } | 1416 | } |
| 1413 | | 1417 | |
| 1414 | /// A `cc` of `.z_and_np` is not supported by this encoding! | 1418 | /// A `cc` of `.z_and_np` is not supported by this encoding! |
| 1415 | fn asmCmovccRegisterMemory(self: *CodeGen, cc: Condition, reg: Register, m: Memory) !void { | 1419 | fn asmCmovccRegisterMemory(self: *CodeGen, cc: Condition, reg: Register, m: Memory) !void { |
| 1416 | _ = try self.addInst(.{ | 1420 | if (self.hasFeature(.cmov)) _ = try self.addInst(.{ |
| 1417 | .tag = switch (cc) { | 1421 | .tag = switch (cc) { |
| 1418 | else => .cmov, | 1422 | else => .cmov, |
| 1419 | .z_and_np => unreachable, | 1423 | .z_and_np => unreachable, |
| ... | @@ -1433,7 +1437,11 @@ fn asmCmovccRegisterMemory(self: *CodeGen, cc: Condition, reg: Register, m: Memo | ... | @@ -1433,7 +1437,11 @@ fn asmCmovccRegisterMemory(self: *CodeGen, cc: Condition, reg: Register, m: Memo |
| 1433 | .r1 = reg, | 1437 | .r1 = reg, |
| 1434 | .payload = try self.addExtra(Mir.Memory.encode(m)), | 1438 | .payload = try self.addExtra(Mir.Memory.encode(m)), |
| 1435 | } }, | 1439 | } }, |
| 1436 | }); | 1440 | }) else { |
| | 1441 | const reloc = try self.asmJccReloc(cc.negate(), undefined); |
| | 1442 | try self.asmRegisterMemory(.{ ._, .mov }, reg, m); |
| | 1443 | self.performReloc(reloc); |
| | 1444 | } |
| 1437 | } | 1445 | } |
| 1438 | | 1446 | |
| 1439 | fn asmSetccRegister(self: *CodeGen, cc: Condition, reg: Register) !void { | 1447 | fn asmSetccRegister(self: *CodeGen, cc: Condition, reg: Register) !void { |
| ... | @@ -2319,6 +2327,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2319,6 +2327,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2319 | } | 2327 | } |
| 2320 | | 2328 | |
| 2321 | fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | 2329 | fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| | 2330 | @setEvalBranchQuota(1_600); |
| 2322 | const pt = cg.pt; | 2331 | const pt = cg.pt; |
| 2323 | const zcu = pt.zcu; | 2332 | const zcu = pt.zcu; |
| 2324 | const ip = &zcu.intern_pool; | 2333 | const ip = &zcu.intern_pool; |
| ... | @@ -2354,9 +2363,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2354,9 +2363,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2354 | try cg.inst_tracking.ensureUnusedCapacity(cg.gpa, 1); | 2363 | try cg.inst_tracking.ensureUnusedCapacity(cg.gpa, 1); |
| 2355 | switch (air_tags[@intFromEnum(inst)]) { | 2364 | switch (air_tags[@intFromEnum(inst)]) { |
| 2356 | // zig fmt: off | 2365 | // zig fmt: off |
| 2357 | .not, | | |
| 2358 | => |air_tag| try cg.airUnOp(inst, air_tag), | | |
| 2359 | | | |
| 2360 | .add, | 2366 | .add, |
| 2361 | .add_wrap, | 2367 | .add_wrap, |
| 2362 | .sub, | 2368 | .sub, |
| ... | @@ -2434,7 +2440,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2434,7 +2440,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2434 | .memset_safe => try cg.airMemset(inst, true), | 2440 | .memset_safe => try cg.airMemset(inst, true), |
| 2435 | .set_union_tag => try cg.airSetUnionTag(inst), | 2441 | .set_union_tag => try cg.airSetUnionTag(inst), |
| 2436 | .get_union_tag => try cg.airGetUnionTag(inst), | 2442 | .get_union_tag => try cg.airGetUnionTag(inst), |
| 2437 | .clz => try cg.airClz(inst), | | |
| 2438 | .ctz => try cg.airCtz(inst), | 2443 | .ctz => try cg.airCtz(inst), |
| 2439 | .popcount => try cg.airPopCount(inst), | 2444 | .popcount => try cg.airPopCount(inst), |
| 2440 | .byte_swap => try cg.airByteSwap(inst), | 2445 | .byte_swap => try cg.airByteSwap(inst), |
| ... | @@ -2525,146 +2530,156 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2525,146 +2530,156 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2525 | })) { | 2530 | })) { |
| 2526 | else => unreachable, | 2531 | else => unreachable, |
| 2527 | inline .@"and", .@"or", .xor => |mir_tag| comptime &.{ .{ | 2532 | inline .@"and", .@"or", .xor => |mir_tag| comptime &.{ .{ |
| 2528 | .required_features = .{ .avx2, null }, | 2533 | .required_features = .{ .avx2, null, null, null }, |
| | 2534 | .src_constraints = .{ .{ .int_or_vec = .yword }, .{ .int_or_vec = .yword } }, |
| 2529 | .patterns = &.{ | 2535 | .patterns = &.{ |
| 2530 | .{ .src = .{ .ymm, .mem } }, | 2536 | .{ .src = .{ .to_ymm, .mem } }, |
| 2531 | .{ .src = .{ .mem, .ymm }, .commute = .{ 0, 1 } }, | 2537 | .{ .src = .{ .mem, .to_ymm }, .commute = .{ 0, 1 } }, |
| 2532 | .{ .src = .{ .ymm, .ymm } }, | 2538 | .{ .src = .{ .to_ymm, .to_ymm } }, |
| 2533 | }, | 2539 | }, |
| 2534 | .dst_temps = .{.{ .rc = .sse }}, | 2540 | .dst_temps = .{.{ .rc = .sse }}, |
| 2535 | .each = .{ .once = &.{ | 2541 | .each = .{ .once = &.{ |
| 2536 | .{ ._, .vp_, mir_tag, .dst0y, .src0y, .src1y, ._ }, | 2542 | .{ ._, .vp_, mir_tag, .dst0y, .src0y, .src1y, ._ }, |
| 2537 | } }, | 2543 | } }, |
| 2538 | }, .{ | 2544 | }, .{ |
| 2539 | .required_features = .{ .avx, null }, | 2545 | .required_features = .{ .avx, null, null, null }, |
| | 2546 | .src_constraints = .{ .{ .int_or_vec = .yword }, .{ .int_or_vec = .yword } }, |
| 2540 | .patterns = &.{ | 2547 | .patterns = &.{ |
| 2541 | .{ .src = .{ .ymm, .mem } }, | 2548 | .{ .src = .{ .to_ymm, .mem } }, |
| 2542 | .{ .src = .{ .mem, .ymm }, .commute = .{ 0, 1 } }, | 2549 | .{ .src = .{ .mem, .to_ymm }, .commute = .{ 0, 1 } }, |
| 2543 | .{ .src = .{ .ymm, .ymm } }, | 2550 | .{ .src = .{ .to_ymm, .to_ymm } }, |
| 2544 | }, | 2551 | }, |
| 2545 | .dst_temps = .{.{ .rc = .sse }}, | 2552 | .dst_temps = .{.{ .rc = .sse }}, |
| 2546 | .each = .{ .once = &.{ | 2553 | .each = .{ .once = &.{ |
| 2547 | .{ ._, .v_pd, mir_tag, .dst0y, .src0y, .src1y, ._ }, | 2554 | .{ ._, .v_pd, mir_tag, .dst0y, .src0y, .src1y, ._ }, |
| 2548 | } }, | 2555 | } }, |
| 2549 | }, .{ | 2556 | }, .{ |
| 2550 | .required_features = .{ .avx, null }, | 2557 | .required_features = .{ .avx, null, null, null }, |
| | 2558 | .src_constraints = .{ .{ .int_or_vec = .xword }, .{ .int_or_vec = .xword } }, |
| 2551 | .patterns = &.{ | 2559 | .patterns = &.{ |
| 2552 | .{ .src = .{ .xmm, .mem } }, | 2560 | .{ .src = .{ .to_xmm, .mem } }, |
| 2553 | .{ .src = .{ .mem, .xmm }, .commute = .{ 0, 1 } }, | 2561 | .{ .src = .{ .mem, .to_xmm }, .commute = .{ 0, 1 } }, |
| 2554 | .{ .src = .{ .xmm, .xmm } }, | 2562 | .{ .src = .{ .to_xmm, .to_xmm } }, |
| 2555 | }, | 2563 | }, |
| 2556 | .dst_temps = .{.{ .rc = .sse }}, | 2564 | .dst_temps = .{.{ .rc = .sse }}, |
| 2557 | .each = .{ .once = &.{ | 2565 | .each = .{ .once = &.{ |
| 2558 | .{ ._, .vp_, mir_tag, .dst0x, .src0x, .src1x, ._ }, | 2566 | .{ ._, .vp_, mir_tag, .dst0x, .src0x, .src1x, ._ }, |
| 2559 | } }, | 2567 | } }, |
| 2560 | }, .{ | 2568 | }, .{ |
| 2561 | .required_features = .{ .sse2, null }, | 2569 | .required_features = .{ .sse2, null, null, null }, |
| | 2570 | .src_constraints = .{ .{ .int_or_vec = .xword }, .{ .int_or_vec = .xword } }, |
| 2562 | .patterns = &.{ | 2571 | .patterns = &.{ |
| 2563 | .{ .src = .{ .mut_xmm, .mem } }, | 2572 | .{ .src = .{ .to_mut_xmm, .mem } }, |
| 2564 | .{ .src = .{ .mem, .mut_xmm }, .commute = .{ 0, 1 } }, | 2573 | .{ .src = .{ .mem, .to_mut_xmm }, .commute = .{ 0, 1 } }, |
| 2565 | .{ .src = .{ .mut_xmm, .xmm } }, | 2574 | .{ .src = .{ .to_mut_xmm, .to_xmm } }, |
| 2566 | }, | 2575 | }, |
| 2567 | .dst_temps = .{.{ .ref = .src0 }}, | 2576 | .dst_temps = .{.{ .ref = .src0 }}, |
| 2568 | .each = .{ .once = &.{ | 2577 | .each = .{ .once = &.{ |
| 2569 | .{ ._, .p_, mir_tag, .dst0x, .src1x, ._, ._ }, | 2578 | .{ ._, .p_, mir_tag, .dst0x, .src1x, ._, ._ }, |
| 2570 | } }, | 2579 | } }, |
| 2571 | }, .{ | 2580 | }, .{ |
| 2572 | .required_features = .{ .sse, null }, | 2581 | .required_features = .{ .sse, null, null, null }, |
| | 2582 | .src_constraints = .{ .{ .int_or_vec = .xword }, .{ .int_or_vec = .xword } }, |
| 2573 | .patterns = &.{ | 2583 | .patterns = &.{ |
| 2574 | .{ .src = .{ .mut_xmm, .mem } }, | 2584 | .{ .src = .{ .to_mut_xmm, .mem } }, |
| 2575 | .{ .src = .{ .mem, .mut_xmm }, .commute = .{ 0, 1 } }, | 2585 | .{ .src = .{ .mem, .to_mut_xmm }, .commute = .{ 0, 1 } }, |
| 2576 | .{ .src = .{ .mut_xmm, .xmm } }, | 2586 | .{ .src = .{ .to_mut_xmm, .to_xmm } }, |
| 2577 | }, | 2587 | }, |
| 2578 | .dst_temps = .{.{ .ref = .src0 }}, | 2588 | .dst_temps = .{.{ .ref = .src0 }}, |
| 2579 | .each = .{ .once = &.{ | 2589 | .each = .{ .once = &.{ |
| 2580 | .{ ._, ._ps, mir_tag, .dst0x, .src1x, ._, ._ }, | 2590 | .{ ._, ._ps, mir_tag, .dst0x, .src1x, ._, ._ }, |
| 2581 | } }, | 2591 | } }, |
| 2582 | }, .{ | 2592 | }, .{ |
| 2583 | .required_features = .{ .mmx, null }, | 2593 | .required_features = .{ .mmx, null, null, null }, |
| | 2594 | .src_constraints = .{ .{ .int_or_vec = .qword }, .{ .int_or_vec = .qword } }, |
| 2584 | .patterns = &.{ | 2595 | .patterns = &.{ |
| 2585 | .{ .src = .{ .mut_mm, .mem } }, | 2596 | .{ .src = .{ .to_mut_mm, .mem } }, |
| 2586 | .{ .src = .{ .mem, .mut_mm }, .commute = .{ 0, 1 } }, | 2597 | .{ .src = .{ .mem, .to_mut_mm }, .commute = .{ 0, 1 } }, |
| 2587 | .{ .src = .{ .mut_mm, .mm } }, | 2598 | .{ .src = .{ .to_mut_mm, .to_mm } }, |
| 2588 | }, | 2599 | }, |
| 2589 | .dst_temps = .{.{ .ref = .src0 }}, | 2600 | .dst_temps = .{.{ .ref = .src0 }}, |
| 2590 | .each = .{ .once = &.{ | 2601 | .each = .{ .once = &.{ |
| 2591 | .{ ._, .p_, mir_tag, .dst0q, .src1q, ._, ._ }, | 2602 | .{ ._, .p_, mir_tag, .dst0q, .src1q, ._, ._ }, |
| 2592 | } }, | 2603 | } }, |
| 2593 | }, .{ | 2604 | }, .{ |
| 2594 | .src_constraints = .{ .{ .int = .byte }, .{ .int = .byte } }, | 2605 | .src_constraints = .{ .{ .int_or_vec = .byte }, .{ .int_or_vec = .byte } }, |
| 2595 | .patterns = &.{ | 2606 | .patterns = &.{ |
| 2596 | .{ .src = .{ .mut_mem, .imm8 } }, | 2607 | .{ .src = .{ .mut_mem, .imm8 } }, |
| 2597 | .{ .src = .{ .imm8, .mut_mem }, .commute = .{ 0, 1 } }, | 2608 | .{ .src = .{ .imm8, .mut_mem }, .commute = .{ 0, 1 } }, |
| 2598 | .{ .src = .{ .mut_gpr, .imm8 } }, | 2609 | .{ .src = .{ .to_mut_gpr, .imm8 } }, |
| 2599 | .{ .src = .{ .imm8, .mut_gpr }, .commute = .{ 0, 1 } }, | 2610 | .{ .src = .{ .imm8, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 2600 | .{ .src = .{ .mut_mem, .gpr } }, | 2611 | .{ .src = .{ .mut_mem, .to_gpr } }, |
| 2601 | .{ .src = .{ .gpr, .mut_mem }, .commute = .{ 0, 1 } }, | 2612 | .{ .src = .{ .to_gpr, .mut_mem }, .commute = .{ 0, 1 } }, |
| 2602 | .{ .src = .{ .mut_gpr, .mem } }, | 2613 | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 2603 | .{ .src = .{ .mem, .mut_gpr }, .commute = .{ 0, 1 } }, | 2614 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 2604 | .{ .src = .{ .mut_gpr, .gpr } }, | 2615 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 2605 | }, | 2616 | }, |
| 2606 | .clobbers = .{ .eflags = true }, | | |
| 2607 | .dst_temps = .{.{ .ref = .src0 }}, | 2617 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 2618 | .clobbers = .{ .eflags = true }, |
| 2608 | .each = .{ .once = &.{ | 2619 | .each = .{ .once = &.{ |
| 2609 | .{ ._, ._, mir_tag, .dst0b, .src1b, ._, ._ }, | 2620 | .{ ._, ._, mir_tag, .dst0b, .src1b, ._, ._ }, |
| 2610 | } }, | 2621 | } }, |
| 2611 | }, .{ | 2622 | }, .{ |
| 2612 | .src_constraints = .{ .{ .int = .word }, .{ .int = .word } }, | 2623 | .src_constraints = .{ .{ .int_or_vec = .word }, .{ .int_or_vec = .word } }, |
| 2613 | .patterns = &.{ | 2624 | .patterns = &.{ |
| 2614 | .{ .src = .{ .mut_mem, .imm16 } }, | 2625 | .{ .src = .{ .mut_mem, .imm16 } }, |
| 2615 | .{ .src = .{ .imm16, .mut_mem }, .commute = .{ 0, 1 } }, | 2626 | .{ .src = .{ .imm16, .mut_mem }, .commute = .{ 0, 1 } }, |
| 2616 | .{ .src = .{ .mut_gpr, .imm16 } }, | 2627 | .{ .src = .{ .to_mut_gpr, .imm16 } }, |
| 2617 | .{ .src = .{ .imm16, .mut_gpr }, .commute = .{ 0, 1 } }, | 2628 | .{ .src = .{ .imm16, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 2618 | .{ .src = .{ .mut_mem, .gpr } }, | 2629 | .{ .src = .{ .mut_mem, .to_gpr } }, |
| 2619 | .{ .src = .{ .gpr, .mut_mem }, .commute = .{ 0, 1 } }, | 2630 | .{ .src = .{ .to_gpr, .mut_mem }, .commute = .{ 0, 1 } }, |
| 2620 | .{ .src = .{ .mut_gpr, .mem } }, | 2631 | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 2621 | .{ .src = .{ .mem, .mut_gpr }, .commute = .{ 0, 1 } }, | 2632 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 2622 | .{ .src = .{ .mut_gpr, .gpr } }, | 2633 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 2623 | }, | 2634 | }, |
| 2624 | .clobbers = .{ .eflags = true }, | | |
| 2625 | .dst_temps = .{.{ .ref = .src0 }}, | 2635 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 2636 | .clobbers = .{ .eflags = true }, |
| 2626 | .each = .{ .once = &.{ | 2637 | .each = .{ .once = &.{ |
| 2627 | .{ ._, ._, mir_tag, .dst0w, .src1w, ._, ._ }, | 2638 | .{ ._, ._, mir_tag, .dst0w, .src1w, ._, ._ }, |
| 2628 | } }, | 2639 | } }, |
| 2629 | }, .{ | 2640 | }, .{ |
| 2630 | .src_constraints = .{ .{ .int = .dword }, .{ .int = .dword } }, | 2641 | .src_constraints = .{ .{ .int_or_vec = .dword }, .{ .int_or_vec = .dword } }, |
| 2631 | .patterns = &.{ | 2642 | .patterns = &.{ |
| 2632 | .{ .src = .{ .mut_mem, .imm32 } }, | 2643 | .{ .src = .{ .mut_mem, .imm32 } }, |
| 2633 | .{ .src = .{ .imm32, .mut_mem }, .commute = .{ 0, 1 } }, | 2644 | .{ .src = .{ .imm32, .mut_mem }, .commute = .{ 0, 1 } }, |
| 2634 | .{ .src = .{ .mut_gpr, .imm32 } }, | 2645 | .{ .src = .{ .to_mut_gpr, .imm32 } }, |
| 2635 | .{ .src = .{ .imm32, .mut_gpr }, .commute = .{ 0, 1 } }, | 2646 | .{ .src = .{ .imm32, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 2636 | .{ .src = .{ .mut_mem, .gpr } }, | 2647 | .{ .src = .{ .mut_mem, .to_gpr } }, |
| 2637 | .{ .src = .{ .gpr, .mut_mem }, .commute = .{ 0, 1 } }, | 2648 | .{ .src = .{ .to_gpr, .mut_mem }, .commute = .{ 0, 1 } }, |
| 2638 | .{ .src = .{ .mut_gpr, .mem } }, | 2649 | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 2639 | .{ .src = .{ .mem, .mut_gpr }, .commute = .{ 0, 1 } }, | 2650 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 2640 | .{ .src = .{ .mut_gpr, .gpr } }, | 2651 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 2641 | }, | 2652 | }, |
| 2642 | .clobbers = .{ .eflags = true }, | | |
| 2643 | .dst_temps = .{.{ .ref = .src0 }}, | 2653 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 2654 | .clobbers = .{ .eflags = true }, |
| 2644 | .each = .{ .once = &.{ | 2655 | .each = .{ .once = &.{ |
| 2645 | .{ ._, ._, mir_tag, .dst0d, .src1d, ._, ._ }, | 2656 | .{ ._, ._, mir_tag, .dst0d, .src1d, ._, ._ }, |
| 2646 | } }, | 2657 | } }, |
| 2647 | }, .{ | 2658 | }, .{ |
| 2648 | .required_features = .{ .@"64bit", null }, | 2659 | .required_features = .{ .@"64bit", null, null, null }, |
| 2649 | .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword } }, | 2660 | .src_constraints = .{ .{ .int_or_vec = .qword }, .{ .int_or_vec = .qword } }, |
| 2650 | .patterns = &.{ | 2661 | .patterns = &.{ |
| 2651 | .{ .src = .{ .mut_mem, .simm32 } }, | 2662 | .{ .src = .{ .mut_mem, .simm32 } }, |
| 2652 | .{ .src = .{ .simm32, .mut_mem }, .commute = .{ 0, 1 } }, | 2663 | .{ .src = .{ .simm32, .mut_mem }, .commute = .{ 0, 1 } }, |
| 2653 | .{ .src = .{ .mut_gpr, .simm32 } }, | 2664 | .{ .src = .{ .to_mut_gpr, .simm32 } }, |
| 2654 | .{ .src = .{ .simm32, .mut_gpr }, .commute = .{ 0, 1 } }, | 2665 | .{ .src = .{ .simm32, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 2655 | .{ .src = .{ .mut_mem, .gpr } }, | 2666 | .{ .src = .{ .mut_mem, .to_gpr } }, |
| 2656 | .{ .src = .{ .gpr, .mut_mem }, .commute = .{ 0, 1 } }, | 2667 | .{ .src = .{ .to_gpr, .mut_mem }, .commute = .{ 0, 1 } }, |
| 2657 | .{ .src = .{ .mut_gpr, .mem } }, | 2668 | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 2658 | .{ .src = .{ .mem, .mut_gpr }, .commute = .{ 0, 1 } }, | 2669 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 2659 | .{ .src = .{ .mut_gpr, .gpr } }, | 2670 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 2660 | }, | 2671 | }, |
| 2661 | .clobbers = .{ .eflags = true }, | | |
| 2662 | .dst_temps = .{.{ .ref = .src0 }}, | 2672 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 2673 | .clobbers = .{ .eflags = true }, |
| 2663 | .each = .{ .once = &.{ | 2674 | .each = .{ .once = &.{ |
| 2664 | .{ ._, ._, mir_tag, .dst0q, .src1q, ._, ._ }, | 2675 | .{ ._, ._, mir_tag, .dst0q, .src1q, ._, ._ }, |
| 2665 | } }, | 2676 | } }, |
| 2666 | }, .{ | 2677 | }, .{ |
| 2667 | .required_features = .{ .avx2, null }, | 2678 | .required_features = .{ .avx2, null, null, null }, |
| | 2679 | .src_constraints = .{ |
| | 2680 | .{ .exact_remainder_int_or_vec = .{ .of = .yword, .is = .yword } }, |
| | 2681 | .{ .exact_remainder_int_or_vec = .{ .of = .yword, .is = .yword } }, |
| | 2682 | }, |
| 2668 | .patterns = &.{ | 2683 | .patterns = &.{ |
| 2669 | .{ .src = .{ .to_mem, .to_mem } }, | 2684 | .{ .src = .{ .to_mem, .to_mem } }, |
| 2670 | }, | 2685 | }, |
| ... | @@ -2677,16 +2692,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2677,16 +2692,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2677 | .unused, | 2692 | .unused, |
| 2678 | }, | 2693 | }, |
| 2679 | .dst_temps = .{.mem}, | 2694 | .dst_temps = .{.mem}, |
| | 2695 | .clobbers = .{ .eflags = true }, |
| 2680 | .each = .{ .once = &.{ | 2696 | .each = .{ .once = &.{ |
| 2681 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 2697 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 2682 | .{ .@"0:", .v_dqu, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, | 2698 | .{ .@"0:", .v_dqu, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 2683 | .{ ._, .vp_, mir_tag, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ }, | 2699 | .{ ._, .vp_, mir_tag, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ }, |
| 2684 | .{ ._, .v_dqu, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ }, | 2700 | .{ ._, .v_dqu, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ }, |
| 2685 | .{ ._, ._, .add, .tmp0p, .i(32), ._, ._ }, | 2701 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 2686 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 2702 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 2687 | } }, | 2703 | } }, |
| 2688 | }, .{ | 2704 | }, .{ |
| 2689 | .required_features = .{ .avx, null }, | 2705 | .required_features = .{ .avx, null, null, null }, |
| | 2706 | .src_constraints = .{ |
| | 2707 | .{ .exact_remainder_int_or_vec = .{ .of = .yword, .is = .yword } }, |
| | 2708 | .{ .exact_remainder_int_or_vec = .{ .of = .yword, .is = .yword } }, |
| | 2709 | }, |
| 2690 | .patterns = &.{ | 2710 | .patterns = &.{ |
| 2691 | .{ .src = .{ .to_mem, .to_mem } }, | 2711 | .{ .src = .{ .to_mem, .to_mem } }, |
| 2692 | }, | 2712 | }, |
| ... | @@ -2699,16 +2719,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2699,16 +2719,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2699 | .unused, | 2719 | .unused, |
| 2700 | }, | 2720 | }, |
| 2701 | .dst_temps = .{.mem}, | 2721 | .dst_temps = .{.mem}, |
| | 2722 | .clobbers = .{ .eflags = true }, |
| 2702 | .each = .{ .once = &.{ | 2723 | .each = .{ .once = &.{ |
| 2703 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 2724 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 2704 | .{ .@"0:", .v_pd, .movu, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, | 2725 | .{ .@"0:", .v_pd, .movu, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 2705 | .{ ._, .v_pd, mir_tag, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ }, | 2726 | .{ ._, .v_pd, mir_tag, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ }, |
| 2706 | .{ ._, .v_pd, .movu, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ }, | 2727 | .{ ._, .v_pd, .movu, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ }, |
| 2707 | .{ ._, ._, .add, .tmp0p, .i(32), ._, ._ }, | 2728 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 2708 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 2729 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 2709 | } }, | 2730 | } }, |
| 2710 | }, .{ | 2731 | }, .{ |
| 2711 | .required_features = .{ .avx, null }, | 2732 | .required_features = .{ .avx, null, null, null }, |
| | 2733 | .src_constraints = .{ |
| | 2734 | .{ .exact_remainder_int_or_vec = .{ .of = .xword, .is = .xword } }, |
| | 2735 | .{ .exact_remainder_int_or_vec = .{ .of = .xword, .is = .xword } }, |
| | 2736 | }, |
| 2712 | .patterns = &.{ | 2737 | .patterns = &.{ |
| 2713 | .{ .src = .{ .to_mem, .to_mem } }, | 2738 | .{ .src = .{ .to_mem, .to_mem } }, |
| 2714 | }, | 2739 | }, |
| ... | @@ -2721,16 +2746,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2721,16 +2746,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2721 | .unused, | 2746 | .unused, |
| 2722 | }, | 2747 | }, |
| 2723 | .dst_temps = .{.mem}, | 2748 | .dst_temps = .{.mem}, |
| | 2749 | .clobbers = .{ .eflags = true }, |
| 2724 | .each = .{ .once = &.{ | 2750 | .each = .{ .once = &.{ |
| 2725 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 2751 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 2726 | .{ .@"0:", .v_dqu, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 2752 | .{ .@"0:", .v_dqu, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 2727 | .{ ._, .vp_, mir_tag, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._ }, | 2753 | .{ ._, .vp_, mir_tag, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._ }, |
| 2728 | .{ ._, .v_dqu, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, | 2754 | .{ ._, .v_dqu, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 2729 | .{ ._, ._, .add, .tmp0p, .i(16), ._, ._ }, | 2755 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 2730 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 2756 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 2731 | } }, | 2757 | } }, |
| 2732 | }, .{ | 2758 | }, .{ |
| 2733 | .required_features = .{ .sse2, null }, | 2759 | .required_features = .{ .sse2, null, null, null }, |
| | 2760 | .src_constraints = .{ |
| | 2761 | .{ .exact_remainder_int_or_vec = .{ .of = .xword, .is = .xword } }, |
| | 2762 | .{ .exact_remainder_int_or_vec = .{ .of = .xword, .is = .xword } }, |
| | 2763 | }, |
| 2734 | .patterns = &.{ | 2764 | .patterns = &.{ |
| 2735 | .{ .src = .{ .to_mem, .to_mem } }, | 2765 | .{ .src = .{ .to_mem, .to_mem } }, |
| 2736 | }, | 2766 | }, |
| ... | @@ -2743,16 +2773,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2743,16 +2773,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2743 | .unused, | 2773 | .unused, |
| 2744 | }, | 2774 | }, |
| 2745 | .dst_temps = .{.mem}, | 2775 | .dst_temps = .{.mem}, |
| | 2776 | .clobbers = .{ .eflags = true }, |
| 2746 | .each = .{ .once = &.{ | 2777 | .each = .{ .once = &.{ |
| 2747 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 2778 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 2748 | .{ .@"0:", ._dqu, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 2779 | .{ .@"0:", ._dqu, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 2749 | .{ ._, .p_, mir_tag, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, | 2780 | .{ ._, .p_, mir_tag, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 2750 | .{ ._, ._dqu, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, | 2781 | .{ ._, ._dqu, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 2751 | .{ ._, ._, .add, .tmp0p, .i(16), ._, ._ }, | 2782 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 2752 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 2783 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 2753 | } }, | 2784 | } }, |
| 2754 | }, .{ | 2785 | }, .{ |
| 2755 | .required_features = .{ .sse, null }, | 2786 | .required_features = .{ .sse, null, null, null }, |
| | 2787 | .src_constraints = .{ |
| | 2788 | .{ .exact_remainder_int_or_vec = .{ .of = .xword, .is = .xword } }, |
| | 2789 | .{ .exact_remainder_int_or_vec = .{ .of = .xword, .is = .xword } }, |
| | 2790 | }, |
| 2756 | .patterns = &.{ | 2791 | .patterns = &.{ |
| 2757 | .{ .src = .{ .to_mem, .to_mem } }, | 2792 | .{ .src = .{ .to_mem, .to_mem } }, |
| 2758 | }, | 2793 | }, |
| ... | @@ -2765,16 +2800,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2765,16 +2800,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2765 | .unused, | 2800 | .unused, |
| 2766 | }, | 2801 | }, |
| 2767 | .dst_temps = .{.mem}, | 2802 | .dst_temps = .{.mem}, |
| | 2803 | .clobbers = .{ .eflags = true }, |
| 2768 | .each = .{ .once = &.{ | 2804 | .each = .{ .once = &.{ |
| 2769 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 2805 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 2770 | .{ .@"0:", ._ps, .movu, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 2806 | .{ .@"0:", ._ps, .movu, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 2771 | .{ ._, ._ps, mir_tag, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, | 2807 | .{ ._, ._ps, mir_tag, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 2772 | .{ ._, ._ps, .movu, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, | 2808 | .{ ._, ._ps, .movu, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 2773 | .{ ._, ._, .add, .tmp0p, .i(16), ._, ._ }, | 2809 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 2774 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 2810 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 2775 | } }, | 2811 | } }, |
| 2776 | }, .{ | 2812 | }, .{ |
| 2777 | .required_features = .{ .mmx, null }, | 2813 | .required_features = .{ .mmx, null, null, null }, |
| | 2814 | .src_constraints = .{ |
| | 2815 | .{ .exact_remainder_int_or_vec = .{ .of = .qword, .is = .qword } }, |
| | 2816 | .{ .exact_remainder_int_or_vec = .{ .of = .qword, .is = .qword } }, |
| | 2817 | }, |
| 2778 | .patterns = &.{ | 2818 | .patterns = &.{ |
| 2779 | .{ .src = .{ .to_mem, .to_mem } }, | 2819 | .{ .src = .{ .to_mem, .to_mem } }, |
| 2780 | }, | 2820 | }, |
| ... | @@ -2787,15 +2827,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2787,15 +2827,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2787 | .unused, | 2827 | .unused, |
| 2788 | }, | 2828 | }, |
| 2789 | .dst_temps = .{.mem}, | 2829 | .dst_temps = .{.mem}, |
| | 2830 | .clobbers = .{ .eflags = true }, |
| 2790 | .each = .{ .once = &.{ | 2831 | .each = .{ .once = &.{ |
| 2791 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 2832 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 2792 | .{ .@"0:", ._q, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, | 2833 | .{ .@"0:", ._q, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 2793 | .{ ._, .p_, mir_tag, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, | 2834 | .{ ._, .p_, mir_tag, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 2794 | .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, | 2835 | .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, |
| 2795 | .{ ._, ._, .add, .tmp0p, .i(8), ._, ._ }, | 2836 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 2796 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 2837 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 2797 | } }, | 2838 | } }, |
| 2798 | }, .{ | 2839 | }, .{ |
| | 2840 | .src_constraints = .{ |
| | 2841 | .{ .exact_remainder_int_or_vec = .{ .of = .qword, .is = .qword } }, |
| | 2842 | .{ .exact_remainder_int_or_vec = .{ .of = .qword, .is = .qword } }, |
| | 2843 | }, |
| 2799 | .patterns = &.{ | 2844 | .patterns = &.{ |
| 2800 | .{ .src = .{ .to_mem, .to_mem } }, | 2845 | .{ .src = .{ .to_mem, .to_mem } }, |
| 2801 | }, | 2846 | }, |
| ... | @@ -2808,16 +2853,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2808,16 +2853,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2808 | .unused, | 2853 | .unused, |
| 2809 | }, | 2854 | }, |
| 2810 | .dst_temps = .{.mem}, | 2855 | .dst_temps = .{.mem}, |
| | 2856 | .clobbers = .{ .eflags = true }, |
| 2811 | .each = .{ .once = &.{ | 2857 | .each = .{ .once = &.{ |
| 2812 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 2858 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 2813 | .{ .@"0:", ._, .mov, .tmp1p, .memia(.src0p, .tmp0, .add_size), ._, ._ }, | 2859 | .{ .@"0:", ._, .mov, .tmp1p, .memia(.src0p, .tmp0, .add_size), ._, ._ }, |
| 2814 | .{ ._, ._, mir_tag, .tmp1p, .memia(.src1p, .tmp0, .add_size), ._, ._ }, | 2860 | .{ ._, ._, mir_tag, .tmp1p, .memia(.src1p, .tmp0, .add_size), ._, ._ }, |
| 2815 | .{ ._, ._, .mov, .memia(.dst0p, .tmp0, .add_size), .tmp1p, ._, ._ }, | 2861 | .{ ._, ._, .mov, .memia(.dst0p, .tmp0, .add_size), .tmp1p, ._, ._ }, |
| 2816 | .{ ._, ._, .add, .tmp0p, .a(.tmp1, .add_size), ._, ._ }, | 2862 | .{ ._, ._, .add, .tmp0p, .sa(.tmp1, .add_size), ._, ._ }, |
| 2817 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 2863 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 2818 | } }, | 2864 | } }, |
| 2819 | } }, | 2865 | } }, |
| 2820 | }) catch |err2| switch (err2) { | 2866 | }) catch |err| switch (err) { |
| 2821 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ | 2867 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 2822 | @tagName(air_tag), | 2868 | @tagName(air_tag), |
| 2823 | cg.typeOf(bin_op.lhs).fmt(pt), | 2869 | cg.typeOf(bin_op.lhs).fmt(pt), |
| ... | @@ -2830,6 +2876,1058 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2830,6 +2876,1058 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2830 | if (ops[1].index != res[0].index) try ops[1].die(cg); | 2876 | if (ops[1].index != res[0].index) try ops[1].die(cg); |
| 2831 | try res[0].moveTo(inst, cg); | 2877 | try res[0].moveTo(inst, cg); |
| 2832 | }, | 2878 | }, |
| | 2879 | .not => |air_tag| if (use_old) try cg.airUnOp(inst, air_tag) else { |
| | 2880 | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| | 2881 | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| | 2882 | var res: [1]Temp = undefined; |
| | 2883 | cg.select(&res, &.{cg.typeOfIndex(inst)}, &ops, comptime &.{ .{ |
| | 2884 | .src_constraints = .{ .{ .signed_or_exact_int = .byte }, .any }, |
| | 2885 | .patterns = &.{ |
| | 2886 | .{ .src = .{ .mut_mem, .none } }, |
| | 2887 | .{ .src = .{ .to_mut_gpr, .none } }, |
| | 2888 | }, |
| | 2889 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 2890 | .each = .{ .once = &.{ |
| | 2891 | .{ ._, ._, .not, .dst0b, ._, ._, ._ }, |
| | 2892 | } }, |
| | 2893 | }, .{ |
| | 2894 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any }, |
| | 2895 | .patterns = &.{ |
| | 2896 | .{ .src = .{ .mut_mem, .none } }, |
| | 2897 | .{ .src = .{ .to_mut_gpr, .none } }, |
| | 2898 | }, |
| | 2899 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 2900 | .clobbers = .{ .eflags = true }, |
| | 2901 | .each = .{ .once = &.{ |
| | 2902 | .{ ._, ._, .xor, .dst0b, .sa(.src0, .add_umax), ._, ._ }, |
| | 2903 | } }, |
| | 2904 | }, .{ |
| | 2905 | .src_constraints = .{ .{ .signed_or_exact_int = .word }, .any }, |
| | 2906 | .patterns = &.{ |
| | 2907 | .{ .src = .{ .mut_mem, .none } }, |
| | 2908 | .{ .src = .{ .to_mut_gpr, .none } }, |
| | 2909 | }, |
| | 2910 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 2911 | .each = .{ .once = &.{ |
| | 2912 | .{ ._, ._, .not, .dst0w, ._, ._, ._ }, |
| | 2913 | } }, |
| | 2914 | }, .{ |
| | 2915 | .src_constraints = .{ .{ .unsigned_int = .word }, .any }, |
| | 2916 | .patterns = &.{ |
| | 2917 | .{ .src = .{ .mut_mem, .none } }, |
| | 2918 | .{ .src = .{ .to_mut_gpr, .none } }, |
| | 2919 | }, |
| | 2920 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 2921 | .clobbers = .{ .eflags = true }, |
| | 2922 | .each = .{ .once = &.{ |
| | 2923 | .{ ._, ._, .xor, .dst0w, .sa(.src0, .add_umax), ._, ._ }, |
| | 2924 | } }, |
| | 2925 | }, .{ |
| | 2926 | .src_constraints = .{ .{ .signed_or_exact_int = .dword }, .any }, |
| | 2927 | .patterns = &.{ |
| | 2928 | .{ .src = .{ .mut_mem, .none } }, |
| | 2929 | .{ .src = .{ .to_mut_gpr, .none } }, |
| | 2930 | }, |
| | 2931 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 2932 | .each = .{ .once = &.{ |
| | 2933 | .{ ._, ._, .not, .dst0d, ._, ._, ._ }, |
| | 2934 | } }, |
| | 2935 | }, .{ |
| | 2936 | .src_constraints = .{ .{ .unsigned_int = .dword }, .any }, |
| | 2937 | .patterns = &.{ |
| | 2938 | .{ .src = .{ .mut_mem, .none } }, |
| | 2939 | .{ .src = .{ .to_mut_gpr, .none } }, |
| | 2940 | }, |
| | 2941 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 2942 | .clobbers = .{ .eflags = true }, |
| | 2943 | .each = .{ .once = &.{ |
| | 2944 | .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_umax), ._, ._ }, |
| | 2945 | } }, |
| | 2946 | }, .{ |
| | 2947 | .required_features = .{ .@"64bit", null, null, null }, |
| | 2948 | .src_constraints = .{ .{ .signed_or_exact_int = .qword }, .any }, |
| | 2949 | .patterns = &.{ |
| | 2950 | .{ .src = .{ .mut_mem, .none } }, |
| | 2951 | .{ .src = .{ .to_mut_gpr, .none } }, |
| | 2952 | }, |
| | 2953 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 2954 | .each = .{ .once = &.{ |
| | 2955 | .{ ._, ._, .not, .dst0q, ._, ._, ._ }, |
| | 2956 | } }, |
| | 2957 | }, .{ |
| | 2958 | .required_features = .{ .@"64bit", null, null, null }, |
| | 2959 | .src_constraints = .{ .{ .unsigned_int = .qword }, .any }, |
| | 2960 | .patterns = &.{ |
| | 2961 | .{ .src = .{ .mem, .none } }, |
| | 2962 | .{ .src = .{ .to_gpr, .none } }, |
| | 2963 | }, |
| | 2964 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 2965 | .each = .{ .once = &.{ |
| | 2966 | .{ ._, ._, .mov, .dst0q, .ua(.src0, .add_umax), ._, ._ }, |
| | 2967 | .{ ._, ._, .xor, .dst0q, .src0q, ._, ._ }, |
| | 2968 | } }, |
| | 2969 | }, .{ |
| | 2970 | .required_features = .{ .mmx, null, null, null }, |
| | 2971 | .src_constraints = .{ .{ .signed_or_exact_int = .qword }, .any }, |
| | 2972 | .patterns = &.{ |
| | 2973 | .{ .src = .{ .mem, .none } }, |
| | 2974 | .{ .src = .{ .to_mm, .none } }, |
| | 2975 | }, |
| | 2976 | .dst_temps = .{.{ .rc = .mmx }}, |
| | 2977 | .each = .{ .once = &.{ |
| | 2978 | .{ ._, .p_d, .cmpeq, .dst0q, .dst0q, ._, ._ }, |
| | 2979 | .{ ._, .p_, .xor, .dst0q, .src0q, ._, ._ }, |
| | 2980 | } }, |
| | 2981 | }, .{ |
| | 2982 | .required_features = .{ .mmx, null, null, null }, |
| | 2983 | .src_constraints = .{ .{ .unsigned_int = .qword }, .any }, |
| | 2984 | .patterns = &.{ |
| | 2985 | .{ .src = .{ .to_mut_mm, .none } }, |
| | 2986 | }, |
| | 2987 | .extra_temps = .{ |
| | 2988 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 2989 | .{ .kind = .{ .umax_mem = .src0 } }, |
| | 2990 | .unused, |
| | 2991 | .unused, |
| | 2992 | .unused, |
| | 2993 | .unused, |
| | 2994 | }, |
| | 2995 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 2996 | .each = .{ .once = &.{ |
| | 2997 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 2998 | .{ ._, .p_, .xor, .dst0q, .lea(.qword, .tmp0), ._, ._ }, |
| | 2999 | } }, |
| | 3000 | }, .{ |
| | 3001 | .required_features = .{ .avx, null, null, null }, |
| | 3002 | .src_constraints = .{ .{ .signed_or_exact_int = .xword }, .any }, |
| | 3003 | .patterns = &.{ |
| | 3004 | .{ .src = .{ .mem, .none } }, |
| | 3005 | .{ .src = .{ .to_xmm, .none } }, |
| | 3006 | }, |
| | 3007 | .dst_temps = .{.{ .rc = .sse }}, |
| | 3008 | .each = .{ .once = &.{ |
| | 3009 | .{ ._, .vp_q, .cmpeq, .dst0x, .dst0x, .dst0x, ._ }, |
| | 3010 | .{ ._, .vp_, .xor, .dst0x, .dst0x, .src0x, ._ }, |
| | 3011 | } }, |
| | 3012 | }, .{ |
| | 3013 | .required_features = .{ .avx, null, null, null }, |
| | 3014 | .src_constraints = .{ .{ .unsigned_int = .xword }, .any }, |
| | 3015 | .patterns = &.{ |
| | 3016 | .{ .src = .{ .to_xmm, .none } }, |
| | 3017 | }, |
| | 3018 | .extra_temps = .{ |
| | 3019 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 3020 | .{ .kind = .{ .umax_mem = .src0 } }, |
| | 3021 | .unused, |
| | 3022 | .unused, |
| | 3023 | .unused, |
| | 3024 | .unused, |
| | 3025 | }, |
| | 3026 | .dst_temps = .{.{ .rc = .sse }}, |
| | 3027 | .each = .{ .once = &.{ |
| | 3028 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 3029 | .{ ._, .vp_, .xor, .dst0x, .src0x, .lea(.xword, .tmp0), ._ }, |
| | 3030 | } }, |
| | 3031 | }, .{ |
| | 3032 | .required_features = .{ .sse2, null, null, null }, |
| | 3033 | .src_constraints = .{ .{ .signed_or_exact_int = .xword }, .any }, |
| | 3034 | .patterns = &.{ |
| | 3035 | .{ .src = .{ .mem, .none } }, |
| | 3036 | .{ .src = .{ .to_xmm, .none } }, |
| | 3037 | }, |
| | 3038 | .dst_temps = .{.{ .rc = .sse }}, |
| | 3039 | .each = .{ .once = &.{ |
| | 3040 | .{ ._, .p_d, .cmpeq, .dst0x, .dst0x, ._, ._ }, |
| | 3041 | .{ ._, .p_, .xor, .dst0x, .src0x, ._, ._ }, |
| | 3042 | } }, |
| | 3043 | }, .{ |
| | 3044 | .required_features = .{ .sse2, null, null, null }, |
| | 3045 | .src_constraints = .{ .{ .unsigned_int = .xword }, .any }, |
| | 3046 | .patterns = &.{ |
| | 3047 | .{ .src = .{ .to_mut_xmm, .none } }, |
| | 3048 | }, |
| | 3049 | .extra_temps = .{ |
| | 3050 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 3051 | .{ .kind = .{ .umax_mem = .src0 } }, |
| | 3052 | .unused, |
| | 3053 | .unused, |
| | 3054 | .unused, |
| | 3055 | .unused, |
| | 3056 | }, |
| | 3057 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 3058 | .each = .{ .once = &.{ |
| | 3059 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 3060 | .{ ._, .p_, .xor, .dst0x, .lea(.xword, .tmp0), ._, ._ }, |
| | 3061 | } }, |
| | 3062 | }, .{ |
| | 3063 | .required_features = .{ .sse, null, null, null }, |
| | 3064 | .src_constraints = .{ .{ .int = .xword }, .any }, |
| | 3065 | .patterns = &.{ |
| | 3066 | .{ .src = .{ .to_mut_xmm, .none } }, |
| | 3067 | }, |
| | 3068 | .extra_temps = .{ |
| | 3069 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 3070 | .{ .kind = .{ .umax_mem = .src0 } }, |
| | 3071 | .unused, |
| | 3072 | .unused, |
| | 3073 | .unused, |
| | 3074 | .unused, |
| | 3075 | }, |
| | 3076 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 3077 | .each = .{ .once = &.{ |
| | 3078 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 3079 | .{ ._, ._ps, .xor, .dst0x, .lea(.xword, .tmp0), ._, ._ }, |
| | 3080 | } }, |
| | 3081 | }, .{ |
| | 3082 | .required_features = .{ .avx2, null, null, null }, |
| | 3083 | .src_constraints = .{ .{ .signed_or_exact_int = .yword }, .any }, |
| | 3084 | .patterns = &.{ |
| | 3085 | .{ .src = .{ .mem, .none } }, |
| | 3086 | .{ .src = .{ .to_ymm, .none } }, |
| | 3087 | }, |
| | 3088 | .dst_temps = .{.{ .rc = .sse }}, |
| | 3089 | .each = .{ .once = &.{ |
| | 3090 | .{ ._, .vp_q, .cmpeq, .dst0y, .dst0y, .dst0y, ._ }, |
| | 3091 | .{ ._, .vp_, .xor, .dst0y, .dst0y, .src0y, ._ }, |
| | 3092 | } }, |
| | 3093 | }, .{ |
| | 3094 | .required_features = .{ .avx2, null, null, null }, |
| | 3095 | .src_constraints = .{ .{ .unsigned_int = .yword }, .any }, |
| | 3096 | .patterns = &.{ |
| | 3097 | .{ .src = .{ .to_ymm, .none } }, |
| | 3098 | }, |
| | 3099 | .extra_temps = .{ |
| | 3100 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 3101 | .{ .kind = .{ .umax_mem = .src0 } }, |
| | 3102 | .unused, |
| | 3103 | .unused, |
| | 3104 | .unused, |
| | 3105 | .unused, |
| | 3106 | }, |
| | 3107 | .dst_temps = .{.{ .rc = .sse }}, |
| | 3108 | .each = .{ .once = &.{ |
| | 3109 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 3110 | .{ ._, .vp_, .xor, .dst0y, .src0y, .lea(.yword, .tmp0), ._ }, |
| | 3111 | } }, |
| | 3112 | }, .{ |
| | 3113 | .required_features = .{ .avx, null, null, null }, |
| | 3114 | .src_constraints = .{ .{ .signed_or_exact_int = .yword }, .any }, |
| | 3115 | .patterns = &.{ |
| | 3116 | .{ .src = .{ .mem, .none } }, |
| | 3117 | .{ .src = .{ .to_ymm, .none } }, |
| | 3118 | }, |
| | 3119 | .dst_temps = .{.{ .rc = .sse }}, |
| | 3120 | .each = .{ .once = &.{ |
| | 3121 | .{ ._, .v_pd, .cmp, .dst0y, .dst0y, .dst0y, .si(0b01111) }, |
| | 3122 | .{ ._, .v_pd, .xor, .dst0y, .dst0y, .src0y, ._ }, |
| | 3123 | } }, |
| | 3124 | }, .{ |
| | 3125 | .required_features = .{ .avx, null, null, null }, |
| | 3126 | .src_constraints = .{ .{ .unsigned_int = .yword }, .any }, |
| | 3127 | .patterns = &.{ |
| | 3128 | .{ .src = .{ .to_ymm, .none } }, |
| | 3129 | }, |
| | 3130 | .extra_temps = .{ |
| | 3131 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 3132 | .{ .kind = .{ .umax_mem = .src0 } }, |
| | 3133 | .unused, |
| | 3134 | .unused, |
| | 3135 | .unused, |
| | 3136 | .unused, |
| | 3137 | }, |
| | 3138 | .dst_temps = .{.{ .rc = .sse }}, |
| | 3139 | .each = .{ .once = &.{ |
| | 3140 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 3141 | .{ ._, .v_pd, .xor, .dst0y, .src0y, .lea(.yword, .tmp0), ._ }, |
| | 3142 | } }, |
| | 3143 | }, .{ |
| | 3144 | .required_features = .{ .avx2, null, null, null }, |
| | 3145 | .src_constraints = .{ .{ .signed_or_exact_remainder_int = .{ .of = .yword, .is = .xword } }, .any }, |
| | 3146 | .patterns = &.{ |
| | 3147 | .{ .src = .{ .to_mem, .none } }, |
| | 3148 | }, |
| | 3149 | .extra_temps = .{ |
| | 3150 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 3151 | .{ .kind = .{ .rc = .sse } }, |
| | 3152 | .{ .kind = .{ .rc = .sse } }, |
| | 3153 | .unused, |
| | 3154 | .unused, |
| | 3155 | .unused, |
| | 3156 | }, |
| | 3157 | .dst_temps = .{.mem}, |
| | 3158 | .clobbers = .{ .eflags = true }, |
| | 3159 | .each = .{ .once = &.{ |
| | 3160 | .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_size), ._, ._ }, |
| | 3161 | .{ ._, .vp_q, .cmpeq, .tmp1y, .tmp1y, .tmp1y, ._ }, |
| | 3162 | .{ .@"0:", .vp_, .xor, .tmp2y, .tmp1y, .memiad(.src0y, .tmp0, .add_size, -16), ._ }, |
| | 3163 | .{ ._, .v_dqu, .mov, .memiad(.dst0y, .tmp0, .add_size, -16), .tmp2y, ._, ._ }, |
| | 3164 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 3165 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 3166 | .{ .@"0:", .vp_, .xor, .tmp2x, .tmp1x, .memad(.src0x, .add_size, -16), ._ }, |
| | 3167 | .{ ._, .v_dqa, .mov, .memad(.dst0x, .add_size, -16), .tmp2x, ._, ._ }, |
| | 3168 | } }, |
| | 3169 | }, .{ |
| | 3170 | .required_features = .{ .avx2, null, null, null }, |
| | 3171 | .src_constraints = .{ .{ .signed_or_exact_remainder_int = .{ .of = .yword, .is = .yword } }, .any }, |
| | 3172 | .patterns = &.{ |
| | 3173 | .{ .src = .{ .to_mem, .none } }, |
| | 3174 | }, |
| | 3175 | .extra_temps = .{ |
| | 3176 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 3177 | .{ .kind = .{ .rc = .sse } }, |
| | 3178 | .{ .kind = .{ .rc = .sse } }, |
| | 3179 | .unused, |
| | 3180 | .unused, |
| | 3181 | .unused, |
| | 3182 | }, |
| | 3183 | .dst_temps = .{.mem}, |
| | 3184 | .clobbers = .{ .eflags = true }, |
| | 3185 | .each = .{ .once = &.{ |
| | 3186 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| | 3187 | .{ ._, .vp_q, .cmpeq, .tmp1y, .tmp1y, .tmp1y, ._ }, |
| | 3188 | .{ .@"0:", .vp_, .xor, .tmp2y, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._ }, |
| | 3189 | .{ ._, .v_dqu, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp2y, ._, ._ }, |
| | 3190 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 3191 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 3192 | } }, |
| | 3193 | }, .{ |
| | 3194 | .required_features = .{ .avx, null, null, null }, |
| | 3195 | .src_constraints = .{ .{ .signed_or_exact_remainder_int = .{ .of = .yword, .is = .xword } }, .any }, |
| | 3196 | .patterns = &.{ |
| | 3197 | .{ .src = .{ .to_mem, .none } }, |
| | 3198 | }, |
| | 3199 | .extra_temps = .{ |
| | 3200 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 3201 | .{ .kind = .{ .rc = .sse } }, |
| | 3202 | .{ .kind = .{ .rc = .sse } }, |
| | 3203 | .unused, |
| | 3204 | .unused, |
| | 3205 | .unused, |
| | 3206 | }, |
| | 3207 | .dst_temps = .{.mem}, |
| | 3208 | .clobbers = .{ .eflags = true }, |
| | 3209 | .each = .{ .once = &.{ |
| | 3210 | .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_size), ._, ._ }, |
| | 3211 | .{ ._, .v_pd, .cmp, .tmp1y, .tmp1y, .tmp1y, .si(0b01111) }, |
| | 3212 | .{ .@"0:", .v_pd, .xor, .tmp2y, .tmp1y, .memiad(.src0y, .tmp0, .add_size, -16), ._ }, |
| | 3213 | .{ ._, .v_pd, .movu, .memiad(.dst0y, .tmp0, .add_size, -16), .tmp2y, ._, ._ }, |
| | 3214 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 3215 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 3216 | .{ .@"0:", .v_pd, .xor, .tmp2x, .tmp1x, .memad(.src0x, .add_size, -16), ._ }, |
| | 3217 | .{ ._, .v_pd, .mova, .memad(.dst0x, .add_size, -16), .tmp2x, ._, ._ }, |
| | 3218 | } }, |
| | 3219 | }, .{ |
| | 3220 | .required_features = .{ .avx, null, null, null }, |
| | 3221 | .src_constraints = .{ .{ .signed_or_exact_remainder_int = .{ .of = .yword, .is = .yword } }, .any }, |
| | 3222 | .patterns = &.{ |
| | 3223 | .{ .src = .{ .to_mem, .none } }, |
| | 3224 | }, |
| | 3225 | .extra_temps = .{ |
| | 3226 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 3227 | .{ .kind = .{ .rc = .sse } }, |
| | 3228 | .{ .kind = .{ .rc = .sse } }, |
| | 3229 | .unused, |
| | 3230 | .unused, |
| | 3231 | .unused, |
| | 3232 | }, |
| | 3233 | .dst_temps = .{.mem}, |
| | 3234 | .clobbers = .{ .eflags = true }, |
| | 3235 | .each = .{ .once = &.{ |
| | 3236 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| | 3237 | .{ ._, .v_pd, .cmp, .tmp1y, .tmp1y, .tmp1y, .si(0b01111) }, |
| | 3238 | .{ .@"0:", .v_pd, .xor, .tmp2y, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._ }, |
| | 3239 | .{ ._, .v_pd, .movu, .memia(.dst0y, .tmp0, .add_size), .tmp2y, ._, ._ }, |
| | 3240 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 3241 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 3242 | } }, |
| | 3243 | }, .{ |
| | 3244 | .required_features = .{ .avx, null, null, null }, |
| | 3245 | .src_constraints = .{ .{ .signed_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| | 3246 | .patterns = &.{ |
| | 3247 | .{ .src = .{ .to_mem, .none } }, |
| | 3248 | }, |
| | 3249 | .extra_temps = .{ |
| | 3250 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 3251 | .{ .kind = .{ .rc = .sse } }, |
| | 3252 | .{ .kind = .{ .rc = .sse } }, |
| | 3253 | .unused, |
| | 3254 | .unused, |
| | 3255 | .unused, |
| | 3256 | }, |
| | 3257 | .dst_temps = .{.mem}, |
| | 3258 | .clobbers = .{ .eflags = true }, |
| | 3259 | .each = .{ .once = &.{ |
| | 3260 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| | 3261 | .{ ._, .vp_q, .cmpeq, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| | 3262 | .{ .@"0:", .v_, .xor, .tmp2x, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._ }, |
| | 3263 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp2x, ._, ._ }, |
| | 3264 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 3265 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 3266 | } }, |
| | 3267 | }, .{ |
| | 3268 | .required_features = .{ .sse2, null, null, null }, |
| | 3269 | .src_constraints = .{ .{ .signed_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| | 3270 | .patterns = &.{ |
| | 3271 | .{ .src = .{ .to_mem, .none } }, |
| | 3272 | }, |
| | 3273 | .extra_temps = .{ |
| | 3274 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 3275 | .{ .kind = .{ .rc = .sse } }, |
| | 3276 | .{ .kind = .{ .rc = .sse } }, |
| | 3277 | .unused, |
| | 3278 | .unused, |
| | 3279 | .unused, |
| | 3280 | }, |
| | 3281 | .dst_temps = .{.mem}, |
| | 3282 | .clobbers = .{ .eflags = true }, |
| | 3283 | .each = .{ .once = &.{ |
| | 3284 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| | 3285 | .{ ._, .p_d, .cmpeq, .tmp1x, .tmp1x, ._, ._ }, |
| | 3286 | .{ .@"0:", ._dqa, .mov, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| | 3287 | .{ ._, .p_, .xor, .tmp2x, .tmp1x, ._, ._ }, |
| | 3288 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp2x, ._, ._ }, |
| | 3289 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 3290 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 3291 | } }, |
| | 3292 | }, .{ |
| | 3293 | .required_features = .{ .@"64bit", null, null, null }, |
| | 3294 | .src_constraints = .{ .{ .signed_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| | 3295 | .patterns = &.{ |
| | 3296 | .{ .src = .{ .mut_mem, .none } }, |
| | 3297 | }, |
| | 3298 | .extra_temps = .{ |
| | 3299 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 3300 | .unused, |
| | 3301 | .unused, |
| | 3302 | .unused, |
| | 3303 | .unused, |
| | 3304 | .unused, |
| | 3305 | }, |
| | 3306 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 3307 | .clobbers = .{ .eflags = true }, |
| | 3308 | .each = .{ .once = &.{ |
| | 3309 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| | 3310 | .{ .@"0:", ._, .not, .memia(.dst0q, .tmp0, .add_size), ._, ._, ._ }, |
| | 3311 | .{ ._, ._, .not, .memiad(.dst0q, .tmp0, .add_size, 8), ._, ._, ._ }, |
| | 3312 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 3313 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 3314 | } }, |
| | 3315 | }, .{ |
| | 3316 | .required_features = .{ .@"64bit", null, null, null }, |
| | 3317 | .src_constraints = .{ .{ .signed_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| | 3318 | .patterns = &.{ |
| | 3319 | .{ .src = .{ .to_mem, .none } }, |
| | 3320 | }, |
| | 3321 | .extra_temps = .{ |
| | 3322 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 3323 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 3324 | .unused, |
| | 3325 | .unused, |
| | 3326 | .unused, |
| | 3327 | .unused, |
| | 3328 | }, |
| | 3329 | .dst_temps = .{.mem}, |
| | 3330 | .clobbers = .{ .eflags = true }, |
| | 3331 | .each = .{ .once = &.{ |
| | 3332 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| | 3333 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| | 3334 | .{ ._, ._, .not, .tmp1q, ._, ._, ._ }, |
| | 3335 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, |
| | 3336 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 3337 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 3338 | } }, |
| | 3339 | }, .{ |
| | 3340 | .required_features = .{ .@"64bit", null, null, null }, |
| | 3341 | .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .xword, .is = .dword } }, .any }, |
| | 3342 | .patterns = &.{ |
| | 3343 | .{ .src = .{ .mut_mem, .none } }, |
| | 3344 | }, |
| | 3345 | .extra_temps = .{ |
| | 3346 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 3347 | .unused, |
| | 3348 | .unused, |
| | 3349 | .unused, |
| | 3350 | .unused, |
| | 3351 | .unused, |
| | 3352 | }, |
| | 3353 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 3354 | .clobbers = .{ .eflags = true }, |
| | 3355 | .each = .{ .once = &.{ |
| | 3356 | .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_size), ._, ._ }, |
| | 3357 | .{ .@"0:", ._, .not, .memiad(.dst0q, .tmp0, .add_size, -16), ._, ._, ._ }, |
| | 3358 | .{ ._, ._, .not, .memiad(.dst0q, .tmp0, .add_size, -16 + 8), ._, ._, ._ }, |
| | 3359 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 3360 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 3361 | .{ ._, ._, .not, .memad(.dst0d, .add_size, -16), ._, ._, ._ }, |
| | 3362 | } }, |
| | 3363 | }, .{ |
| | 3364 | .required_features = .{ .@"64bit", null, null, null }, |
| | 3365 | .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .xword, .is = .dword } }, .any }, |
| | 3366 | .patterns = &.{ |
| | 3367 | .{ .src = .{ .to_mem, .none } }, |
| | 3368 | }, |
| | 3369 | .extra_temps = .{ |
| | 3370 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 3371 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 3372 | .unused, |
| | 3373 | .unused, |
| | 3374 | .unused, |
| | 3375 | .unused, |
| | 3376 | }, |
| | 3377 | .dst_temps = .{.mem}, |
| | 3378 | .clobbers = .{ .eflags = true }, |
| | 3379 | .each = .{ .once = &.{ |
| | 3380 | .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_size), ._, ._ }, |
| | 3381 | .{ .@"0:", ._, .mov, .tmp1q, .memiad(.src0q, .tmp0, .add_size, -16), ._, ._ }, |
| | 3382 | .{ ._, ._, .not, .tmp1q, ._, ._, ._ }, |
| | 3383 | .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_size, -16), .tmp1q, ._, ._ }, |
| | 3384 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 3385 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 3386 | .{ ._, ._, .mov, .tmp0d, .memad(.src0d, .add_size, -16), ._, ._ }, |
| | 3387 | .{ ._, ._, .not, .tmp0d, ._, ._, ._ }, |
| | 3388 | .{ ._, ._, .mov, .memad(.dst0d, .add_size, -16), .tmp0d, ._, ._ }, |
| | 3389 | .{ ._, ._, .mov, .memad(.dst0d, .add_size, -16 + 4), .si(0), ._, ._ }, |
| | 3390 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16 + 8), .si(0), ._, ._ }, |
| | 3391 | } }, |
| | 3392 | }, .{ |
| | 3393 | .required_features = .{ .@"64bit", null, null, null }, |
| | 3394 | .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .qword, .is = .qword } }, .any }, |
| | 3395 | .patterns = &.{ |
| | 3396 | .{ .src = .{ .mut_mem, .none } }, |
| | 3397 | }, |
| | 3398 | .extra_temps = .{ |
| | 3399 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 3400 | .unused, |
| | 3401 | .unused, |
| | 3402 | .unused, |
| | 3403 | .unused, |
| | 3404 | .unused, |
| | 3405 | }, |
| | 3406 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 3407 | .clobbers = .{ .eflags = true }, |
| | 3408 | .each = .{ .once = &.{ |
| | 3409 | .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_size), ._, ._ }, |
| | 3410 | .{ .@"0:", ._, .not, .memiad(.dst0q, .tmp0, .add_size, -16), ._, ._, ._ }, |
| | 3411 | .{ ._, ._, .not, .memiad(.dst0q, .tmp0, .add_size, -16 + 8), ._, ._, ._ }, |
| | 3412 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 3413 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 3414 | .{ ._, ._, .not, .memad(.dst0q, .add_size, -16), ._, ._, ._ }, |
| | 3415 | } }, |
| | 3416 | }, .{ |
| | 3417 | .required_features = .{ .@"64bit", null, null, null }, |
| | 3418 | .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .qword, .is = .qword } }, .any }, |
| | 3419 | .patterns = &.{ |
| | 3420 | .{ .src = .{ .to_mem, .none } }, |
| | 3421 | }, |
| | 3422 | .extra_temps = .{ |
| | 3423 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 3424 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 3425 | .unused, |
| | 3426 | .unused, |
| | 3427 | .unused, |
| | 3428 | .unused, |
| | 3429 | }, |
| | 3430 | .dst_temps = .{.mem}, |
| | 3431 | .clobbers = .{ .eflags = true }, |
| | 3432 | .each = .{ .once = &.{ |
| | 3433 | .{ ._, ._, .mov, .tmp0p, .sia(8, .src0, .sub_size), ._, ._ }, |
| | 3434 | .{ .@"0:", ._, .mov, .tmp1q, .memiad(.src0q, .tmp0, .add_size, -8), ._, ._ }, |
| | 3435 | .{ ._, ._, .not, .tmp1q, ._, ._, ._ }, |
| | 3436 | .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_size, -8), .tmp1q, ._, ._ }, |
| | 3437 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 3438 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 3439 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ }, |
| | 3440 | } }, |
| | 3441 | }, .{ |
| | 3442 | .required_features = .{ .@"64bit", null, null, null }, |
| | 3443 | .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .dword, .is = .dword } }, .any }, |
| | 3444 | .patterns = &.{ |
| | 3445 | .{ .src = .{ .mut_mem, .none } }, |
| | 3446 | }, |
| | 3447 | .extra_temps = .{ |
| | 3448 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 3449 | .unused, |
| | 3450 | .unused, |
| | 3451 | .unused, |
| | 3452 | .unused, |
| | 3453 | .unused, |
| | 3454 | }, |
| | 3455 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 3456 | .clobbers = .{ .eflags = true }, |
| | 3457 | .each = .{ .once = &.{ |
| | 3458 | .{ ._, ._, .mov, .tmp0p, .sia(8, .src0, .sub_size), ._, ._ }, |
| | 3459 | .{ .@"0:", ._, .not, .memiad(.dst0q, .tmp0, .add_size, -8), ._, ._, ._ }, |
| | 3460 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 3461 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 3462 | .{ ._, ._, .not, .memad(.dst0d, .add_size, -8), ._, ._, ._ }, |
| | 3463 | } }, |
| | 3464 | }, .{ |
| | 3465 | .required_features = .{ .@"64bit", null, null, null }, |
| | 3466 | .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .dword, .is = .dword } }, .any }, |
| | 3467 | .patterns = &.{ |
| | 3468 | .{ .src = .{ .to_mem, .none } }, |
| | 3469 | }, |
| | 3470 | .extra_temps = .{ |
| | 3471 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 3472 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 3473 | .unused, |
| | 3474 | .unused, |
| | 3475 | .unused, |
| | 3476 | .unused, |
| | 3477 | }, |
| | 3478 | .dst_temps = .{.mem}, |
| | 3479 | .clobbers = .{ .eflags = true }, |
| | 3480 | .each = .{ .once = &.{ |
| | 3481 | .{ ._, ._, .mov, .tmp0p, .sia(8, .src0, .sub_size), ._, ._ }, |
| | 3482 | .{ .@"0:", ._, .mov, .tmp1q, .memiad(.src0q, .tmp0, .add_size, -8), ._, ._ }, |
| | 3483 | .{ ._, ._, .not, .tmp1q, ._, ._, ._ }, |
| | 3484 | .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_size, -8), .tmp1q, ._, ._ }, |
| | 3485 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 3486 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 3487 | .{ ._, ._, .mov, .tmp0d, .memad(.src0d, .add_size, -8), ._, ._ }, |
| | 3488 | .{ ._, ._, .not, .tmp0d, ._, ._, ._ }, |
| | 3489 | .{ ._, ._, .mov, .memad(.dst0d, .add_size, -8), .tmp0d, ._, ._ }, |
| | 3490 | .{ ._, ._, .mov, .memad(.dst0d, .add_size, -8 + 4), .si(0), ._, ._ }, |
| | 3491 | } }, |
| | 3492 | }, .{ |
| | 3493 | .required_features = .{ .@"64bit", null, null, null }, |
| | 3494 | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .dword } }, .any }, |
| | 3495 | .patterns = &.{ |
| | 3496 | .{ .src = .{ .mut_mem, .none } }, |
| | 3497 | }, |
| | 3498 | .extra_temps = .{ |
| | 3499 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 3500 | .unused, |
| | 3501 | .unused, |
| | 3502 | .unused, |
| | 3503 | .unused, |
| | 3504 | .unused, |
| | 3505 | }, |
| | 3506 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 3507 | .clobbers = .{ .eflags = true }, |
| | 3508 | .each = .{ .once = &.{ |
| | 3509 | .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_size), ._, ._ }, |
| | 3510 | .{ .@"0:", ._, .not, .memiad(.dst0q, .tmp0, .add_size, -16), ._, ._, ._ }, |
| | 3511 | .{ ._, ._, .not, .memiad(.dst0q, .tmp0, .add_size, -16 + 8), ._, ._, ._ }, |
| | 3512 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 3513 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 3514 | .{ ._, ._, .xor, .memad(.dst0d, .add_size, -16), .sa(.src0, .add_umax), ._, ._ }, |
| | 3515 | } }, |
| | 3516 | }, .{ |
| | 3517 | .required_features = .{ .@"64bit", null, null, null }, |
| | 3518 | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .dword } }, .any }, |
| | 3519 | .patterns = &.{ |
| | 3520 | .{ .src = .{ .to_mem, .none } }, |
| | 3521 | }, |
| | 3522 | .extra_temps = .{ |
| | 3523 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 3524 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 3525 | .unused, |
| | 3526 | .unused, |
| | 3527 | .unused, |
| | 3528 | .unused, |
| | 3529 | }, |
| | 3530 | .dst_temps = .{.mem}, |
| | 3531 | .clobbers = .{ .eflags = true }, |
| | 3532 | .each = .{ .once = &.{ |
| | 3533 | .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_size), ._, ._ }, |
| | 3534 | .{ .@"0:", ._, .mov, .tmp1q, .memiad(.src0q, .tmp0, .add_size, -16), ._, ._ }, |
| | 3535 | .{ ._, ._, .not, .tmp1q, ._, ._, ._ }, |
| | 3536 | .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_size, -16), .tmp1q, ._, ._ }, |
| | 3537 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 3538 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 3539 | .{ ._, ._, .mov, .tmp0d, .memad(.src0d, .add_size, -16), ._, ._ }, |
| | 3540 | .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_umax), ._, ._ }, |
| | 3541 | .{ ._, ._, .mov, .memad(.dst0d, .add_size, -16), .tmp0d, ._, ._ }, |
| | 3542 | .{ ._, ._, .mov, .memad(.dst0d, .add_size, -16 + 4), .si(0), ._, ._ }, |
| | 3543 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16 + 8), .si(0), ._, ._ }, |
| | 3544 | } }, |
| | 3545 | }, .{ |
| | 3546 | .required_features = .{ .@"64bit", null, null, null }, |
| | 3547 | .src_constraints = .{ .{ .remainder_int = .{ .of = .qword, .is = .dword } }, .any }, |
| | 3548 | .patterns = &.{ |
| | 3549 | .{ .src = .{ .mut_mem, .none } }, |
| | 3550 | }, |
| | 3551 | .extra_temps = .{ |
| | 3552 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 3553 | .unused, |
| | 3554 | .unused, |
| | 3555 | .unused, |
| | 3556 | .unused, |
| | 3557 | .unused, |
| | 3558 | }, |
| | 3559 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 3560 | .clobbers = .{ .eflags = true }, |
| | 3561 | .each = .{ .once = &.{ |
| | 3562 | .{ ._, ._, .mov, .tmp0p, .sia(8, .src0, .sub_size), ._, ._ }, |
| | 3563 | .{ .@"0:", ._, .not, .memiad(.dst0q, .tmp0, .add_size, -8), ._, ._, ._ }, |
| | 3564 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 3565 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 3566 | .{ ._, ._, .xor, .memad(.dst0d, .add_size, -8), .sa(.src0, .add_umax), ._, ._ }, |
| | 3567 | } }, |
| | 3568 | }, .{ |
| | 3569 | .required_features = .{ .@"64bit", null, null, null }, |
| | 3570 | .src_constraints = .{ .{ .remainder_int = .{ .of = .qword, .is = .dword } }, .any }, |
| | 3571 | .patterns = &.{ |
| | 3572 | .{ .src = .{ .to_mem, .none } }, |
| | 3573 | }, |
| | 3574 | .extra_temps = .{ |
| | 3575 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 3576 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 3577 | .unused, |
| | 3578 | .unused, |
| | 3579 | .unused, |
| | 3580 | .unused, |
| | 3581 | }, |
| | 3582 | .dst_temps = .{.mem}, |
| | 3583 | .clobbers = .{ .eflags = true }, |
| | 3584 | .each = .{ .once = &.{ |
| | 3585 | .{ ._, ._, .mov, .tmp0p, .sia(8, .src0, .sub_size), ._, ._ }, |
| | 3586 | .{ .@"0:", ._, .mov, .tmp1q, .memiad(.src0q, .tmp0, .add_size, -8), ._, ._ }, |
| | 3587 | .{ ._, ._, .not, .tmp1q, ._, ._, ._ }, |
| | 3588 | .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_size, -8), .tmp1q, ._, ._ }, |
| | 3589 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 3590 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 3591 | .{ ._, ._, .mov, .tmp0d, .memad(.src0d, .add_size, -8), ._, ._ }, |
| | 3592 | .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_umax), ._, ._ }, |
| | 3593 | .{ ._, ._, .mov, .memad(.dst0d, .add_size, -8), .tmp0d, ._, ._ }, |
| | 3594 | .{ ._, ._, .mov, .memad(.dst0d, .add_size, -8 + 4), .si(0), ._, ._ }, |
| | 3595 | } }, |
| | 3596 | }, .{ |
| | 3597 | .required_features = .{ .@"64bit", null, null, null }, |
| | 3598 | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .qword } }, .any }, |
| | 3599 | .patterns = &.{ |
| | 3600 | .{ .src = .{ .mut_mem, .none } }, |
| | 3601 | }, |
| | 3602 | .extra_temps = .{ |
| | 3603 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 3604 | .unused, |
| | 3605 | .unused, |
| | 3606 | .unused, |
| | 3607 | .unused, |
| | 3608 | .unused, |
| | 3609 | }, |
| | 3610 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 3611 | .clobbers = .{ .eflags = true }, |
| | 3612 | .each = .{ .once = &.{ |
| | 3613 | .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_size), ._, ._ }, |
| | 3614 | .{ .@"0:", ._, .not, .memiad(.dst0q, .tmp0, .add_size, -16), ._, ._, ._ }, |
| | 3615 | .{ ._, ._, .not, .memiad(.dst0q, .tmp0, .add_size, -16 + 8), ._, ._, ._ }, |
| | 3616 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 3617 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 3618 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ }, |
| | 3619 | .{ ._, ._, .xor, .memad(.dst0q, .add_size, -16), .tmp0q, ._, ._ }, |
| | 3620 | } }, |
| | 3621 | }, .{ |
| | 3622 | .required_features = .{ .@"64bit", null, null, null }, |
| | 3623 | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .qword } }, .any }, |
| | 3624 | .patterns = &.{ |
| | 3625 | .{ .src = .{ .to_mem, .none } }, |
| | 3626 | }, |
| | 3627 | .extra_temps = .{ |
| | 3628 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 3629 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 3630 | .unused, |
| | 3631 | .unused, |
| | 3632 | .unused, |
| | 3633 | .unused, |
| | 3634 | }, |
| | 3635 | .dst_temps = .{.mem}, |
| | 3636 | .clobbers = .{ .eflags = true }, |
| | 3637 | .each = .{ .once = &.{ |
| | 3638 | .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_size), ._, ._ }, |
| | 3639 | .{ .@"0:", ._, .mov, .tmp1q, .memiad(.src0q, .tmp0, .add_size, -16), ._, ._ }, |
| | 3640 | .{ ._, ._, .not, .tmp1q, ._, ._, ._ }, |
| | 3641 | .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_size, -16), .tmp1q, ._, ._ }, |
| | 3642 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 3643 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 3644 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ }, |
| | 3645 | .{ ._, ._, .xor, .tmp0q, .memad(.src0q, .add_size, -16), ._, ._ }, |
| | 3646 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp0q, ._, ._ }, |
| | 3647 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ }, |
| | 3648 | } }, |
| | 3649 | }, .{ |
| | 3650 | .required_features = .{ .@"64bit", null, null, null }, |
| | 3651 | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| | 3652 | .patterns = &.{ |
| | 3653 | .{ .src = .{ .mut_mem, .none } }, |
| | 3654 | }, |
| | 3655 | .extra_temps = .{ |
| | 3656 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 3657 | .unused, |
| | 3658 | .unused, |
| | 3659 | .unused, |
| | 3660 | .unused, |
| | 3661 | .unused, |
| | 3662 | }, |
| | 3663 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 3664 | .clobbers = .{ .eflags = true }, |
| | 3665 | .each = .{ .once = &.{ |
| | 3666 | .{ ._, ._, .mov, .tmp0p, .sia(8, .src0, .sub_size), ._, ._ }, |
| | 3667 | .{ .@"0:", ._, .not, .memiad(.dst0q, .tmp0, .add_size, -8), ._, ._, ._ }, |
| | 3668 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 3669 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 3670 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ }, |
| | 3671 | .{ ._, ._, .xor, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ }, |
| | 3672 | } }, |
| | 3673 | }, .{ |
| | 3674 | .required_features = .{ .@"64bit", null, null, null }, |
| | 3675 | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| | 3676 | .patterns = &.{ |
| | 3677 | .{ .src = .{ .to_mem, .none } }, |
| | 3678 | }, |
| | 3679 | .extra_temps = .{ |
| | 3680 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 3681 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 3682 | .unused, |
| | 3683 | .unused, |
| | 3684 | .unused, |
| | 3685 | .unused, |
| | 3686 | }, |
| | 3687 | .dst_temps = .{.mem}, |
| | 3688 | .clobbers = .{ .eflags = true }, |
| | 3689 | .each = .{ .once = &.{ |
| | 3690 | .{ ._, ._, .mov, .tmp0p, .sia(8, .src0, .sub_size), ._, ._ }, |
| | 3691 | .{ .@"0:", ._, .mov, .tmp1q, .memiad(.src0q, .tmp0, .add_size, -8), ._, ._ }, |
| | 3692 | .{ ._, ._, .not, .tmp1q, ._, ._, ._ }, |
| | 3693 | .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_size, -8), .tmp1q, ._, ._ }, |
| | 3694 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 3695 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 3696 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ }, |
| | 3697 | .{ ._, ._, .xor, .tmp0q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 3698 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ }, |
| | 3699 | } }, |
| | 3700 | }, .{ |
| | 3701 | .required_features = .{ .mmx, null, null, null }, |
| | 3702 | .src_constraints = .{ .{ .signed_int_or_full_vec = .qword }, .any }, |
| | 3703 | .patterns = &.{ |
| | 3704 | .{ .src = .{ .mem, .none } }, |
| | 3705 | .{ .src = .{ .to_mm, .none } }, |
| | 3706 | }, |
| | 3707 | .dst_temps = .{.{ .rc = .mmx }}, |
| | 3708 | .each = .{ .once = &.{ |
| | 3709 | .{ ._, .p_d, .cmpeq, .dst0q, .dst0q, ._, ._ }, |
| | 3710 | .{ ._, .p_, .xor, .dst0q, .src0q, ._, ._ }, |
| | 3711 | } }, |
| | 3712 | }, .{ |
| | 3713 | .required_features = .{ .mmx, null, null, null }, |
| | 3714 | .src_constraints = .{ .{ .unsigned_int_vec = .qword }, .any }, |
| | 3715 | .patterns = &.{ |
| | 3716 | .{ .src = .{ .to_mut_mm, .none } }, |
| | 3717 | }, |
| | 3718 | .extra_temps = .{ |
| | 3719 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 3720 | .{ .kind = .{ .umax_mem = .src0 } }, |
| | 3721 | .unused, |
| | 3722 | .unused, |
| | 3723 | .unused, |
| | 3724 | .unused, |
| | 3725 | }, |
| | 3726 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 3727 | .each = .{ .once = &.{ |
| | 3728 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 3729 | .{ ._, .p_, .xor, .dst0q, .lea(.qword, .tmp0), ._, ._ }, |
| | 3730 | } }, |
| | 3731 | }, .{ |
| | 3732 | .required_features = .{ .avx, null, null, null }, |
| | 3733 | .src_constraints = .{ .{ .signed_int_or_full_vec = .xword }, .any }, |
| | 3734 | .patterns = &.{ |
| | 3735 | .{ .src = .{ .mem, .none } }, |
| | 3736 | .{ .src = .{ .to_xmm, .none } }, |
| | 3737 | }, |
| | 3738 | .dst_temps = .{.{ .rc = .sse }}, |
| | 3739 | .each = .{ .once = &.{ |
| | 3740 | .{ ._, .vp_q, .cmpeq, .dst0x, .dst0x, .dst0x, ._ }, |
| | 3741 | .{ ._, .vp_, .xor, .dst0x, .dst0x, .src0x, ._ }, |
| | 3742 | } }, |
| | 3743 | }, .{ |
| | 3744 | .required_features = .{ .avx, null, null, null }, |
| | 3745 | .src_constraints = .{ .{ .unsigned_int_vec = .xword }, .any }, |
| | 3746 | .patterns = &.{ |
| | 3747 | .{ .src = .{ .to_xmm, .none } }, |
| | 3748 | }, |
| | 3749 | .extra_temps = .{ |
| | 3750 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 3751 | .{ .kind = .{ .umax_mem = .src0 } }, |
| | 3752 | .unused, |
| | 3753 | .unused, |
| | 3754 | .unused, |
| | 3755 | .unused, |
| | 3756 | }, |
| | 3757 | .dst_temps = .{.{ .rc = .sse }}, |
| | 3758 | .each = .{ .once = &.{ |
| | 3759 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 3760 | .{ ._, .vp_, .xor, .dst0x, .src0x, .lea(.xword, .tmp0), ._ }, |
| | 3761 | } }, |
| | 3762 | }, .{ |
| | 3763 | .required_features = .{ .sse2, null, null, null }, |
| | 3764 | .src_constraints = .{ .{ .signed_int_or_full_vec = .xword }, .any }, |
| | 3765 | .patterns = &.{ |
| | 3766 | .{ .src = .{ .mem, .none } }, |
| | 3767 | .{ .src = .{ .to_xmm, .none } }, |
| | 3768 | }, |
| | 3769 | .dst_temps = .{.{ .rc = .sse }}, |
| | 3770 | .each = .{ .once = &.{ |
| | 3771 | .{ ._, .p_d, .cmpeq, .dst0x, .dst0x, ._, ._ }, |
| | 3772 | .{ ._, .p_, .xor, .dst0x, .src0x, ._, ._ }, |
| | 3773 | } }, |
| | 3774 | }, .{ |
| | 3775 | .required_features = .{ .sse2, null, null, null }, |
| | 3776 | .src_constraints = .{ .{ .unsigned_int_vec = .xword }, .any }, |
| | 3777 | .patterns = &.{ |
| | 3778 | .{ .src = .{ .to_mut_xmm, .none } }, |
| | 3779 | }, |
| | 3780 | .extra_temps = .{ |
| | 3781 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 3782 | .{ .kind = .{ .umax_mem = .src0 } }, |
| | 3783 | .unused, |
| | 3784 | .unused, |
| | 3785 | .unused, |
| | 3786 | .unused, |
| | 3787 | }, |
| | 3788 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 3789 | .each = .{ .once = &.{ |
| | 3790 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 3791 | .{ ._, .p_, .xor, .dst0x, .lea(.xword, .tmp0), ._, ._ }, |
| | 3792 | } }, |
| | 3793 | }, .{ |
| | 3794 | .required_features = .{ .sse, null, null, null }, |
| | 3795 | .src_constraints = .{ .{ .vec = .xword }, .any }, |
| | 3796 | .patterns = &.{ |
| | 3797 | .{ .src = .{ .to_mut_xmm, .none } }, |
| | 3798 | }, |
| | 3799 | .extra_temps = .{ |
| | 3800 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 3801 | .{ .kind = .{ .umax_mem = .src0 } }, |
| | 3802 | .unused, |
| | 3803 | .unused, |
| | 3804 | .unused, |
| | 3805 | .unused, |
| | 3806 | }, |
| | 3807 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 3808 | .each = .{ .once = &.{ |
| | 3809 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 3810 | .{ ._, ._ps, .xor, .dst0x, .lea(.xword, .tmp0), ._, ._ }, |
| | 3811 | } }, |
| | 3812 | }, .{ |
| | 3813 | .required_features = .{ .avx2, null, null, null }, |
| | 3814 | .src_constraints = .{ .{ .signed_int_or_full_vec = .yword }, .any }, |
| | 3815 | .patterns = &.{ |
| | 3816 | .{ .src = .{ .mem, .none } }, |
| | 3817 | .{ .src = .{ .to_ymm, .none } }, |
| | 3818 | }, |
| | 3819 | .dst_temps = .{.{ .rc = .sse }}, |
| | 3820 | .each = .{ .once = &.{ |
| | 3821 | .{ ._, .vp_q, .cmpeq, .dst0y, .dst0y, .dst0y, ._ }, |
| | 3822 | .{ ._, .vp_, .xor, .dst0y, .dst0y, .src0y, ._ }, |
| | 3823 | } }, |
| | 3824 | }, .{ |
| | 3825 | .required_features = .{ .avx2, null, null, null }, |
| | 3826 | .src_constraints = .{ .{ .unsigned_int_vec = .yword }, .any }, |
| | 3827 | .patterns = &.{ |
| | 3828 | .{ .src = .{ .to_ymm, .none } }, |
| | 3829 | }, |
| | 3830 | .extra_temps = .{ |
| | 3831 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 3832 | .{ .kind = .{ .umax_mem = .src0 } }, |
| | 3833 | .unused, |
| | 3834 | .unused, |
| | 3835 | .unused, |
| | 3836 | .unused, |
| | 3837 | }, |
| | 3838 | .dst_temps = .{.{ .rc = .sse }}, |
| | 3839 | .each = .{ .once = &.{ |
| | 3840 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 3841 | .{ ._, .vp_, .xor, .dst0y, .src0y, .lea(.yword, .tmp0), ._ }, |
| | 3842 | } }, |
| | 3843 | }, .{ |
| | 3844 | .required_features = .{ .avx, null, null, null }, |
| | 3845 | .src_constraints = .{ .{ .signed_int_or_full_vec = .yword }, .any }, |
| | 3846 | .patterns = &.{ |
| | 3847 | .{ .src = .{ .mem, .none } }, |
| | 3848 | .{ .src = .{ .to_ymm, .none } }, |
| | 3849 | }, |
| | 3850 | .dst_temps = .{.{ .rc = .sse }}, |
| | 3851 | .each = .{ .once = &.{ |
| | 3852 | .{ ._, .v_pd, .cmp, .dst0y, .dst0y, .dst0y, .si(0b01111) }, |
| | 3853 | .{ ._, .v_pd, .xor, .dst0y, .dst0y, .src0y, ._ }, |
| | 3854 | } }, |
| | 3855 | }, .{ |
| | 3856 | .required_features = .{ .avx, null, null, null }, |
| | 3857 | .src_constraints = .{ .{ .unsigned_int_vec = .yword }, .any }, |
| | 3858 | .patterns = &.{ |
| | 3859 | .{ .src = .{ .to_ymm, .none } }, |
| | 3860 | }, |
| | 3861 | .extra_temps = .{ |
| | 3862 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 3863 | .{ .kind = .{ .umax_mem = .src0 } }, |
| | 3864 | .unused, |
| | 3865 | .unused, |
| | 3866 | .unused, |
| | 3867 | .unused, |
| | 3868 | }, |
| | 3869 | .dst_temps = .{.{ .rc = .sse }}, |
| | 3870 | .each = .{ .once = &.{ |
| | 3871 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 3872 | .{ ._, .v_pd, .xor, .dst0y, .src0y, .lea(.yword, .tmp0), ._ }, |
| | 3873 | } }, |
| | 3874 | }, .{ |
| | 3875 | .required_features = .{ .@"64bit", null, null, null }, |
| | 3876 | .patterns = &.{ |
| | 3877 | .{ .src = .{ .to_mem, .none } }, |
| | 3878 | }, |
| | 3879 | .extra_temps = .{ |
| | 3880 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 3881 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 3882 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 3883 | .{ .kind = .{ .umax_mem = .src0 } }, |
| | 3884 | .unused, |
| | 3885 | .unused, |
| | 3886 | }, |
| | 3887 | .dst_temps = .{.mem}, |
| | 3888 | .each = .{ .once = &.{ |
| | 3889 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_src0_size), ._, ._ }, |
| | 3890 | .{ ._, ._, .lea, .tmp1p, .mem(.tmp3), ._, ._ }, |
| | 3891 | .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_src0_size), ._, ._ }, |
| | 3892 | .{ ._, ._, .xor, .tmp2q, .leaia(.qword, .tmp1, .tmp0, .add_src0_size), ._, ._ }, |
| | 3893 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_src0_size), .tmp2q, ._, ._ }, |
| | 3894 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 3895 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 3896 | } }, |
| | 3897 | }, .{ |
| | 3898 | .patterns = &.{ |
| | 3899 | .{ .src = .{ .to_mem, .none } }, |
| | 3900 | }, |
| | 3901 | .extra_temps = .{ |
| | 3902 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 3903 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 3904 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 3905 | .{ .kind = .{ .umax_mem = .src0 } }, |
| | 3906 | .unused, |
| | 3907 | .unused, |
| | 3908 | }, |
| | 3909 | .dst_temps = .{.mem}, |
| | 3910 | .each = .{ .once = &.{ |
| | 3911 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_src0_size), ._, ._ }, |
| | 3912 | .{ ._, ._, .lea, .tmp1p, .mem(.tmp3), ._, ._ }, |
| | 3913 | .{ .@"0:", ._, .mov, .tmp2d, .memia(.src0d, .tmp0, .add_src0_size), ._, ._ }, |
| | 3914 | .{ ._, ._, .xor, .tmp2d, .leaia(.dword, .tmp1, .tmp0, .add_src0_size), ._, ._ }, |
| | 3915 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_src0_size), .tmp2d, ._, ._ }, |
| | 3916 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| | 3917 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 3918 | } }, |
| | 3919 | } }) catch |err| switch (err) { |
| | 3920 | error.SelectFailed => return cg.fail("failed to select {s} {} {}", .{ |
| | 3921 | @tagName(air_tag), |
| | 3922 | cg.typeOf(ty_op.operand).fmt(pt), |
| | 3923 | ops[0].tracking(cg), |
| | 3924 | }), |
| | 3925 | else => |e| return e, |
| | 3926 | }; |
| | 3927 | if (ops[0].index != res[0].index) try ops[0].die(cg); |
| | 3928 | try res[0].moveTo(inst, cg); |
| | 3929 | }, |
| | 3930 | |
| 2833 | .block => if (use_old) try cg.airBlock(inst) else { | 3931 | .block => if (use_old) try cg.airBlock(inst) else { |
| 2834 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; | 3932 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| 2835 | const extra = cg.air.extraData(Air.Block, ty_pl.payload); | 3933 | const extra = cg.air.extraData(Air.Block, ty_pl.payload); |
| ... | @@ -2880,91 +3978,2760 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2880,91 +3978,2760 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2880 | .call_never_tail => try cg.airCall(inst, .never_tail), | 3978 | .call_never_tail => try cg.airCall(inst, .never_tail), |
| 2881 | .call_never_inline => try cg.airCall(inst, .never_inline), | 3979 | .call_never_inline => try cg.airCall(inst, .never_inline), |
| 2882 | | 3980 | |
| 2883 | .cmp_vector, .cmp_vector_optimized => |air_tag| if (use_old) try cg.airCmpVector(inst) else fallback: { | 3981 | .clz => |air_tag| if (use_old) try cg.airClz(inst) else { |
| 2884 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; | 3982 | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 2885 | const extra = cg.air.extraData(Air.VectorCmp, ty_pl.payload).data; | 3983 | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 2886 | switch (extra.compareOperator()) { | | |
| 2887 | .eq, .neq => {}, | | |
| 2888 | else => break :fallback try cg.airCmpVector(inst), | | |
| 2889 | } | | |
| 2890 | var ops = try cg.tempsFromOperands(inst, .{ extra.lhs, extra.rhs }); | | |
| 2891 | var res: [1]Temp = undefined; | 3984 | var res: [1]Temp = undefined; |
| 2892 | switch (extra.compareOperator()) { | 3985 | cg.select(&res, &.{cg.typeOfIndex(inst)}, &ops, comptime &.{ .{ |
| 2893 | .lt => unreachable, | 3986 | .required_features = .{ .slow_incdec, null, null, null }, |
| 2894 | .lte => unreachable, | 3987 | .src_constraints = .{ .{ .exact_signed_int = 1 }, .any }, |
| 2895 | .eq, .neq => |cmp_op| cg.select(&res, &.{cg.typeOfIndex(inst)}, &ops, switch (@as(Condition, switch (cmp_op) { | 3988 | .patterns = &.{ |
| 2896 | else => unreachable, | 3989 | .{ .src = .{ .mut_mem, .none } }, |
| 2897 | .eq => .e, | 3990 | .{ .src = .{ .to_mut_gpr, .none } }, |
| 2898 | .neq => .ne, | 3991 | }, |
| 2899 | })) { | 3992 | .dst_temps = .{.{ .ref = .src0 }}, |
| 2900 | else => unreachable, | 3993 | .clobbers = .{ .eflags = true }, |
| 2901 | inline .e, .ne => |cc| comptime &.{ .{ | 3994 | .each = .{ .once = &.{ |
| 2902 | .required_features = .{ .avx2, null }, | 3995 | .{ ._, ._, .add, .dst0b, .si(1), ._, ._ }, |
| 2903 | .src_constraints = .{ .{ .int = .byte }, .{ .int = .byte } }, | 3996 | } }, |
| 2904 | .patterns = &.{ | 3997 | }, .{ |
| 2905 | .{ .src = .{ .ymm, .mem } }, | 3998 | .src_constraints = .{ .{ .exact_signed_int = 1 }, .any }, |
| 2906 | .{ .src = .{ .mem, .ymm }, .commute = .{ 0, 1 } }, | 3999 | .patterns = &.{ |
| 2907 | .{ .src = .{ .ymm, .ymm } }, | 4000 | .{ .src = .{ .mut_mem, .none } }, |
| 2908 | }, | 4001 | .{ .src = .{ .to_mut_gpr, .none } }, |
| 2909 | .dst_temps = .{.{ .rc_mask = .{ .rc = .sse, .info = .{ | 4002 | }, |
| 2910 | .kind = .all, | 4003 | .dst_temps = .{.{ .ref = .src0 }}, |
| 2911 | .inverted = switch (cc) { | 4004 | .clobbers = .{ .eflags = true }, |
| 2912 | else => unreachable, | 4005 | .each = .{ .once = &.{ |
| 2913 | .e => false, | 4006 | .{ ._, ._, .inc, .dst0b, ._, ._, ._ }, |
| 2914 | .ne => true, | 4007 | } }, |
| 2915 | }, | 4008 | }, .{ |
| 2916 | .scalar = .byte, | 4009 | .src_constraints = .{ .{ .exact_unsigned_int = 1 }, .any }, |
| 2917 | } } }}, | 4010 | .patterns = &.{ |
| 2918 | .each = .{ .once = &.{ | 4011 | .{ .src = .{ .mut_mem, .none } }, |
| 2919 | .{ ._, .vp_b, .cmpeq, .dst0y, .src0y, .src1y, ._ }, | 4012 | .{ .src = .{ .to_mut_gpr, .none } }, |
| 2920 | } }, | 4013 | }, |
| 2921 | }, .{ | 4014 | .dst_temps = .{.{ .ref = .src0 }}, |
| 2922 | .required_features = .{ .avx2, null }, | 4015 | .clobbers = .{ .eflags = true }, |
| 2923 | .src_constraints = .{ .{ .int = .word }, .{ .int = .word } }, | 4016 | .each = .{ .once = &.{ |
| 2924 | .patterns = &.{ | 4017 | .{ ._, ._, .xor, .dst0b, .si(1), ._, ._ }, |
| 2925 | .{ .src = .{ .ymm, .mem } }, | 4018 | } }, |
| 2926 | .{ .src = .{ .mem, .ymm }, .commute = .{ 0, 1 } }, | 4019 | }, .{ |
| 2927 | .{ .src = .{ .ymm, .ymm } }, | 4020 | .required_features = .{ .lzcnt, null, null, null }, |
| 2928 | }, | 4021 | .src_constraints = .{ .{ .unsigned_or_exact_int = .byte }, .any }, |
| 2929 | .dst_temps = .{.{ .rc_mask = .{ .rc = .sse, .info = .{ | 4022 | .patterns = &.{ |
| 2930 | .kind = .all, | 4023 | .{ .src = .{ .mem, .none } }, |
| 2931 | .inverted = switch (cc) { | 4024 | .{ .src = .{ .to_gpr, .none } }, |
| 2932 | else => unreachable, | 4025 | }, |
| 2933 | .e => false, | 4026 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 2934 | .ne => true, | 4027 | .clobbers = .{ .eflags = true }, |
| 2935 | }, | 4028 | .each = .{ .once = &.{ |
| 2936 | .scalar = .word, | 4029 | .{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ }, |
| 2937 | } } }}, | 4030 | .{ ._, ._, .lzcnt, .dst0d, .dst0d, ._, ._ }, |
| 2938 | .each = .{ .once = &.{ | 4031 | .{ ._, ._, .sub, .dst0b, .sia(32, .src0, .sub_bit_size), ._, ._ }, |
| 2939 | .{ ._, .vp_w, .cmpeq, .dst0y, .src0y, .src1y, ._ }, | 4032 | } }, |
| 2940 | } }, | 4033 | }, .{ |
| 2941 | }, .{ | 4034 | .required_features = .{ .lzcnt, null, null, null }, |
| 2942 | .required_features = .{ .avx2, null }, | 4035 | .src_constraints = .{ .{ .signed_int = .byte }, .any }, |
| 2943 | .src_constraints = .{ .{ .int = .dword }, .{ .int = .dword } }, | 4036 | .patterns = &.{ |
| 2944 | .patterns = &.{ | 4037 | .{ .src = .{ .mem, .none } }, |
| 2945 | .{ .src = .{ .ymm, .mem } }, | 4038 | .{ .src = .{ .to_gpr, .none } }, |
| 2946 | .{ .src = .{ .mem, .ymm }, .commute = .{ 0, 1 } }, | 4039 | }, |
| 2947 | .{ .src = .{ .ymm, .ymm } }, | 4040 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 2948 | }, | 4041 | .clobbers = .{ .eflags = true }, |
| 2949 | .dst_temps = .{.{ .rc_mask = .{ .rc = .sse, .info = .{ | 4042 | .each = .{ .once = &.{ |
| 2950 | .kind = .all, | 4043 | .{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ }, |
| 2951 | .inverted = switch (cc) { | 4044 | .{ ._, ._, .@"and", .dst0d, .sa(.src0, .add_umax), ._, ._ }, |
| 2952 | else => unreachable, | 4045 | .{ ._, ._, .lzcnt, .dst0d, .dst0d, ._, ._ }, |
| 2953 | .e => false, | 4046 | .{ ._, ._, .sub, .dst0b, .sia(32, .src0, .sub_bit_size), ._, ._ }, |
| 2954 | .ne => true, | 4047 | } }, |
| 2955 | }, | 4048 | }, .{ |
| 2956 | .scalar = .dword, | 4049 | .required_features = .{ .false_deps_lzcnt_tzcnt, .lzcnt, null, null }, |
| 2957 | } } }}, | 4050 | .src_constraints = .{ .{ .exact_int = 16 }, .any }, |
| 2958 | .each = .{ .once = &.{ | 4051 | .patterns = &.{ |
| 2959 | .{ ._, .vp_d, .cmpeq, .dst0y, .src0y, .src1y, ._ }, | 4052 | .{ .src = .{ .to_mut_gpr, .none } }, |
| 2960 | } }, | 4053 | }, |
| 2961 | }, .{ | 4054 | .dst_temps = .{.{ .ref = .src0 }}, |
| 2962 | .required_features = .{ .avx2, null }, | 4055 | .clobbers = .{ .eflags = true }, |
| 2963 | .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword } }, | 4056 | .each = .{ .once = &.{ |
| 2964 | .patterns = &.{ | 4057 | .{ ._, ._, .lzcnt, .dst0w, .src0w, ._, ._ }, |
| 2965 | .{ .src = .{ .ymm, .mem } }, | 4058 | } }, |
| 2966 | .{ .src = .{ .mem, .ymm }, .commute = .{ 0, 1 } }, | 4059 | }, .{ |
| 2967 | .{ .src = .{ .ymm, .ymm } }, | 4060 | .required_features = .{ .lzcnt, null, null, null }, |
| | 4061 | .src_constraints = .{ .{ .exact_int = 16 }, .any }, |
| | 4062 | .patterns = &.{ |
| | 4063 | .{ .src = .{ .mem, .none } }, |
| | 4064 | .{ .src = .{ .to_gpr, .none } }, |
| | 4065 | }, |
| | 4066 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4067 | .clobbers = .{ .eflags = true }, |
| | 4068 | .each = .{ .once = &.{ |
| | 4069 | .{ ._, ._, .lzcnt, .dst0w, .src0w, ._, ._ }, |
| | 4070 | } }, |
| | 4071 | }, .{ |
| | 4072 | .required_features = .{ .lzcnt, null, null, null }, |
| | 4073 | .src_constraints = .{ .{ .signed_int = .word }, .any }, |
| | 4074 | .patterns = &.{ |
| | 4075 | .{ .src = .{ .to_mut_gpr, .none } }, |
| | 4076 | }, |
| | 4077 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 4078 | .clobbers = .{ .eflags = true }, |
| | 4079 | .each = .{ .once = &.{ |
| | 4080 | .{ ._, ._, .@"and", .src0w, .sa(.src0, .add_umax), ._, ._ }, |
| | 4081 | .{ ._, ._, .lzcnt, .dst0w, .src0w, ._, ._ }, |
| | 4082 | .{ ._, ._, .sub, .dst0b, .sia(16, .src0, .sub_bit_size), ._, ._ }, |
| | 4083 | } }, |
| | 4084 | }, .{ |
| | 4085 | .required_features = .{ .false_deps_lzcnt_tzcnt, .lzcnt, null, null }, |
| | 4086 | .src_constraints = .{ .{ .unsigned_int = .word }, .any }, |
| | 4087 | .patterns = &.{ |
| | 4088 | .{ .src = .{ .to_mut_gpr, .none } }, |
| | 4089 | }, |
| | 4090 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 4091 | .clobbers = .{ .eflags = true }, |
| | 4092 | .each = .{ .once = &.{ |
| | 4093 | .{ ._, ._, .lzcnt, .dst0w, .src0w, ._, ._ }, |
| | 4094 | .{ ._, ._, .sub, .dst0b, .sia(16, .src0, .sub_bit_size), ._, ._ }, |
| | 4095 | } }, |
| | 4096 | }, .{ |
| | 4097 | .required_features = .{ .lzcnt, null, null, null }, |
| | 4098 | .src_constraints = .{ .{ .unsigned_int = .word }, .any }, |
| | 4099 | .patterns = &.{ |
| | 4100 | .{ .src = .{ .mem, .none } }, |
| | 4101 | .{ .src = .{ .to_gpr, .none } }, |
| | 4102 | }, |
| | 4103 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4104 | .clobbers = .{ .eflags = true }, |
| | 4105 | .each = .{ .once = &.{ |
| | 4106 | .{ ._, ._, .lzcnt, .dst0w, .src0w, ._, ._ }, |
| | 4107 | .{ ._, ._, .sub, .dst0b, .sia(16, .src0, .sub_bit_size), ._, ._ }, |
| | 4108 | } }, |
| | 4109 | }, .{ |
| | 4110 | .required_features = .{ .false_deps_lzcnt_tzcnt, .lzcnt, null, null }, |
| | 4111 | .src_constraints = .{ .{ .exact_int = 32 }, .any }, |
| | 4112 | .patterns = &.{ |
| | 4113 | .{ .src = .{ .to_mut_gpr, .none } }, |
| | 4114 | }, |
| | 4115 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 4116 | .clobbers = .{ .eflags = true }, |
| | 4117 | .each = .{ .once = &.{ |
| | 4118 | .{ ._, ._, .lzcnt, .dst0d, .src0d, ._, ._ }, |
| | 4119 | } }, |
| | 4120 | }, .{ |
| | 4121 | .required_features = .{ .lzcnt, null, null, null }, |
| | 4122 | .src_constraints = .{ .{ .exact_int = 32 }, .any }, |
| | 4123 | .patterns = &.{ |
| | 4124 | .{ .src = .{ .mem, .none } }, |
| | 4125 | .{ .src = .{ .to_gpr, .none } }, |
| | 4126 | }, |
| | 4127 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4128 | .clobbers = .{ .eflags = true }, |
| | 4129 | .each = .{ .once = &.{ |
| | 4130 | .{ ._, ._, .lzcnt, .dst0d, .src0d, ._, ._ }, |
| | 4131 | } }, |
| | 4132 | }, .{ |
| | 4133 | .required_features = .{ .lzcnt, null, null, null }, |
| | 4134 | .src_constraints = .{ .{ .signed_int = .dword }, .any }, |
| | 4135 | .patterns = &.{ |
| | 4136 | .{ .src = .{ .to_mut_gpr, .none } }, |
| | 4137 | }, |
| | 4138 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 4139 | .clobbers = .{ .eflags = true }, |
| | 4140 | .each = .{ .once = &.{ |
| | 4141 | .{ ._, ._, .@"and", .src0d, .sa(.src0, .add_umax), ._, ._ }, |
| | 4142 | .{ ._, ._, .lzcnt, .dst0d, .src0d, ._, ._ }, |
| | 4143 | .{ ._, ._, .sub, .dst0b, .sia(32, .src0, .sub_bit_size), ._, ._ }, |
| | 4144 | } }, |
| | 4145 | }, .{ |
| | 4146 | .required_features = .{ .false_deps_lzcnt_tzcnt, .lzcnt, null, null }, |
| | 4147 | .src_constraints = .{ .{ .unsigned_int = .dword }, .any }, |
| | 4148 | .patterns = &.{ |
| | 4149 | .{ .src = .{ .to_mut_gpr, .none } }, |
| | 4150 | }, |
| | 4151 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 4152 | .clobbers = .{ .eflags = true }, |
| | 4153 | .each = .{ .once = &.{ |
| | 4154 | .{ ._, ._, .lzcnt, .dst0d, .src0d, ._, ._ }, |
| | 4155 | .{ ._, ._, .sub, .dst0b, .sia(32, .src0, .sub_bit_size), ._, ._ }, |
| | 4156 | } }, |
| | 4157 | }, .{ |
| | 4158 | .required_features = .{ .lzcnt, null, null, null }, |
| | 4159 | .src_constraints = .{ .{ .unsigned_int = .dword }, .any }, |
| | 4160 | .patterns = &.{ |
| | 4161 | .{ .src = .{ .mem, .none } }, |
| | 4162 | .{ .src = .{ .to_gpr, .none } }, |
| | 4163 | }, |
| | 4164 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4165 | .clobbers = .{ .eflags = true }, |
| | 4166 | .each = .{ .once = &.{ |
| | 4167 | .{ ._, ._, .lzcnt, .dst0d, .src0d, ._, ._ }, |
| | 4168 | .{ ._, ._, .sub, .dst0b, .sia(32, .src0, .sub_bit_size), ._, ._ }, |
| | 4169 | } }, |
| | 4170 | }, .{ |
| | 4171 | .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null }, |
| | 4172 | .src_constraints = .{ .{ .exact_int = 64 }, .any }, |
| | 4173 | .patterns = &.{ |
| | 4174 | .{ .src = .{ .to_mut_gpr, .none } }, |
| | 4175 | }, |
| | 4176 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 4177 | .clobbers = .{ .eflags = true }, |
| | 4178 | .each = .{ .once = &.{ |
| | 4179 | .{ ._, ._, .lzcnt, .dst0q, .src0q, ._, ._ }, |
| | 4180 | } }, |
| | 4181 | }, .{ |
| | 4182 | .required_features = .{ .@"64bit", .lzcnt, null, null }, |
| | 4183 | .src_constraints = .{ .{ .exact_int = 64 }, .any }, |
| | 4184 | .patterns = &.{ |
| | 4185 | .{ .src = .{ .mem, .none } }, |
| | 4186 | .{ .src = .{ .to_gpr, .none } }, |
| | 4187 | }, |
| | 4188 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4189 | .clobbers = .{ .eflags = true }, |
| | 4190 | .each = .{ .once = &.{ |
| | 4191 | .{ ._, ._, .lzcnt, .dst0q, .src0q, ._, ._ }, |
| | 4192 | } }, |
| | 4193 | }, .{ |
| | 4194 | .required_features = .{ .@"64bit", .lzcnt, null, null }, |
| | 4195 | .src_constraints = .{ .{ .signed_int = .qword }, .any }, |
| | 4196 | .patterns = &.{ |
| | 4197 | .{ .src = .{ .mem, .none } }, |
| | 4198 | .{ .src = .{ .to_gpr, .none } }, |
| | 4199 | }, |
| | 4200 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4201 | .clobbers = .{ .eflags = true }, |
| | 4202 | .each = .{ .once = &.{ |
| | 4203 | .{ ._, ._, .mov, .dst0q, .ua(.src0, .add_umax), ._, ._ }, |
| | 4204 | .{ ._, ._, .@"and", .dst0q, .src0q, ._, ._ }, |
| | 4205 | .{ ._, ._, .lzcnt, .dst0q, .dst0q, ._, ._ }, |
| | 4206 | .{ ._, ._, .sub, .dst0b, .sia(64, .src0, .sub_bit_size), ._, ._ }, |
| | 4207 | } }, |
| | 4208 | }, .{ |
| | 4209 | .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null }, |
| | 4210 | .src_constraints = .{ .{ .unsigned_int = .qword }, .any }, |
| | 4211 | .patterns = &.{ |
| | 4212 | .{ .src = .{ .to_mut_gpr, .none } }, |
| | 4213 | }, |
| | 4214 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 4215 | .clobbers = .{ .eflags = true }, |
| | 4216 | .each = .{ .once = &.{ |
| | 4217 | .{ ._, ._, .lzcnt, .dst0q, .src0q, ._, ._ }, |
| | 4218 | .{ ._, ._, .sub, .dst0b, .sia(64, .src0, .sub_bit_size), ._, ._ }, |
| | 4219 | } }, |
| | 4220 | }, .{ |
| | 4221 | .required_features = .{ .@"64bit", .lzcnt, null, null }, |
| | 4222 | .src_constraints = .{ .{ .unsigned_int = .qword }, .any }, |
| | 4223 | .patterns = &.{ |
| | 4224 | .{ .src = .{ .mem, .none } }, |
| | 4225 | .{ .src = .{ .to_gpr, .none } }, |
| | 4226 | }, |
| | 4227 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4228 | .clobbers = .{ .eflags = true }, |
| | 4229 | .each = .{ .once = &.{ |
| | 4230 | .{ ._, ._, .lzcnt, .dst0q, .src0q, ._, ._ }, |
| | 4231 | .{ ._, ._, .sub, .dst0b, .sia(64, .src0, .sub_bit_size), ._, ._ }, |
| | 4232 | } }, |
| | 4233 | }, .{ |
| | 4234 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, |
| | 4235 | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .byte }, .any }, |
| | 4236 | .patterns = &.{ |
| | 4237 | .{ .src = .{ .mem, .none } }, |
| | 4238 | .{ .src = .{ .to_gpr, .none } }, |
| | 4239 | }, |
| | 4240 | .extra_temps = .{ |
| | 4241 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 4242 | .unused, |
| | 4243 | .unused, |
| | 4244 | .unused, |
| | 4245 | .unused, |
| | 4246 | .unused, |
| | 4247 | }, |
| | 4248 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4249 | .clobbers = .{ .eflags = true }, |
| | 4250 | .each = .{ .once = &.{ |
| | 4251 | .{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ }, |
| | 4252 | .{ ._, ._r, .bs, .dst0d, .dst0d, ._, ._ }, |
| | 4253 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_2_bit_size), ._, ._ }, |
| | 4254 | .{ ._, ._z, .cmov, .dst0d, .tmp0d, ._, ._ }, |
| | 4255 | .{ ._, ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 4256 | } }, |
| | 4257 | }, .{ |
| | 4258 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, |
| | 4259 | .src_constraints = .{ .{ .signed_po2_int = .byte }, .any }, |
| | 4260 | .patterns = &.{ |
| | 4261 | .{ .src = .{ .mem, .none } }, |
| | 4262 | .{ .src = .{ .to_gpr, .none } }, |
| | 4263 | }, |
| | 4264 | .extra_temps = .{ |
| | 4265 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 4266 | .unused, |
| | 4267 | .unused, |
| | 4268 | .unused, |
| | 4269 | .unused, |
| | 4270 | .unused, |
| | 4271 | }, |
| | 4272 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4273 | .clobbers = .{ .eflags = true }, |
| | 4274 | .each = .{ .once = &.{ |
| | 4275 | .{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ }, |
| | 4276 | .{ ._, ._, .@"and", .dst0d, .sa(.src0, .add_umax), ._, ._ }, |
| | 4277 | .{ ._, ._r, .bs, .dst0d, .dst0d, ._, ._ }, |
| | 4278 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_2_bit_size), ._, ._ }, |
| | 4279 | .{ ._, ._z, .cmov, .dst0d, .tmp0d, ._, ._ }, |
| | 4280 | .{ ._, ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 4281 | } }, |
| | 4282 | }, .{ |
| | 4283 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, |
| | 4284 | .src_constraints = .{ .{ .signed_int = .byte }, .any }, |
| | 4285 | .patterns = &.{ |
| | 4286 | .{ .src = .{ .mem, .none } }, |
| | 4287 | .{ .src = .{ .to_gpr, .none } }, |
| | 4288 | }, |
| | 4289 | .extra_temps = .{ |
| | 4290 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 4291 | .unused, |
| | 4292 | .unused, |
| | 4293 | .unused, |
| | 4294 | .unused, |
| | 4295 | .unused, |
| | 4296 | }, |
| | 4297 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4298 | .clobbers = .{ .eflags = true }, |
| | 4299 | .each = .{ .once = &.{ |
| | 4300 | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, |
| | 4301 | .{ ._, ._, .@"and", .tmp0d, .sa(.src0, .add_umax), ._, ._ }, |
| | 4302 | .{ ._, ._r, .bs, .tmp0d, .tmp0d, ._, ._ }, |
| | 4303 | .{ ._, ._, .mov, .dst0d, .si(0xff), ._, ._ }, |
| | 4304 | .{ ._, ._z, .cmov, .tmp0d, .dst0d, ._, ._ }, |
| | 4305 | .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 4306 | .{ ._, ._, .sub, .dst0b, .tmp0b, ._, ._ }, |
| | 4307 | } }, |
| | 4308 | }, .{ |
| | 4309 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, |
| | 4310 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any }, |
| | 4311 | .patterns = &.{ |
| | 4312 | .{ .src = .{ .mem, .none } }, |
| | 4313 | .{ .src = .{ .to_gpr, .none } }, |
| | 4314 | }, |
| | 4315 | .extra_temps = .{ |
| | 4316 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 4317 | .unused, |
| | 4318 | .unused, |
| | 4319 | .unused, |
| | 4320 | .unused, |
| | 4321 | .unused, |
| | 4322 | }, |
| | 4323 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4324 | .clobbers = .{ .eflags = true }, |
| | 4325 | .each = .{ .once = &.{ |
| | 4326 | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, |
| | 4327 | .{ ._, ._r, .bs, .tmp0d, .tmp0d, ._, ._ }, |
| | 4328 | .{ ._, ._, .mov, .dst0d, .si(0xff), ._, ._ }, |
| | 4329 | .{ ._, ._z, .cmov, .tmp0d, .dst0d, ._, ._ }, |
| | 4330 | .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 4331 | .{ ._, ._, .sub, .dst0b, .tmp0b, ._, ._ }, |
| | 4332 | } }, |
| | 4333 | }, .{ |
| | 4334 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, |
| | 4335 | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .byte }, .any }, |
| | 4336 | .patterns = &.{ |
| | 4337 | .{ .src = .{ .mem, .none } }, |
| | 4338 | .{ .src = .{ .to_gpr, .none } }, |
| | 4339 | }, |
| | 4340 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4341 | .clobbers = .{ .eflags = true }, |
| | 4342 | .each = .{ .once = &.{ |
| | 4343 | .{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ }, |
| | 4344 | .{ ._, ._r, .bs, .dst0d, .dst0d, ._, ._ }, |
| | 4345 | .{ ._, ._nz, .j, .@"0f", ._, ._, ._ }, |
| | 4346 | .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_2_bit_size), ._, ._ }, |
| | 4347 | .{ .@"0:", ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 4348 | } }, |
| | 4349 | }, .{ |
| | 4350 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, |
| | 4351 | .src_constraints = .{ .{ .signed_po2_int = .byte }, .any }, |
| | 4352 | .patterns = &.{ |
| | 4353 | .{ .src = .{ .mem, .none } }, |
| | 4354 | .{ .src = .{ .to_gpr, .none } }, |
| | 4355 | }, |
| | 4356 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4357 | .clobbers = .{ .eflags = true }, |
| | 4358 | .each = .{ .once = &.{ |
| | 4359 | .{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ }, |
| | 4360 | .{ ._, ._, .@"and", .dst0d, .sa(.src0, .add_umax), ._, ._ }, |
| | 4361 | .{ ._, ._r, .bs, .dst0d, .dst0d, ._, ._ }, |
| | 4362 | .{ ._, ._nz, .j, .@"0f", ._, ._, ._ }, |
| | 4363 | .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_2_bit_size), ._, ._ }, |
| | 4364 | .{ .@"0:", ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 4365 | } }, |
| | 4366 | }, .{ |
| | 4367 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, |
| | 4368 | .src_constraints = .{ .{ .signed_int = .byte }, .any }, |
| | 4369 | .patterns = &.{ |
| | 4370 | .{ .src = .{ .mem, .none } }, |
| | 4371 | .{ .src = .{ .to_gpr, .none } }, |
| | 4372 | }, |
| | 4373 | .extra_temps = .{ |
| | 4374 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 4375 | .unused, |
| | 4376 | .unused, |
| | 4377 | .unused, |
| | 4378 | .unused, |
| | 4379 | .unused, |
| | 4380 | }, |
| | 4381 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4382 | .clobbers = .{ .eflags = true }, |
| | 4383 | .each = .{ .once = &.{ |
| | 4384 | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, |
| | 4385 | .{ ._, ._, .@"and", .tmp0d, .sa(.src0, .add_umax), ._, ._ }, |
| | 4386 | .{ ._, ._r, .bs, .tmp0d, .tmp0d, ._, ._ }, |
| | 4387 | .{ ._, ._, .mov, .dst0b, .sa(.src0, .add_bit_size), ._, ._ }, |
| | 4388 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| | 4389 | .{ ._, ._c, .st, ._, ._, ._, ._ }, |
| | 4390 | .{ ._, ._, .sbb, .dst0b, .tmp0b, ._, ._ }, |
| | 4391 | } }, |
| | 4392 | }, .{ |
| | 4393 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, |
| | 4394 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any }, |
| | 4395 | .patterns = &.{ |
| | 4396 | .{ .src = .{ .mem, .none } }, |
| | 4397 | .{ .src = .{ .to_gpr, .none } }, |
| | 4398 | }, |
| | 4399 | .extra_temps = .{ |
| | 4400 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 4401 | .unused, |
| | 4402 | .unused, |
| | 4403 | .unused, |
| | 4404 | .unused, |
| | 4405 | .unused, |
| | 4406 | }, |
| | 4407 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4408 | .clobbers = .{ .eflags = true }, |
| | 4409 | .each = .{ .once = &.{ |
| | 4410 | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, |
| | 4411 | .{ ._, ._r, .bs, .tmp0d, .tmp0d, ._, ._ }, |
| | 4412 | .{ ._, ._, .mov, .dst0b, .sa(.src0, .add_bit_size), ._, ._ }, |
| | 4413 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| | 4414 | .{ ._, ._c, .st, ._, ._, ._, ._ }, |
| | 4415 | .{ ._, ._, .sbb, .dst0b, .tmp0b, ._, ._ }, |
| | 4416 | } }, |
| | 4417 | }, .{ |
| | 4418 | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .byte }, .any }, |
| | 4419 | .patterns = &.{ |
| | 4420 | .{ .src = .{ .mem, .none } }, |
| | 4421 | .{ .src = .{ .to_gpr, .none } }, |
| | 4422 | }, |
| | 4423 | .extra_temps = .{ |
| | 4424 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 4425 | .unused, |
| | 4426 | .unused, |
| | 4427 | .unused, |
| | 4428 | .unused, |
| | 4429 | .unused, |
| | 4430 | }, |
| | 4431 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4432 | .clobbers = .{ .eflags = true }, |
| | 4433 | .each = .{ .once = &.{ |
| | 4434 | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, |
| | 4435 | .{ ._, ._, .mov, .dst0d, .sia(-1, .src0, .add_2_bit_size), ._, ._ }, |
| | 4436 | .{ ._, ._r, .bs, .dst0d, .tmp0d, ._, ._ }, |
| | 4437 | .{ ._, ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 4438 | } }, |
| | 4439 | }, .{ |
| | 4440 | .src_constraints = .{ .{ .signed_po2_int = .byte }, .any }, |
| | 4441 | .patterns = &.{ |
| | 4442 | .{ .src = .{ .mem, .none } }, |
| | 4443 | .{ .src = .{ .to_gpr, .none } }, |
| | 4444 | }, |
| | 4445 | .extra_temps = .{ |
| | 4446 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 4447 | .unused, |
| | 4448 | .unused, |
| | 4449 | .unused, |
| | 4450 | .unused, |
| | 4451 | .unused, |
| | 4452 | }, |
| | 4453 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4454 | .clobbers = .{ .eflags = true }, |
| | 4455 | .each = .{ .once = &.{ |
| | 4456 | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, |
| | 4457 | .{ ._, ._, .@"and", .tmp0d, .sa(.src0, .add_umax), ._, ._ }, |
| | 4458 | .{ ._, ._, .mov, .dst0d, .sia(-1, .src0, .add_2_bit_size), ._, ._ }, |
| | 4459 | .{ ._, ._r, .bs, .dst0d, .tmp0d, ._, ._ }, |
| | 4460 | .{ ._, ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 4461 | } }, |
| | 4462 | }, .{ |
| | 4463 | .src_constraints = .{ .{ .signed_int = .byte }, .any }, |
| | 4464 | .patterns = &.{ |
| | 4465 | .{ .src = .{ .mem, .none } }, |
| | 4466 | .{ .src = .{ .to_gpr, .none } }, |
| | 4467 | }, |
| | 4468 | .extra_temps = .{ |
| | 4469 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 4470 | .unused, |
| | 4471 | .unused, |
| | 4472 | .unused, |
| | 4473 | .unused, |
| | 4474 | .unused, |
| | 4475 | }, |
| | 4476 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4477 | .clobbers = .{ .eflags = true }, |
| | 4478 | .each = .{ .once = &.{ |
| | 4479 | .{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ }, |
| | 4480 | .{ ._, ._, .@"and", .dst0d, .sa(.src0, .add_umax), ._, ._ }, |
| | 4481 | .{ ._, ._, .mov, .tmp0d, .si(0xff), ._, ._ }, |
| | 4482 | .{ ._, ._r, .bs, .tmp0d, .dst0d, ._, ._ }, |
| | 4483 | .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 4484 | .{ ._, ._, .sub, .dst0b, .tmp0b, ._, ._ }, |
| | 4485 | } }, |
| | 4486 | }, .{ |
| | 4487 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any }, |
| | 4488 | .patterns = &.{ |
| | 4489 | .{ .src = .{ .mem, .none } }, |
| | 4490 | .{ .src = .{ .to_gpr, .none } }, |
| | 4491 | }, |
| | 4492 | .extra_temps = .{ |
| | 4493 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 4494 | .unused, |
| | 4495 | .unused, |
| | 4496 | .unused, |
| | 4497 | .unused, |
| | 4498 | .unused, |
| | 4499 | }, |
| | 4500 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4501 | .clobbers = .{ .eflags = true }, |
| | 4502 | .each = .{ .once = &.{ |
| | 4503 | .{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ }, |
| | 4504 | .{ ._, ._, .mov, .tmp0d, .si(0xff), ._, ._ }, |
| | 4505 | .{ ._, ._r, .bs, .tmp0d, .dst0d, ._, ._ }, |
| | 4506 | .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 4507 | .{ ._, ._, .sub, .dst0b, .tmp0b, ._, ._ }, |
| | 4508 | } }, |
| | 4509 | }, .{ |
| | 4510 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, |
| | 4511 | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .word }, .any }, |
| | 4512 | .patterns = &.{ |
| | 4513 | .{ .src = .{ .to_mut_gpr, .none } }, |
| | 4514 | }, |
| | 4515 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4516 | .clobbers = .{ .eflags = true }, |
| | 4517 | .each = .{ .once = &.{ |
| | 4518 | .{ ._, ._r, .bs, .src0w, .src0w, ._, ._ }, |
| | 4519 | .{ ._, ._, .mov, .dst0w, .sia(-1, .src0, .add_2_bit_size), ._, ._ }, |
| | 4520 | .{ ._, ._nz, .cmov, .dst0w, .src0w, ._, ._ }, |
| | 4521 | .{ ._, ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 4522 | } }, |
| | 4523 | }, .{ |
| | 4524 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, |
| | 4525 | .src_constraints = .{ .{ .signed_int = .word }, .any }, |
| | 4526 | .patterns = &.{ |
| | 4527 | .{ .src = .{ .to_mut_gpr, .none } }, |
| | 4528 | }, |
| | 4529 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4530 | .clobbers = .{ .eflags = true }, |
| | 4531 | .each = .{ .once = &.{ |
| | 4532 | .{ ._, ._, .@"and", .src0w, .sa(.src0, .add_umax), ._, ._ }, |
| | 4533 | .{ ._, ._r, .bs, .src0w, .src0w, ._, ._ }, |
| | 4534 | .{ ._, ._, .mov, .dst0w, .si(0xff), ._, ._ }, |
| | 4535 | .{ ._, ._z, .cmov, .src0w, .dst0w, ._, ._ }, |
| | 4536 | .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 4537 | .{ ._, ._, .sub, .dst0b, .src0b, ._, ._ }, |
| | 4538 | } }, |
| | 4539 | }, .{ |
| | 4540 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, |
| | 4541 | .src_constraints = .{ .{ .unsigned_int = .word }, .any }, |
| | 4542 | .patterns = &.{ |
| | 4543 | .{ .src = .{ .to_mut_gpr, .none } }, |
| | 4544 | }, |
| | 4545 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4546 | .clobbers = .{ .eflags = true }, |
| | 4547 | .each = .{ .once = &.{ |
| | 4548 | .{ ._, ._r, .bs, .src0w, .src0w, ._, ._ }, |
| | 4549 | .{ ._, ._, .mov, .dst0w, .si(0xff), ._, ._ }, |
| | 4550 | .{ ._, ._z, .cmov, .src0w, .dst0w, ._, ._ }, |
| | 4551 | .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 4552 | .{ ._, ._, .sub, .dst0b, .src0b, ._, ._ }, |
| | 4553 | } }, |
| | 4554 | }, .{ |
| | 4555 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, |
| | 4556 | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .word }, .any }, |
| | 4557 | .patterns = &.{ |
| | 4558 | .{ .src = .{ .to_mut_gpr, .none } }, |
| | 4559 | }, |
| | 4560 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 4561 | .clobbers = .{ .eflags = true }, |
| | 4562 | .each = .{ .once = &.{ |
| | 4563 | .{ ._, ._r, .bs, .dst0w, .src0w, ._, ._ }, |
| | 4564 | .{ ._, ._nz, .j, .@"0f", ._, ._, ._ }, |
| | 4565 | .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_2_bit_size), ._, ._ }, |
| | 4566 | .{ .@"0:", ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 4567 | } }, |
| | 4568 | }, .{ |
| | 4569 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, |
| | 4570 | .src_constraints = .{ .{ .signed_int = .word }, .any }, |
| | 4571 | .patterns = &.{ |
| | 4572 | .{ .src = .{ .to_mut_gpr, .none } }, |
| | 4573 | }, |
| | 4574 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4575 | .clobbers = .{ .eflags = true }, |
| | 4576 | .each = .{ .once = &.{ |
| | 4577 | .{ ._, ._, .@"and", .src0w, .sa(.src0, .add_umax), ._, ._ }, |
| | 4578 | .{ ._, ._r, .bs, .src0w, .src0w, ._, ._ }, |
| | 4579 | .{ ._, ._, .mov, .dst0b, .sa(.src0, .add_bit_size), ._, ._ }, |
| | 4580 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| | 4581 | .{ ._, ._c, .st, ._, ._, ._, ._ }, |
| | 4582 | .{ ._, ._, .sbb, .dst0b, .src0b, ._, ._ }, |
| | 4583 | } }, |
| | 4584 | }, .{ |
| | 4585 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, |
| | 4586 | .src_constraints = .{ .{ .unsigned_int = .word }, .any }, |
| | 4587 | .patterns = &.{ |
| | 4588 | .{ .src = .{ .to_mut_gpr, .none } }, |
| | 4589 | }, |
| | 4590 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4591 | .clobbers = .{ .eflags = true }, |
| | 4592 | .each = .{ .once = &.{ |
| | 4593 | .{ ._, ._r, .bs, .src0w, .src0w, ._, ._ }, |
| | 4594 | .{ ._, ._, .mov, .dst0b, .sa(.src0, .add_bit_size), ._, ._ }, |
| | 4595 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| | 4596 | .{ ._, ._c, .st, ._, ._, ._, ._ }, |
| | 4597 | .{ ._, ._, .sbb, .dst0b, .src0b, ._, ._ }, |
| | 4598 | } }, |
| | 4599 | }, .{ |
| | 4600 | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .word }, .any }, |
| | 4601 | .patterns = &.{ |
| | 4602 | .{ .src = .{ .mem, .none } }, |
| | 4603 | .{ .src = .{ .to_gpr, .none } }, |
| | 4604 | }, |
| | 4605 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4606 | .clobbers = .{ .eflags = true }, |
| | 4607 | .each = .{ .once = &.{ |
| | 4608 | .{ ._, ._, .mov, .dst0w, .sia(-1, .src0, .add_2_bit_size), ._, ._ }, |
| | 4609 | .{ ._, ._r, .bs, .dst0w, .src0w, ._, ._ }, |
| | 4610 | .{ ._, ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 4611 | } }, |
| | 4612 | }, .{ |
| | 4613 | .src_constraints = .{ .{ .signed_int = .word }, .any }, |
| | 4614 | .patterns = &.{ |
| | 4615 | .{ .src = .{ .to_mut_gpr, .none } }, |
| | 4616 | }, |
| | 4617 | .extra_temps = .{ |
| | 4618 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| | 4619 | .unused, |
| | 4620 | .unused, |
| | 4621 | .unused, |
| | 4622 | .unused, |
| | 4623 | .unused, |
| | 4624 | }, |
| | 4625 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4626 | .clobbers = .{ .eflags = true }, |
| | 4627 | .each = .{ .once = &.{ |
| | 4628 | .{ ._, ._, .@"and", .src0w, .sa(.src0, .add_umax), ._, ._ }, |
| | 4629 | .{ ._, ._, .mov, .tmp0w, .si(0xff), ._, ._ }, |
| | 4630 | .{ ._, ._r, .bs, .tmp0w, .src0w, ._, ._ }, |
| | 4631 | .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 4632 | .{ ._, ._, .sub, .dst0b, .tmp0b, ._, ._ }, |
| | 4633 | } }, |
| | 4634 | }, .{ |
| | 4635 | .src_constraints = .{ .{ .unsigned_int = .word }, .any }, |
| | 4636 | .patterns = &.{ |
| | 4637 | .{ .src = .{ .mem, .none } }, |
| | 4638 | .{ .src = .{ .to_gpr, .none } }, |
| | 4639 | }, |
| | 4640 | .extra_temps = .{ |
| | 4641 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| | 4642 | .unused, |
| | 4643 | .unused, |
| | 4644 | .unused, |
| | 4645 | .unused, |
| | 4646 | .unused, |
| | 4647 | }, |
| | 4648 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4649 | .clobbers = .{ .eflags = true }, |
| | 4650 | .each = .{ .once = &.{ |
| | 4651 | .{ ._, ._, .mov, .tmp0w, .si(0xff), ._, ._ }, |
| | 4652 | .{ ._, ._r, .bs, .tmp0w, .src0w, ._, ._ }, |
| | 4653 | .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 4654 | .{ ._, ._, .sub, .dst0b, .tmp0b, ._, ._ }, |
| | 4655 | } }, |
| | 4656 | }, .{ |
| | 4657 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, |
| | 4658 | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .dword }, .any }, |
| | 4659 | .patterns = &.{ |
| | 4660 | .{ .src = .{ .to_mut_gpr, .none } }, |
| | 4661 | }, |
| | 4662 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4663 | .clobbers = .{ .eflags = true }, |
| | 4664 | .each = .{ .once = &.{ |
| | 4665 | .{ ._, ._r, .bs, .src0d, .src0d, ._, ._ }, |
| | 4666 | .{ ._, ._, .mov, .dst0d, .sia(-1, .src0, .add_2_bit_size), ._, ._ }, |
| | 4667 | .{ ._, ._nz, .cmov, .dst0d, .src0d, ._, ._ }, |
| | 4668 | .{ ._, ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 4669 | } }, |
| | 4670 | }, .{ |
| | 4671 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, |
| | 4672 | .src_constraints = .{ .{ .signed_int = .dword }, .any }, |
| | 4673 | .patterns = &.{ |
| | 4674 | .{ .src = .{ .to_mut_gpr, .none } }, |
| | 4675 | }, |
| | 4676 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4677 | .clobbers = .{ .eflags = true }, |
| | 4678 | .each = .{ .once = &.{ |
| | 4679 | .{ ._, ._, .@"and", .src0d, .sa(.src0, .add_umax), ._, ._ }, |
| | 4680 | .{ ._, ._r, .bs, .src0d, .src0d, ._, ._ }, |
| | 4681 | .{ ._, ._, .mov, .dst0d, .si(0xff), ._, ._ }, |
| | 4682 | .{ ._, ._z, .cmov, .src0d, .dst0d, ._, ._ }, |
| | 4683 | .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 4684 | .{ ._, ._, .sub, .dst0b, .src0b, ._, ._ }, |
| | 4685 | } }, |
| | 4686 | }, .{ |
| | 4687 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, |
| | 4688 | .src_constraints = .{ .{ .unsigned_int = .dword }, .any }, |
| | 4689 | .patterns = &.{ |
| | 4690 | .{ .src = .{ .to_mut_gpr, .none } }, |
| | 4691 | }, |
| | 4692 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4693 | .clobbers = .{ .eflags = true }, |
| | 4694 | .each = .{ .once = &.{ |
| | 4695 | .{ ._, ._r, .bs, .src0d, .src0d, ._, ._ }, |
| | 4696 | .{ ._, ._, .mov, .dst0d, .si(0xff), ._, ._ }, |
| | 4697 | .{ ._, ._z, .cmov, .src0d, .dst0d, ._, ._ }, |
| | 4698 | .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 4699 | .{ ._, ._, .sub, .dst0b, .src0b, ._, ._ }, |
| | 4700 | } }, |
| | 4701 | }, .{ |
| | 4702 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, |
| | 4703 | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .dword }, .any }, |
| | 4704 | .patterns = &.{ |
| | 4705 | .{ .src = .{ .to_mut_gpr, .none } }, |
| | 4706 | }, |
| | 4707 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 4708 | .clobbers = .{ .eflags = true }, |
| | 4709 | .each = .{ .once = &.{ |
| | 4710 | .{ ._, ._r, .bs, .dst0d, .src0d, ._, ._ }, |
| | 4711 | .{ ._, ._nz, .j, .@"0f", ._, ._, ._ }, |
| | 4712 | .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_2_bit_size), ._, ._ }, |
| | 4713 | .{ .@"0:", ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 4714 | } }, |
| | 4715 | }, .{ |
| | 4716 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, |
| | 4717 | .src_constraints = .{ .{ .signed_int = .dword }, .any }, |
| | 4718 | .patterns = &.{ |
| | 4719 | .{ .src = .{ .to_mut_gpr, .none } }, |
| | 4720 | }, |
| | 4721 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4722 | .clobbers = .{ .eflags = true }, |
| | 4723 | .each = .{ .once = &.{ |
| | 4724 | .{ ._, ._, .@"and", .src0d, .sa(.src0, .add_umax), ._, ._ }, |
| | 4725 | .{ ._, ._r, .bs, .src0d, .src0d, ._, ._ }, |
| | 4726 | .{ ._, ._, .mov, .dst0b, .sa(.src0, .add_bit_size), ._, ._ }, |
| | 4727 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| | 4728 | .{ ._, ._c, .st, ._, ._, ._, ._ }, |
| | 4729 | .{ ._, ._, .sbb, .dst0b, .src0b, ._, ._ }, |
| | 4730 | } }, |
| | 4731 | }, .{ |
| | 4732 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, |
| | 4733 | .src_constraints = .{ .{ .unsigned_int = .dword }, .any }, |
| | 4734 | .patterns = &.{ |
| | 4735 | .{ .src = .{ .to_mut_gpr, .none } }, |
| | 4736 | }, |
| | 4737 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4738 | .clobbers = .{ .eflags = true }, |
| | 4739 | .each = .{ .once = &.{ |
| | 4740 | .{ ._, ._r, .bs, .src0d, .src0d, ._, ._ }, |
| | 4741 | .{ ._, ._, .mov, .dst0b, .sa(.src0, .add_bit_size), ._, ._ }, |
| | 4742 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| | 4743 | .{ ._, ._c, .st, ._, ._, ._, ._ }, |
| | 4744 | .{ ._, ._, .sbb, .dst0b, .src0b, ._, ._ }, |
| | 4745 | } }, |
| | 4746 | }, .{ |
| | 4747 | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .dword }, .any }, |
| | 4748 | .patterns = &.{ |
| | 4749 | .{ .src = .{ .mem, .none } }, |
| | 4750 | .{ .src = .{ .to_gpr, .none } }, |
| | 4751 | }, |
| | 4752 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4753 | .clobbers = .{ .eflags = true }, |
| | 4754 | .each = .{ .once = &.{ |
| | 4755 | .{ ._, ._, .mov, .dst0d, .sia(-1, .src0, .add_2_bit_size), ._, ._ }, |
| | 4756 | .{ ._, ._r, .bs, .dst0d, .src0d, ._, ._ }, |
| | 4757 | .{ ._, ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 4758 | } }, |
| | 4759 | }, .{ |
| | 4760 | .src_constraints = .{ .{ .signed_int = .dword }, .any }, |
| | 4761 | .patterns = &.{ |
| | 4762 | .{ .src = .{ .to_mut_gpr, .none } }, |
| | 4763 | }, |
| | 4764 | .extra_temps = .{ |
| | 4765 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 4766 | .unused, |
| | 4767 | .unused, |
| | 4768 | .unused, |
| | 4769 | .unused, |
| | 4770 | .unused, |
| | 4771 | }, |
| | 4772 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4773 | .clobbers = .{ .eflags = true }, |
| | 4774 | .each = .{ .once = &.{ |
| | 4775 | .{ ._, ._, .@"and", .src0d, .sa(.src0, .add_umax), ._, ._ }, |
| | 4776 | .{ ._, ._, .mov, .tmp0d, .si(0xff), ._, ._ }, |
| | 4777 | .{ ._, ._r, .bs, .tmp0d, .src0d, ._, ._ }, |
| | 4778 | .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 4779 | .{ ._, ._, .sub, .dst0b, .tmp0b, ._, ._ }, |
| | 4780 | } }, |
| | 4781 | }, .{ |
| | 4782 | .src_constraints = .{ .{ .unsigned_int = .dword }, .any }, |
| | 4783 | .patterns = &.{ |
| | 4784 | .{ .src = .{ .mem, .none } }, |
| | 4785 | .{ .src = .{ .to_gpr, .none } }, |
| | 4786 | }, |
| | 4787 | .extra_temps = .{ |
| | 4788 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 4789 | .unused, |
| | 4790 | .unused, |
| | 4791 | .unused, |
| | 4792 | .unused, |
| | 4793 | .unused, |
| | 4794 | }, |
| | 4795 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4796 | .clobbers = .{ .eflags = true }, |
| | 4797 | .each = .{ .once = &.{ |
| | 4798 | .{ ._, ._, .mov, .tmp0d, .si(0xff), ._, ._ }, |
| | 4799 | .{ ._, ._r, .bs, .tmp0d, .src0d, ._, ._ }, |
| | 4800 | .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 4801 | .{ ._, ._, .sub, .dst0b, .tmp0b, ._, ._ }, |
| | 4802 | } }, |
| | 4803 | }, .{ |
| | 4804 | .required_features = .{ .@"64bit", .cmov, .bsf_bsr_0_clobbers_result, null }, |
| | 4805 | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .qword }, .any }, |
| | 4806 | .patterns = &.{ |
| | 4807 | .{ .src = .{ .to_mut_gpr, .none } }, |
| | 4808 | }, |
| | 4809 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4810 | .clobbers = .{ .eflags = true }, |
| | 4811 | .each = .{ .once = &.{ |
| | 4812 | .{ ._, ._r, .bs, .src0q, .src0q, ._, ._ }, |
| | 4813 | .{ ._, ._, .mov, .dst0d, .sia(-1, .src0, .add_2_bit_size), ._, ._ }, |
| | 4814 | .{ ._, ._nz, .cmov, .dst0d, .src0d, ._, ._ }, |
| | 4815 | .{ ._, ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 4816 | } }, |
| | 4817 | }, .{ |
| | 4818 | .required_features = .{ .@"64bit", .cmov, .bsf_bsr_0_clobbers_result, null }, |
| | 4819 | .src_constraints = .{ .{ .signed_int = .qword }, .any }, |
| | 4820 | .patterns = &.{ |
| | 4821 | .{ .src = .{ .mem, .none } }, |
| | 4822 | .{ .src = .{ .to_gpr, .none } }, |
| | 4823 | }, |
| | 4824 | .extra_temps = .{ |
| | 4825 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 4826 | .unused, |
| | 4827 | .unused, |
| | 4828 | .unused, |
| | 4829 | .unused, |
| | 4830 | .unused, |
| | 4831 | }, |
| | 4832 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4833 | .clobbers = .{ .eflags = true }, |
| | 4834 | .each = .{ .once = &.{ |
| | 4835 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ }, |
| | 4836 | .{ ._, ._, .@"and", .tmp0q, .src0q, ._, ._ }, |
| | 4837 | .{ ._, ._r, .bs, .tmp0q, .tmp0q, ._, ._ }, |
| | 4838 | .{ ._, ._, .mov, .dst0d, .si(0xff), ._, ._ }, |
| | 4839 | .{ ._, ._z, .cmov, .tmp0d, .dst0d, ._, ._ }, |
| | 4840 | .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 4841 | .{ ._, ._, .sub, .dst0b, .tmp0b, ._, ._ }, |
| | 4842 | } }, |
| | 4843 | }, .{ |
| | 4844 | .required_features = .{ .@"64bit", .cmov, .bsf_bsr_0_clobbers_result, null }, |
| | 4845 | .src_constraints = .{ .{ .unsigned_int = .qword }, .any }, |
| | 4846 | .patterns = &.{ |
| | 4847 | .{ .src = .{ .to_mut_gpr, .none } }, |
| | 4848 | }, |
| | 4849 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4850 | .clobbers = .{ .eflags = true }, |
| | 4851 | .each = .{ .once = &.{ |
| | 4852 | .{ ._, ._r, .bs, .src0q, .src0q, ._, ._ }, |
| | 4853 | .{ ._, ._, .mov, .dst0d, .si(0xff), ._, ._ }, |
| | 4854 | .{ ._, ._z, .cmov, .src0d, .dst0d, ._, ._ }, |
| | 4855 | .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 4856 | .{ ._, ._, .sub, .dst0b, .src0b, ._, ._ }, |
| | 4857 | } }, |
| | 4858 | }, .{ |
| | 4859 | .required_features = .{ .@"64bit", .bsf_bsr_0_clobbers_result, null, null }, |
| | 4860 | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .qword }, .any }, |
| | 4861 | .patterns = &.{ |
| | 4862 | .{ .src = .{ .to_mut_gpr, .none } }, |
| | 4863 | }, |
| | 4864 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 4865 | .clobbers = .{ .eflags = true }, |
| | 4866 | .each = .{ .once = &.{ |
| | 4867 | .{ ._, ._r, .bs, .dst0q, .src0q, ._, ._ }, |
| | 4868 | .{ ._, ._nz, .j, .@"0f", ._, ._, ._ }, |
| | 4869 | .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_2_bit_size), ._, ._ }, |
| | 4870 | .{ .@"0:", ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 4871 | } }, |
| | 4872 | }, .{ |
| | 4873 | .required_features = .{ .@"64bit", .bsf_bsr_0_clobbers_result, null, null }, |
| | 4874 | .src_constraints = .{ .{ .signed_int = .qword }, .any }, |
| | 4875 | .patterns = &.{ |
| | 4876 | .{ .src = .{ .mem, .none } }, |
| | 4877 | .{ .src = .{ .to_gpr, .none } }, |
| | 4878 | }, |
| | 4879 | .extra_temps = .{ |
| | 4880 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 4881 | .unused, |
| | 4882 | .unused, |
| | 4883 | .unused, |
| | 4884 | .unused, |
| | 4885 | .unused, |
| | 4886 | }, |
| | 4887 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4888 | .clobbers = .{ .eflags = true }, |
| | 4889 | .each = .{ .once = &.{ |
| | 4890 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ }, |
| | 4891 | .{ ._, ._, .@"and", .tmp0q, .src0q, ._, ._ }, |
| | 4892 | .{ ._, ._r, .bs, .tmp0q, .tmp0q, ._, ._ }, |
| | 4893 | .{ ._, ._, .mov, .dst0b, .sa(.src0, .add_bit_size), ._, ._ }, |
| | 4894 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| | 4895 | .{ ._, ._c, .st, ._, ._, ._, ._ }, |
| | 4896 | .{ ._, ._, .sbb, .dst0b, .tmp0b, ._, ._ }, |
| | 4897 | } }, |
| | 4898 | }, .{ |
| | 4899 | .required_features = .{ .@"64bit", .bsf_bsr_0_clobbers_result, null, null }, |
| | 4900 | .src_constraints = .{ .{ .unsigned_int = .qword }, .any }, |
| | 4901 | .patterns = &.{ |
| | 4902 | .{ .src = .{ .to_mut_gpr, .none } }, |
| | 4903 | }, |
| | 4904 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4905 | .clobbers = .{ .eflags = true }, |
| | 4906 | .each = .{ .once = &.{ |
| | 4907 | .{ ._, ._r, .bs, .src0q, .src0q, ._, ._ }, |
| | 4908 | .{ ._, ._, .mov, .dst0b, .sa(.src0, .add_bit_size), ._, ._ }, |
| | 4909 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| | 4910 | .{ ._, ._c, .st, ._, ._, ._, ._ }, |
| | 4911 | .{ ._, ._, .sbb, .dst0b, .src0b, ._, ._ }, |
| | 4912 | } }, |
| | 4913 | }, .{ |
| | 4914 | .required_features = .{ .@"64bit", null, null, null }, |
| | 4915 | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .qword }, .any }, |
| | 4916 | .patterns = &.{ |
| | 4917 | .{ .src = .{ .mem, .none } }, |
| | 4918 | .{ .src = .{ .to_gpr, .none } }, |
| | 4919 | }, |
| | 4920 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4921 | .clobbers = .{ .eflags = true }, |
| | 4922 | .each = .{ .once = &.{ |
| | 4923 | .{ ._, ._, .mov, .dst0d, .sia(-1, .src0, .add_2_bit_size), ._, ._ }, |
| | 4924 | .{ ._, ._r, .bs, .dst0q, .src0q, ._, ._ }, |
| | 4925 | .{ ._, ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 4926 | } }, |
| | 4927 | }, .{ |
| | 4928 | .required_features = .{ .@"64bit", null, null, null }, |
| | 4929 | .src_constraints = .{ .{ .signed_int = .qword }, .any }, |
| | 4930 | .patterns = &.{ |
| | 4931 | .{ .src = .{ .mem, .none } }, |
| | 4932 | .{ .src = .{ .to_gpr, .none } }, |
| | 4933 | }, |
| | 4934 | .extra_temps = .{ |
| | 4935 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 4936 | .unused, |
| | 4937 | .unused, |
| | 4938 | .unused, |
| | 4939 | .unused, |
| | 4940 | .unused, |
| | 4941 | }, |
| | 4942 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4943 | .clobbers = .{ .eflags = true }, |
| | 4944 | .each = .{ .once = &.{ |
| | 4945 | .{ ._, ._, .mov, .dst0q, .ua(.src0, .add_umax), ._, ._ }, |
| | 4946 | .{ ._, ._, .@"and", .dst0q, .src0q, ._, ._ }, |
| | 4947 | .{ ._, ._, .mov, .tmp0d, .si(0xff), ._, ._ }, |
| | 4948 | .{ ._, ._r, .bs, .tmp0q, .dst0q, ._, ._ }, |
| | 4949 | .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 4950 | .{ ._, ._, .sub, .dst0b, .tmp0b, ._, ._ }, |
| | 4951 | } }, |
| | 4952 | }, .{ |
| | 4953 | .required_features = .{ .@"64bit", null, null, null }, |
| | 4954 | .src_constraints = .{ .{ .unsigned_int = .qword }, .any }, |
| | 4955 | .patterns = &.{ |
| | 4956 | .{ .src = .{ .mem, .none } }, |
| | 4957 | .{ .src = .{ .to_gpr, .none } }, |
| | 4958 | }, |
| | 4959 | .extra_temps = .{ |
| | 4960 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 4961 | .unused, |
| | 4962 | .unused, |
| | 4963 | .unused, |
| | 4964 | .unused, |
| | 4965 | .unused, |
| | 4966 | }, |
| | 4967 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4968 | .clobbers = .{ .eflags = true }, |
| | 4969 | .each = .{ .once = &.{ |
| | 4970 | .{ ._, ._, .mov, .tmp0d, .si(0xff), ._, ._ }, |
| | 4971 | .{ ._, ._r, .bs, .tmp0q, .src0q, ._, ._ }, |
| | 4972 | .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 4973 | .{ ._, ._, .sub, .dst0b, .tmp0b, ._, ._ }, |
| | 4974 | } }, |
| | 4975 | }, .{ |
| | 4976 | .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null }, |
| | 4977 | .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .qword } }, .any }, |
| | 4978 | .patterns = &.{ |
| | 4979 | .{ .src = .{ .to_mem, .none } }, |
| | 4980 | }, |
| | 4981 | .extra_temps = .{ |
| | 4982 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 4983 | .unused, |
| | 4984 | .unused, |
| | 4985 | .unused, |
| | 4986 | .unused, |
| | 4987 | .unused, |
| | 4988 | }, |
| | 4989 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 4990 | .each = .{ .once = &.{ |
| | 4991 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ }, |
| | 4992 | .{ .@"0:", ._, .xor, .dst0d, .dst0d, ._, ._ }, |
| | 4993 | .{ ._, ._, .lzcnt, .dst0q, .memi(.src0q, .tmp0), ._, ._ }, |
| | 4994 | .{ ._, ._nc, .j, .@"0f", ._, ._, ._ }, |
| | 4995 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 4996 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 4997 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| | 4998 | .{ .@"0:", ._, .neg, .tmp0d, ._, ._, ._ }, |
| | 4999 | .{ ._, ._, .lea, .dst0d, .leasiad(.none, .dst0, .@"8", .tmp0, .add_src0_bit_size, -64), ._, ._ }, |
| | 5000 | } }, |
| | 5001 | }, .{ |
| | 5002 | .required_features = .{ .@"64bit", .lzcnt, null, null }, |
| | 5003 | .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .qword } }, .any }, |
| | 5004 | .patterns = &.{ |
| | 5005 | .{ .src = .{ .to_mem, .none } }, |
| | 5006 | }, |
| | 5007 | .extra_temps = .{ |
| | 5008 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5009 | .unused, |
| | 5010 | .unused, |
| | 5011 | .unused, |
| | 5012 | .unused, |
| | 5013 | .unused, |
| | 5014 | }, |
| | 5015 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 5016 | .each = .{ .once = &.{ |
| | 5017 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ }, |
| | 5018 | .{ .@"0:", ._, .lzcnt, .dst0q, .memi(.src0q, .tmp0), ._, ._ }, |
| | 5019 | .{ ._, ._nc, .j, .@"0f", ._, ._, ._ }, |
| | 5020 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 5021 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 5022 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| | 5023 | .{ .@"0:", ._, .neg, .tmp0d, ._, ._, ._ }, |
| | 5024 | .{ ._, ._, .lea, .dst0d, .leasiad(.none, .dst0, .@"8", .tmp0, .add_src0_bit_size, -64), ._, ._ }, |
| | 5025 | } }, |
| | 5026 | }, .{ |
| | 5027 | .required_features = .{ .@"64bit", .bsf_bsr_0_clobbers_result, null, null }, |
| | 5028 | .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .qword } }, .any }, |
| | 5029 | .patterns = &.{ |
| | 5030 | .{ .src = .{ .to_mem, .none } }, |
| | 5031 | }, |
| | 5032 | .extra_temps = .{ |
| | 5033 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5034 | .unused, |
| | 5035 | .unused, |
| | 5036 | .unused, |
| | 5037 | .unused, |
| | 5038 | .unused, |
| | 5039 | }, |
| | 5040 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 5041 | .each = .{ .once = &.{ |
| | 5042 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ }, |
| | 5043 | .{ .@"0:", ._, .xor, .dst0d, .dst0d, ._, ._ }, |
| | 5044 | .{ ._, ._r, .bs, .dst0q, .memi(.src0q, .tmp0), ._, ._ }, |
| | 5045 | .{ ._, ._nz, .j, .@"0f", ._, ._, ._ }, |
| | 5046 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 5047 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 5048 | .{ ._, ._, .mov, .dst0d, .si(-1), ._, ._ }, |
| | 5049 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| | 5050 | .{ .@"0:", ._, .lea, .dst0d, .leasiad(.none, .dst0, .@"8", .tmp0, .sub_src0_bit_size, 1), ._, ._ }, |
| | 5051 | .{ ._, ._, .neg, .dst0d, ._, ._, ._ }, |
| | 5052 | } }, |
| | 5053 | }, .{ |
| | 5054 | .required_features = .{ .@"64bit", null, null, null }, |
| | 5055 | .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .qword } }, .any }, |
| | 5056 | .patterns = &.{ |
| | 5057 | .{ .src = .{ .to_mem, .none } }, |
| | 5058 | }, |
| | 5059 | .extra_temps = .{ |
| | 5060 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5061 | .unused, |
| | 5062 | .unused, |
| | 5063 | .unused, |
| | 5064 | .unused, |
| | 5065 | .unused, |
| | 5066 | }, |
| | 5067 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 5068 | .each = .{ .once = &.{ |
| | 5069 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ }, |
| | 5070 | .{ .@"0:", ._, .mov, .dst0d, .si(-1), ._, ._ }, |
| | 5071 | .{ ._, ._r, .bs, .dst0q, .memi(.src0q, .tmp0), ._, ._ }, |
| | 5072 | .{ ._, ._nz, .j, .@"0f", ._, ._, ._ }, |
| | 5073 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 5074 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 5075 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| | 5076 | .{ .@"0:", ._, .lea, .dst0d, .leasiad(.none, .dst0, .@"8", .tmp0, .sub_src0_bit_size, 1), ._, ._ }, |
| | 5077 | .{ ._, ._, .neg, .dst0d, ._, ._, ._ }, |
| | 5078 | } }, |
| | 5079 | }, .{ |
| | 5080 | .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null }, |
| | 5081 | .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| | 5082 | .patterns = &.{ |
| | 5083 | .{ .src = .{ .to_mem, .none } }, |
| | 5084 | }, |
| | 5085 | .extra_temps = .{ |
| | 5086 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5087 | .unused, |
| | 5088 | .unused, |
| | 5089 | .unused, |
| | 5090 | .unused, |
| | 5091 | .unused, |
| | 5092 | }, |
| | 5093 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 5094 | .each = .{ .once = &.{ |
| | 5095 | .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ }, |
| | 5096 | .{ .@"0:", ._, .xor, .dst0d, .dst0d, ._, ._ }, |
| | 5097 | .{ ._, ._, .lzcnt, .dst0q, .memi(.src0q, .tmp0), ._, ._ }, |
| | 5098 | .{ ._, ._nc, .j, .@"0f", ._, ._, ._ }, |
| | 5099 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 5100 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 5101 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| | 5102 | .{ .@"0:", ._, .neg, .tmp0d, ._, ._, ._ }, |
| | 5103 | .{ ._, ._, .lea, .dst0d, .leasiad(.none, .dst0, .@"8", .tmp0, .add_src0_bit_size, -64), ._, ._ }, |
| | 5104 | } }, |
| | 5105 | }, .{ |
| | 5106 | .required_features = .{ .@"64bit", .lzcnt, null, null }, |
| | 5107 | .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| | 5108 | .patterns = &.{ |
| | 5109 | .{ .src = .{ .to_mem, .none } }, |
| | 5110 | }, |
| | 5111 | .extra_temps = .{ |
| | 5112 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5113 | .unused, |
| | 5114 | .unused, |
| | 5115 | .unused, |
| | 5116 | .unused, |
| | 5117 | .unused, |
| | 5118 | }, |
| | 5119 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 5120 | .each = .{ .once = &.{ |
| | 5121 | .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ }, |
| | 5122 | .{ .@"0:", ._, .lzcnt, .dst0q, .memi(.src0q, .tmp0), ._, ._ }, |
| | 5123 | .{ ._, ._nc, .j, .@"0f", ._, ._, ._ }, |
| | 5124 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 5125 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 5126 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| | 5127 | .{ .@"0:", ._, .neg, .tmp0d, ._, ._, ._ }, |
| | 5128 | .{ ._, ._, .lea, .dst0d, .leasiad(.none, .dst0, .@"8", .tmp0, .add_src0_bit_size, -64), ._, ._ }, |
| | 5129 | } }, |
| | 5130 | }, .{ |
| | 5131 | .required_features = .{ .@"64bit", .bsf_bsr_0_clobbers_result, null, null }, |
| | 5132 | .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| | 5133 | .patterns = &.{ |
| | 5134 | .{ .src = .{ .to_mem, .none } }, |
| | 5135 | }, |
| | 5136 | .extra_temps = .{ |
| | 5137 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5138 | .unused, |
| | 5139 | .unused, |
| | 5140 | .unused, |
| | 5141 | .unused, |
| | 5142 | .unused, |
| | 5143 | }, |
| | 5144 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 5145 | .each = .{ .once = &.{ |
| | 5146 | .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ }, |
| | 5147 | .{ .@"0:", ._, .xor, .dst0d, .dst0d, ._, ._ }, |
| | 5148 | .{ ._, ._r, .bs, .dst0q, .memi(.src0q, .tmp0), ._, ._ }, |
| | 5149 | .{ ._, ._nz, .j, .@"0f", ._, ._, ._ }, |
| | 5150 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 5151 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 5152 | .{ ._, ._, .mov, .dst0d, .si(-1), ._, ._ }, |
| | 5153 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| | 5154 | .{ .@"0:", ._, .lea, .dst0d, .leasiad(.none, .dst0, .@"8", .tmp0, .sub_src0_bit_size, 1), ._, ._ }, |
| | 5155 | .{ ._, ._, .neg, .dst0d, ._, ._, ._ }, |
| | 5156 | } }, |
| | 5157 | }, .{ |
| | 5158 | .required_features = .{ .@"64bit", null, null, null }, |
| | 5159 | .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| | 5160 | .patterns = &.{ |
| | 5161 | .{ .src = .{ .to_mem, .none } }, |
| | 5162 | }, |
| | 5163 | .extra_temps = .{ |
| | 5164 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5165 | .unused, |
| | 5166 | .unused, |
| | 5167 | .unused, |
| | 5168 | .unused, |
| | 5169 | .unused, |
| | 5170 | }, |
| | 5171 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 5172 | .each = .{ .once = &.{ |
| | 5173 | .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ }, |
| | 5174 | .{ .@"0:", ._, .mov, .dst0d, .si(-1), ._, ._ }, |
| | 5175 | .{ ._, ._r, .bs, .dst0q, .memi(.src0q, .tmp0), ._, ._ }, |
| | 5176 | .{ ._, ._nz, .j, .@"0f", ._, ._, ._ }, |
| | 5177 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 5178 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 5179 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| | 5180 | .{ .@"0:", ._, .lea, .dst0d, .leasiad(.none, .dst0, .@"8", .tmp0, .sub_src0_bit_size, 1), ._, ._ }, |
| | 5181 | .{ ._, ._, .neg, .dst0d, ._, ._, ._ }, |
| | 5182 | } }, |
| | 5183 | }, .{ |
| | 5184 | .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null }, |
| | 5185 | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .qword } }, .any }, |
| | 5186 | .patterns = &.{ |
| | 5187 | .{ .src = .{ .to_mem, .none } }, |
| | 5188 | }, |
| | 5189 | .extra_temps = .{ |
| | 5190 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5191 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 5192 | .unused, |
| | 5193 | .unused, |
| | 5194 | .unused, |
| | 5195 | .unused, |
| | 5196 | }, |
| | 5197 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 5198 | .each = .{ .once = &.{ |
| | 5199 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ }, |
| | 5200 | .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ }, |
| | 5201 | .{ .@"0:", ._, .xor, .dst0d, .dst0d, ._, ._ }, |
| | 5202 | .{ ._, ._, .@"and", .tmp1q, .memi(.src0q, .tmp0), ._, ._ }, |
| | 5203 | .{ ._, ._, .lzcnt, .dst0q, .tmp1q, ._, ._ }, |
| | 5204 | .{ ._, ._nc, .j, .@"0f", ._, ._, ._ }, |
| | 5205 | .{ ._, ._, .mov, .tmp1q, .si(-1), ._, ._ }, |
| | 5206 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 5207 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 5208 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| | 5209 | .{ .@"0:", ._, .neg, .tmp0d, ._, ._, ._ }, |
| | 5210 | .{ ._, ._, .lea, .dst0d, .leasiad(.none, .dst0, .@"8", .tmp0, .add_src0_bit_size, -64), ._, ._ }, |
| | 5211 | } }, |
| | 5212 | }, .{ |
| | 5213 | .required_features = .{ .@"64bit", .lzcnt, null, null }, |
| | 5214 | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .qword } }, .any }, |
| | 5215 | .patterns = &.{ |
| | 5216 | .{ .src = .{ .to_mem, .none } }, |
| | 5217 | }, |
| | 5218 | .extra_temps = .{ |
| | 5219 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5220 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 5221 | .unused, |
| | 5222 | .unused, |
| | 5223 | .unused, |
| | 5224 | .unused, |
| | 5225 | }, |
| | 5226 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 5227 | .each = .{ .once = &.{ |
| | 5228 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ }, |
| | 5229 | .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ }, |
| | 5230 | .{ .@"0:", ._, .@"and", .tmp1q, .memi(.src0q, .tmp0), ._, ._ }, |
| | 5231 | .{ ._, ._, .lzcnt, .dst0q, .tmp1q, ._, ._ }, |
| | 5232 | .{ ._, ._nc, .j, .@"0f", ._, ._, ._ }, |
| | 5233 | .{ ._, ._, .mov, .tmp1q, .si(-1), ._, ._ }, |
| | 5234 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 5235 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 5236 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| | 5237 | .{ .@"0:", ._, .neg, .tmp0d, ._, ._, ._ }, |
| | 5238 | .{ ._, ._, .lea, .dst0d, .leasiad(.none, .dst0, .@"8", .tmp0, .add_src0_bit_size, -64), ._, ._ }, |
| | 5239 | } }, |
| | 5240 | }, .{ |
| | 5241 | .required_features = .{ .@"64bit", null, null, null }, |
| | 5242 | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .qword } }, .any }, |
| | 5243 | .patterns = &.{ |
| | 5244 | .{ .src = .{ .to_mem, .none } }, |
| | 5245 | }, |
| | 5246 | .extra_temps = .{ |
| | 5247 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5248 | .unused, |
| | 5249 | .unused, |
| | 5250 | .unused, |
| | 5251 | .unused, |
| | 5252 | .unused, |
| | 5253 | }, |
| | 5254 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 5255 | .each = .{ .once = &.{ |
| | 5256 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ }, |
| | 5257 | .{ ._, ._, .mov, .dst0q, .ua(.src0, .add_umax), ._, ._ }, |
| | 5258 | .{ .@"0:", ._, .@"and", .dst0q, .memi(.src0q, .tmp0), ._, ._ }, |
| | 5259 | .{ ._, ._r, .bs, .dst0q, .dst0q, ._, ._ }, |
| | 5260 | .{ ._, ._nz, .j, .@"0f", ._, ._, ._ }, |
| | 5261 | .{ ._, ._, .mov, .dst0q, .si(-1), ._, ._ }, |
| | 5262 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 5263 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 5264 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| | 5265 | .{ .@"0:", ._, .lea, .dst0d, .leasiad(.none, .dst0, .@"8", .tmp0, .sub_src0_bit_size, 1), ._, ._ }, |
| | 5266 | .{ ._, ._, .neg, .dst0d, ._, ._, ._ }, |
| | 5267 | } }, |
| | 5268 | }, .{ |
| | 5269 | .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null }, |
| | 5270 | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| | 5271 | .patterns = &.{ |
| | 5272 | .{ .src = .{ .to_mem, .none } }, |
| | 5273 | }, |
| | 5274 | .extra_temps = .{ |
| | 5275 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5276 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 5277 | .unused, |
| | 5278 | .unused, |
| | 5279 | .unused, |
| | 5280 | .unused, |
| | 5281 | }, |
| | 5282 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 5283 | .each = .{ .once = &.{ |
| | 5284 | .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ }, |
| | 5285 | .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ }, |
| | 5286 | .{ .@"0:", ._, .xor, .dst0d, .dst0d, ._, ._ }, |
| | 5287 | .{ ._, ._, .@"and", .tmp1q, .memi(.src0q, .tmp0), ._, ._ }, |
| | 5288 | .{ ._, ._, .lzcnt, .dst0q, .tmp1q, ._, ._ }, |
| | 5289 | .{ ._, ._nc, .j, .@"0f", ._, ._, ._ }, |
| | 5290 | .{ ._, ._, .mov, .tmp1q, .si(-1), ._, ._ }, |
| | 5291 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 5292 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 5293 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| | 5294 | .{ .@"0:", ._, .neg, .tmp0d, ._, ._, ._ }, |
| | 5295 | .{ ._, ._, .lea, .dst0d, .leasiad(.none, .dst0, .@"8", .tmp0, .add_src0_bit_size, -64), ._, ._ }, |
| | 5296 | } }, |
| | 5297 | }, .{ |
| | 5298 | .required_features = .{ .@"64bit", .lzcnt, null, null }, |
| | 5299 | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| | 5300 | .patterns = &.{ |
| | 5301 | .{ .src = .{ .to_mem, .none } }, |
| | 5302 | }, |
| | 5303 | .extra_temps = .{ |
| | 5304 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5305 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 5306 | .unused, |
| | 5307 | .unused, |
| | 5308 | .unused, |
| | 5309 | .unused, |
| | 5310 | }, |
| | 5311 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 5312 | .each = .{ .once = &.{ |
| | 5313 | .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ }, |
| | 5314 | .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ }, |
| | 5315 | .{ .@"0:", ._, .@"and", .tmp1q, .memi(.src0q, .tmp0), ._, ._ }, |
| | 5316 | .{ ._, ._, .lzcnt, .dst0q, .tmp1q, ._, ._ }, |
| | 5317 | .{ ._, ._nc, .j, .@"0f", ._, ._, ._ }, |
| | 5318 | .{ ._, ._, .mov, .tmp1q, .si(-1), ._, ._ }, |
| | 5319 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 5320 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 5321 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| | 5322 | .{ .@"0:", ._, .neg, .tmp0d, ._, ._, ._ }, |
| | 5323 | .{ ._, ._, .lea, .dst0d, .leasiad(.none, .dst0, .@"8", .tmp0, .add_src0_bit_size, -64), ._, ._ }, |
| | 5324 | } }, |
| | 5325 | }, .{ |
| | 5326 | .required_features = .{ .@"64bit", null, null, null }, |
| | 5327 | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| | 5328 | .patterns = &.{ |
| | 5329 | .{ .src = .{ .to_mem, .none } }, |
| | 5330 | }, |
| | 5331 | .extra_temps = .{ |
| | 5332 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5333 | .unused, |
| | 5334 | .unused, |
| | 5335 | .unused, |
| | 5336 | .unused, |
| | 5337 | .unused, |
| | 5338 | }, |
| | 5339 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 5340 | .each = .{ .once = &.{ |
| | 5341 | .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ }, |
| | 5342 | .{ ._, ._, .mov, .dst0q, .ua(.src0, .add_umax), ._, ._ }, |
| | 5343 | .{ .@"0:", ._, .@"and", .dst0q, .memi(.src0q, .tmp0), ._, ._ }, |
| | 5344 | .{ ._, ._r, .bs, .dst0q, .dst0q, ._, ._ }, |
| | 5345 | .{ ._, ._nz, .j, .@"0f", ._, ._, ._ }, |
| | 5346 | .{ ._, ._, .mov, .dst0q, .si(-1), ._, ._ }, |
| | 5347 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 5348 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 5349 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| | 5350 | .{ .@"0:", ._, .lea, .dst0d, .leasiad(.none, .dst0, .@"8", .tmp0, .sub_src0_bit_size, 1), ._, ._ }, |
| | 5351 | .{ ._, ._, .neg, .dst0d, ._, ._, ._ }, |
| | 5352 | } }, |
| | 5353 | }, .{ |
| | 5354 | .required_features = .{ .lzcnt, .slow_incdec, null, null }, |
| | 5355 | .src_constraints = .{ .{ .scalar_int = .byte }, .any }, |
| | 5356 | .patterns = &.{ |
| | 5357 | .{ .src = .{ .to_mem, .none } }, |
| | 5358 | }, |
| | 5359 | .extra_temps = .{ |
| | 5360 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 5361 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5362 | .unused, |
| | 5363 | .unused, |
| | 5364 | .unused, |
| | 5365 | .unused, |
| | 5366 | }, |
| | 5367 | .dst_temps = .{.mem}, |
| | 5368 | .each = .{ .once = &.{ |
| | 5369 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 5370 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_len), ._, ._ }, |
| | 5371 | .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ }, |
| | 5372 | .{ ._, ._, .lzcnt, .tmp1d, .tmp1d, ._, ._ }, |
| | 5373 | .{ ._, ._, .sub, .tmp1b, .sia(32, .src0, .sub_bit_size), ._, ._ }, |
| | 5374 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp1b, ._, ._ }, |
| | 5375 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 5376 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 5377 | } }, |
| | 5378 | }, .{ |
| | 5379 | .required_features = .{ .lzcnt, null, null, null }, |
| | 5380 | .src_constraints = .{ .{ .scalar_int = .byte }, .any }, |
| | 5381 | .patterns = &.{ |
| | 5382 | .{ .src = .{ .to_mem, .none } }, |
| | 5383 | }, |
| | 5384 | .extra_temps = .{ |
| | 5385 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 5386 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5387 | .unused, |
| | 5388 | .unused, |
| | 5389 | .unused, |
| | 5390 | .unused, |
| | 5391 | }, |
| | 5392 | .dst_temps = .{.mem}, |
| | 5393 | .each = .{ .once = &.{ |
| | 5394 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 5395 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_len), ._, ._ }, |
| | 5396 | .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ }, |
| | 5397 | .{ ._, ._, .lzcnt, .tmp1d, .tmp1d, ._, ._ }, |
| | 5398 | .{ ._, ._, .sub, .tmp1b, .sia(32, .src0, .sub_bit_size), ._, ._ }, |
| | 5399 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp1b, ._, ._ }, |
| | 5400 | .{ ._, ._, .inc, .tmp0p, ._, ._, ._ }, |
| | 5401 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 5402 | } }, |
| | 5403 | }, .{ |
| | 5404 | .required_features = .{ .lzcnt, .slow_incdec, null, null }, |
| | 5405 | .src_constraints = .{ .{ .scalar_int = .word }, .any }, |
| | 5406 | .patterns = &.{ |
| | 5407 | .{ .src = .{ .to_mem, .none } }, |
| | 5408 | }, |
| | 5409 | .extra_temps = .{ |
| | 5410 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 5411 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5412 | .unused, |
| | 5413 | .unused, |
| | 5414 | .unused, |
| | 5415 | .unused, |
| | 5416 | }, |
| | 5417 | .dst_temps = .{.mem}, |
| | 5418 | .each = .{ .once = &.{ |
| | 5419 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 5420 | .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0w, .@"2", .tmp0, .add_2_len), ._, ._ }, |
| | 5421 | .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ }, |
| | 5422 | .{ ._, ._, .lzcnt, .tmp1d, .tmp1d, ._, ._ }, |
| | 5423 | .{ ._, ._, .sub, .tmp1b, .sia(32, .src0, .sub_bit_size), ._, ._ }, |
| | 5424 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp1b, ._, ._ }, |
| | 5425 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 5426 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 5427 | } }, |
| | 5428 | }, .{ |
| | 5429 | .required_features = .{ .lzcnt, null, null, null }, |
| | 5430 | .src_constraints = .{ .{ .scalar_int = .word }, .any }, |
| | 5431 | .patterns = &.{ |
| | 5432 | .{ .src = .{ .to_mem, .none } }, |
| | 5433 | }, |
| | 5434 | .extra_temps = .{ |
| | 5435 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 5436 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5437 | .unused, |
| | 5438 | .unused, |
| | 5439 | .unused, |
| | 5440 | .unused, |
| | 5441 | }, |
| | 5442 | .dst_temps = .{.mem}, |
| | 5443 | .each = .{ .once = &.{ |
| | 5444 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 5445 | .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0w, .@"2", .tmp0, .add_2_len), ._, ._ }, |
| | 5446 | .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ }, |
| | 5447 | .{ ._, ._, .lzcnt, .tmp1d, .tmp1d, ._, ._ }, |
| | 5448 | .{ ._, ._, .sub, .tmp1b, .sia(32, .src0, .sub_bit_size), ._, ._ }, |
| | 5449 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp1b, ._, ._ }, |
| | 5450 | .{ ._, ._, .inc, .tmp0p, ._, ._, ._ }, |
| | 5451 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 5452 | } }, |
| | 5453 | }, .{ |
| | 5454 | .required_features = .{ .lzcnt, .slow_incdec, null, null }, |
| | 5455 | .src_constraints = .{ .{ .scalar_int = .dword }, .any }, |
| | 5456 | .patterns = &.{ |
| | 5457 | .{ .src = .{ .to_mem, .none } }, |
| | 5458 | }, |
| | 5459 | .extra_temps = .{ |
| | 5460 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 5461 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5462 | .unused, |
| | 5463 | .unused, |
| | 5464 | .unused, |
| | 5465 | .unused, |
| | 5466 | }, |
| | 5467 | .dst_temps = .{.mem}, |
| | 5468 | .each = .{ .once = &.{ |
| | 5469 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 5470 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_4_len), ._, ._ }, |
| | 5471 | .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ }, |
| | 5472 | .{ ._, ._, .lzcnt, .tmp1d, .tmp1d, ._, ._ }, |
| | 5473 | .{ ._, ._, .sub, .tmp1b, .sia(32, .src0, .sub_bit_size), ._, ._ }, |
| | 5474 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp1b, ._, ._ }, |
| | 5475 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 5476 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 5477 | } }, |
| | 5478 | }, .{ |
| | 5479 | .required_features = .{ .lzcnt, null, null, null }, |
| | 5480 | .src_constraints = .{ .{ .scalar_int = .dword }, .any }, |
| | 5481 | .patterns = &.{ |
| | 5482 | .{ .src = .{ .to_mem, .none } }, |
| | 5483 | }, |
| | 5484 | .extra_temps = .{ |
| | 5485 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 5486 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5487 | .unused, |
| | 5488 | .unused, |
| | 5489 | .unused, |
| | 5490 | .unused, |
| | 5491 | }, |
| | 5492 | .dst_temps = .{.mem}, |
| | 5493 | .each = .{ .once = &.{ |
| | 5494 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 5495 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_4_len), ._, ._ }, |
| | 5496 | .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ }, |
| | 5497 | .{ ._, ._, .lzcnt, .tmp1d, .tmp1d, ._, ._ }, |
| | 5498 | .{ ._, ._, .sub, .tmp1b, .sia(32, .src0, .sub_bit_size), ._, ._ }, |
| | 5499 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp1b, ._, ._ }, |
| | 5500 | .{ ._, ._, .inc, .tmp0p, ._, ._, ._ }, |
| | 5501 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 5502 | } }, |
| | 5503 | }, .{ |
| | 5504 | .required_features = .{ .@"64bit", .lzcnt, .slow_incdec, null }, |
| | 5505 | .src_constraints = .{ .{ .scalar_int = .qword }, .any }, |
| | 5506 | .patterns = &.{ |
| | 5507 | .{ .src = .{ .to_mem, .none } }, |
| | 5508 | }, |
| | 5509 | .extra_temps = .{ |
| | 5510 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 5511 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 5512 | .unused, |
| | 5513 | .unused, |
| | 5514 | .unused, |
| | 5515 | .unused, |
| | 5516 | }, |
| | 5517 | .dst_temps = .{.mem}, |
| | 5518 | .each = .{ .once = &.{ |
| | 5519 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 5520 | .{ .@"0:", ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ }, |
| | 5521 | .{ ._, ._, .@"and", .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_8_len), ._, ._ }, |
| | 5522 | .{ ._, ._, .lzcnt, .tmp1q, .tmp1q, ._, ._ }, |
| | 5523 | .{ ._, ._, .sub, .tmp1b, .sia(64, .src0, .sub_bit_size), ._, ._ }, |
| | 5524 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp1b, ._, ._ }, |
| | 5525 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 5526 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 5527 | } }, |
| | 5528 | }, .{ |
| | 5529 | .required_features = .{ .@"64bit", .lzcnt, null, null }, |
| | 5530 | .src_constraints = .{ .{ .scalar_int = .qword }, .any }, |
| | 5531 | .patterns = &.{ |
| | 5532 | .{ .src = .{ .to_mem, .none } }, |
| | 5533 | }, |
| | 5534 | .extra_temps = .{ |
| | 5535 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 5536 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 5537 | .unused, |
| | 5538 | .unused, |
| | 5539 | .unused, |
| | 5540 | .unused, |
| | 5541 | }, |
| | 5542 | .dst_temps = .{.mem}, |
| | 5543 | .each = .{ .once = &.{ |
| | 5544 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 5545 | .{ .@"0:", ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ }, |
| | 5546 | .{ ._, ._, .@"and", .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_8_len), ._, ._ }, |
| | 5547 | .{ ._, ._, .lzcnt, .tmp1q, .tmp1q, ._, ._ }, |
| | 5548 | .{ ._, ._, .sub, .tmp1b, .sia(64, .src0, .sub_bit_size), ._, ._ }, |
| | 5549 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp1b, ._, ._ }, |
| | 5550 | .{ ._, ._, .inc, .tmp0p, ._, ._, ._ }, |
| | 5551 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 5552 | } }, |
| | 5553 | }, .{ |
| | 5554 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, .slow_incdec, null }, |
| | 5555 | .src_constraints = .{ .{ .scalar_int = .byte }, .any }, |
| | 5556 | .patterns = &.{ |
| | 5557 | .{ .src = .{ .to_mem, .none } }, |
| | 5558 | }, |
| | 5559 | .extra_temps = .{ |
| | 5560 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 5561 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5562 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5563 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 5564 | .unused, |
| | 5565 | .unused, |
| | 5566 | }, |
| | 5567 | .dst_temps = .{.mem}, |
| | 5568 | .each = .{ .once = &.{ |
| | 5569 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 5570 | .{ ._, ._, .mov, .tmp1d, .si(0xff), ._, ._ }, |
| | 5571 | .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_len), ._, ._ }, |
| | 5572 | .{ ._, ._, .@"and", .tmp2d, .sa(.src0, .add_umax), ._, ._ }, |
| | 5573 | .{ ._, ._r, .bs, .tmp2d, .tmp2d, ._, ._ }, |
| | 5574 | .{ ._, ._z, .cmov, .tmp2d, .tmp1d, ._, ._ }, |
| | 5575 | .{ ._, ._, .mov, .tmp3b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 5576 | .{ ._, ._, .sub, .tmp3b, .tmp2b, ._, ._ }, |
| | 5577 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp3b, ._, ._ }, |
| | 5578 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 5579 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 5580 | } }, |
| | 5581 | }, .{ |
| | 5582 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, |
| | 5583 | .src_constraints = .{ .{ .scalar_int = .byte }, .any }, |
| | 5584 | .patterns = &.{ |
| | 5585 | .{ .src = .{ .to_mem, .none } }, |
| | 5586 | }, |
| | 5587 | .extra_temps = .{ |
| | 5588 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 5589 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5590 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5591 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 5592 | .unused, |
| | 5593 | .unused, |
| | 5594 | }, |
| | 5595 | .dst_temps = .{.mem}, |
| | 5596 | .each = .{ .once = &.{ |
| | 5597 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 5598 | .{ ._, ._, .mov, .tmp1d, .si(0xff), ._, ._ }, |
| | 5599 | .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_len), ._, ._ }, |
| | 5600 | .{ ._, ._, .@"and", .tmp2d, .sa(.src0, .add_umax), ._, ._ }, |
| | 5601 | .{ ._, ._r, .bs, .tmp2d, .tmp2d, ._, ._ }, |
| | 5602 | .{ ._, ._z, .cmov, .tmp2d, .tmp1d, ._, ._ }, |
| | 5603 | .{ ._, ._, .mov, .tmp3b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 5604 | .{ ._, ._, .sub, .tmp3b, .tmp2b, ._, ._ }, |
| | 5605 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp3b, ._, ._ }, |
| | 5606 | .{ ._, ._, .inc, .tmp0p, ._, ._, ._ }, |
| | 5607 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 5608 | } }, |
| | 5609 | }, .{ |
| | 5610 | .required_features = .{ .bsf_bsr_0_clobbers_result, .slow_incdec, null, null }, |
| | 5611 | .src_constraints = .{ .{ .scalar_int = .byte }, .any }, |
| | 5612 | .patterns = &.{ |
| | 5613 | .{ .src = .{ .to_mem, .none } }, |
| | 5614 | }, |
| | 5615 | .extra_temps = .{ |
| | 5616 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 5617 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5618 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5619 | .unused, |
| | 5620 | .unused, |
| | 5621 | .unused, |
| | 5622 | }, |
| | 5623 | .dst_temps = .{.mem}, |
| | 5624 | .each = .{ .once = &.{ |
| | 5625 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 5626 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_len), ._, ._ }, |
| | 5627 | .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ }, |
| | 5628 | .{ ._, ._r, .bs, .tmp1d, .tmp1d, ._, ._ }, |
| | 5629 | .{ ._, ._, .mov, .tmp2b, .sa(.src0, .add_bit_size), ._, ._ }, |
| | 5630 | .{ ._, ._z, .j, .@"1f", ._, ._, ._ }, |
| | 5631 | .{ ._, ._c, .st, ._, ._, ._, ._ }, |
| | 5632 | .{ ._, ._, .sbb, .tmp2b, .tmp1b, ._, ._ }, |
| | 5633 | .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp2b, ._, ._ }, |
| | 5634 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 5635 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 5636 | } }, |
| | 5637 | }, .{ |
| | 5638 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, |
| | 5639 | .src_constraints = .{ .{ .scalar_int = .byte }, .any }, |
| | 5640 | .patterns = &.{ |
| | 5641 | .{ .src = .{ .to_mem, .none } }, |
| | 5642 | }, |
| | 5643 | .extra_temps = .{ |
| | 5644 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 5645 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5646 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5647 | .unused, |
| | 5648 | .unused, |
| | 5649 | .unused, |
| | 5650 | }, |
| | 5651 | .dst_temps = .{.mem}, |
| | 5652 | .each = .{ .once = &.{ |
| | 5653 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 5654 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_len), ._, ._ }, |
| | 5655 | .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ }, |
| | 5656 | .{ ._, ._r, .bs, .tmp1d, .tmp1d, ._, ._ }, |
| | 5657 | .{ ._, ._, .mov, .tmp2b, .sa(.src0, .add_bit_size), ._, ._ }, |
| | 5658 | .{ ._, ._z, .j, .@"1f", ._, ._, ._ }, |
| | 5659 | .{ ._, ._c, .st, ._, ._, ._, ._ }, |
| | 5660 | .{ ._, ._, .sbb, .tmp2b, .tmp1b, ._, ._ }, |
| | 5661 | .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp2b, ._, ._ }, |
| | 5662 | .{ ._, ._, .inc, .tmp0p, ._, ._, ._ }, |
| | 5663 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 5664 | } }, |
| | 5665 | }, .{ |
| | 5666 | .required_features = .{ .slow_incdec, null, null, null }, |
| | 5667 | .src_constraints = .{ .{ .scalar_int = .byte }, .any }, |
| | 5668 | .patterns = &.{ |
| | 5669 | .{ .src = .{ .to_mem, .none } }, |
| | 5670 | }, |
| | 5671 | .extra_temps = .{ |
| | 5672 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 5673 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5674 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5675 | .unused, |
| | 5676 | .unused, |
| | 5677 | .unused, |
| | 5678 | }, |
| | 5679 | .dst_temps = .{.mem}, |
| | 5680 | .each = .{ .once = &.{ |
| | 5681 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 5682 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_len), ._, ._ }, |
| | 5683 | .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ }, |
| | 5684 | .{ ._, ._, .mov, .tmp2d, .si(0xff), ._, ._ }, |
| | 5685 | .{ ._, ._r, .bs, .tmp2d, .tmp1d, ._, ._ }, |
| | 5686 | .{ ._, ._, .mov, .tmp1b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 5687 | .{ ._, ._, .sub, .tmp1b, .tmp2b, ._, ._ }, |
| | 5688 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp1b, ._, ._ }, |
| | 5689 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 5690 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 5691 | } }, |
| | 5692 | }, .{ |
| | 5693 | .src_constraints = .{ .{ .scalar_int = .byte }, .any }, |
| | 5694 | .patterns = &.{ |
| | 5695 | .{ .src = .{ .to_mem, .none } }, |
| | 5696 | }, |
| | 5697 | .extra_temps = .{ |
| | 5698 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 5699 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5700 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5701 | .unused, |
| | 5702 | .unused, |
| | 5703 | .unused, |
| | 5704 | }, |
| | 5705 | .dst_temps = .{.mem}, |
| | 5706 | .each = .{ .once = &.{ |
| | 5707 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 5708 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_len), ._, ._ }, |
| | 5709 | .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ }, |
| | 5710 | .{ ._, ._, .mov, .tmp2d, .si(0xff), ._, ._ }, |
| | 5711 | .{ ._, ._r, .bs, .tmp2d, .tmp1d, ._, ._ }, |
| | 5712 | .{ ._, ._, .mov, .tmp1b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 5713 | .{ ._, ._, .sub, .tmp1b, .tmp2b, ._, ._ }, |
| | 5714 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp1b, ._, ._ }, |
| | 5715 | .{ ._, ._, .inc, .tmp0p, ._, ._, ._ }, |
| | 5716 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 5717 | } }, |
| | 5718 | }, .{ |
| | 5719 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, .slow_incdec, null }, |
| | 5720 | .src_constraints = .{ .{ .scalar_int = .word }, .any }, |
| | 5721 | .patterns = &.{ |
| | 5722 | .{ .src = .{ .to_mem, .none } }, |
| | 5723 | }, |
| | 5724 | .extra_temps = .{ |
| | 5725 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 5726 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5727 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5728 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 5729 | .unused, |
| | 5730 | .unused, |
| | 5731 | }, |
| | 5732 | .dst_temps = .{.mem}, |
| | 5733 | .each = .{ .once = &.{ |
| | 5734 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 5735 | .{ ._, ._, .mov, .tmp1d, .si(0xff), ._, ._ }, |
| | 5736 | .{ .@"0:", ._, .movzx, .tmp2d, .memsia(.src0w, .@"2", .tmp0, .add_2_len), ._, ._ }, |
| | 5737 | .{ ._, ._, .@"and", .tmp2d, .sa(.src0, .add_umax), ._, ._ }, |
| | 5738 | .{ ._, ._r, .bs, .tmp2d, .tmp2d, ._, ._ }, |
| | 5739 | .{ ._, ._z, .cmov, .tmp2d, .tmp1d, ._, ._ }, |
| | 5740 | .{ ._, ._, .mov, .tmp3b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 5741 | .{ ._, ._, .sub, .tmp3b, .tmp2b, ._, ._ }, |
| | 5742 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp3b, ._, ._ }, |
| | 5743 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 5744 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 5745 | } }, |
| | 5746 | }, .{ |
| | 5747 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, |
| | 5748 | .src_constraints = .{ .{ .scalar_int = .word }, .any }, |
| | 5749 | .patterns = &.{ |
| | 5750 | .{ .src = .{ .to_mem, .none } }, |
| | 5751 | }, |
| | 5752 | .extra_temps = .{ |
| | 5753 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 5754 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5755 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5756 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 5757 | .unused, |
| | 5758 | .unused, |
| | 5759 | }, |
| | 5760 | .dst_temps = .{.mem}, |
| | 5761 | .each = .{ .once = &.{ |
| | 5762 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 5763 | .{ ._, ._, .mov, .tmp1d, .si(0xff), ._, ._ }, |
| | 5764 | .{ .@"0:", ._, .movzx, .tmp2d, .memsia(.src0w, .@"2", .tmp0, .add_2_len), ._, ._ }, |
| | 5765 | .{ ._, ._, .@"and", .tmp2d, .sa(.src0, .add_umax), ._, ._ }, |
| | 5766 | .{ ._, ._r, .bs, .tmp2d, .tmp2d, ._, ._ }, |
| | 5767 | .{ ._, ._z, .cmov, .tmp2d, .tmp1d, ._, ._ }, |
| | 5768 | .{ ._, ._, .mov, .tmp3b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 5769 | .{ ._, ._, .sub, .tmp3b, .tmp2b, ._, ._ }, |
| | 5770 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp3b, ._, ._ }, |
| | 5771 | .{ ._, ._, .inc, .tmp0p, ._, ._, ._ }, |
| | 5772 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 5773 | } }, |
| | 5774 | }, .{ |
| | 5775 | .required_features = .{ .bsf_bsr_0_clobbers_result, .slow_incdec, null, null }, |
| | 5776 | .src_constraints = .{ .{ .scalar_int = .word }, .any }, |
| | 5777 | .patterns = &.{ |
| | 5778 | .{ .src = .{ .to_mem, .none } }, |
| | 5779 | }, |
| | 5780 | .extra_temps = .{ |
| | 5781 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 5782 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5783 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5784 | .unused, |
| | 5785 | .unused, |
| | 5786 | .unused, |
| | 5787 | }, |
| | 5788 | .dst_temps = .{.mem}, |
| | 5789 | .each = .{ .once = &.{ |
| | 5790 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 5791 | .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0w, .@"2", .tmp0, .add_2_len), ._, ._ }, |
| | 5792 | .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ }, |
| | 5793 | .{ ._, ._r, .bs, .tmp1d, .tmp1d, ._, ._ }, |
| | 5794 | .{ ._, ._, .mov, .tmp2b, .sa(.src0, .add_bit_size), ._, ._ }, |
| | 5795 | .{ ._, ._z, .j, .@"1f", ._, ._, ._ }, |
| | 5796 | .{ ._, ._c, .st, ._, ._, ._, ._ }, |
| | 5797 | .{ ._, ._, .sbb, .tmp2b, .tmp1b, ._, ._ }, |
| | 5798 | .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp2b, ._, ._ }, |
| | 5799 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 5800 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 5801 | } }, |
| | 5802 | }, .{ |
| | 5803 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, |
| | 5804 | .src_constraints = .{ .{ .scalar_int = .word }, .any }, |
| | 5805 | .patterns = &.{ |
| | 5806 | .{ .src = .{ .to_mem, .none } }, |
| | 5807 | }, |
| | 5808 | .extra_temps = .{ |
| | 5809 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 5810 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5811 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5812 | .unused, |
| | 5813 | .unused, |
| | 5814 | .unused, |
| | 5815 | }, |
| | 5816 | .dst_temps = .{.mem}, |
| | 5817 | .each = .{ .once = &.{ |
| | 5818 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 5819 | .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0w, .@"2", .tmp0, .add_2_len), ._, ._ }, |
| | 5820 | .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ }, |
| | 5821 | .{ ._, ._r, .bs, .tmp1d, .tmp1d, ._, ._ }, |
| | 5822 | .{ ._, ._, .mov, .tmp2b, .sa(.src0, .add_bit_size), ._, ._ }, |
| | 5823 | .{ ._, ._z, .j, .@"1f", ._, ._, ._ }, |
| | 5824 | .{ ._, ._c, .st, ._, ._, ._, ._ }, |
| | 5825 | .{ ._, ._, .sbb, .tmp2b, .tmp1b, ._, ._ }, |
| | 5826 | .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp2b, ._, ._ }, |
| | 5827 | .{ ._, ._, .inc, .tmp0p, ._, ._, ._ }, |
| | 5828 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 5829 | } }, |
| | 5830 | }, .{ |
| | 5831 | .required_features = .{ .slow_incdec, null, null, null }, |
| | 5832 | .src_constraints = .{ .{ .scalar_int = .word }, .any }, |
| | 5833 | .patterns = &.{ |
| | 5834 | .{ .src = .{ .to_mem, .none } }, |
| | 5835 | }, |
| | 5836 | .extra_temps = .{ |
| | 5837 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 5838 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5839 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5840 | .unused, |
| | 5841 | .unused, |
| | 5842 | .unused, |
| | 5843 | }, |
| | 5844 | .dst_temps = .{.mem}, |
| | 5845 | .each = .{ .once = &.{ |
| | 5846 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 5847 | .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0w, .@"2", .tmp0, .add_2_len), ._, ._ }, |
| | 5848 | .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ }, |
| | 5849 | .{ ._, ._, .mov, .tmp2d, .si(0xff), ._, ._ }, |
| | 5850 | .{ ._, ._r, .bs, .tmp2d, .tmp1d, ._, ._ }, |
| | 5851 | .{ ._, ._, .mov, .tmp1b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 5852 | .{ ._, ._, .sub, .tmp1b, .tmp2b, ._, ._ }, |
| | 5853 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp1b, ._, ._ }, |
| | 5854 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 5855 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 5856 | } }, |
| | 5857 | }, .{ |
| | 5858 | .src_constraints = .{ .{ .scalar_int = .word }, .any }, |
| | 5859 | .patterns = &.{ |
| | 5860 | .{ .src = .{ .to_mem, .none } }, |
| | 5861 | }, |
| | 5862 | .extra_temps = .{ |
| | 5863 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 5864 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5865 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5866 | .unused, |
| | 5867 | .unused, |
| | 5868 | .unused, |
| | 5869 | }, |
| | 5870 | .dst_temps = .{.mem}, |
| | 5871 | .each = .{ .once = &.{ |
| | 5872 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 5873 | .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0w, .@"2", .tmp0, .add_2_len), ._, ._ }, |
| | 5874 | .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ }, |
| | 5875 | .{ ._, ._, .mov, .tmp2d, .si(0xff), ._, ._ }, |
| | 5876 | .{ ._, ._r, .bs, .tmp2d, .tmp1d, ._, ._ }, |
| | 5877 | .{ ._, ._, .mov, .tmp1b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 5878 | .{ ._, ._, .sub, .tmp1b, .tmp2b, ._, ._ }, |
| | 5879 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp1b, ._, ._ }, |
| | 5880 | .{ ._, ._, .inc, .tmp0p, ._, ._, ._ }, |
| | 5881 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 5882 | } }, |
| | 5883 | }, .{ |
| | 5884 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, .slow_incdec, null }, |
| | 5885 | .src_constraints = .{ .{ .scalar_int = .dword }, .any }, |
| | 5886 | .patterns = &.{ |
| | 5887 | .{ .src = .{ .to_mem, .none } }, |
| | 5888 | }, |
| | 5889 | .extra_temps = .{ |
| | 5890 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 5891 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5892 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5893 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 5894 | .unused, |
| | 5895 | .unused, |
| | 5896 | }, |
| | 5897 | .dst_temps = .{.mem}, |
| | 5898 | .each = .{ .once = &.{ |
| | 5899 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 5900 | .{ ._, ._, .mov, .tmp1d, .si(0xff), ._, ._ }, |
| | 5901 | .{ .@"0:", ._, .mov, .tmp2d, .memsia(.src0d, .@"4", .tmp0, .add_4_len), ._, ._ }, |
| | 5902 | .{ ._, ._, .@"and", .tmp2d, .sa(.src0, .add_umax), ._, ._ }, |
| | 5903 | .{ ._, ._r, .bs, .tmp2d, .tmp2d, ._, ._ }, |
| | 5904 | .{ ._, ._z, .cmov, .tmp2d, .tmp1d, ._, ._ }, |
| | 5905 | .{ ._, ._, .mov, .tmp3b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 5906 | .{ ._, ._, .sub, .tmp3b, .tmp2b, ._, ._ }, |
| | 5907 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp3b, ._, ._ }, |
| | 5908 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 5909 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 5910 | } }, |
| | 5911 | }, .{ |
| | 5912 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, |
| | 5913 | .src_constraints = .{ .{ .scalar_int = .dword }, .any }, |
| | 5914 | .patterns = &.{ |
| | 5915 | .{ .src = .{ .to_mem, .none } }, |
| | 5916 | }, |
| | 5917 | .extra_temps = .{ |
| | 5918 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 5919 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5920 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5921 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 5922 | .unused, |
| | 5923 | .unused, |
| | 5924 | }, |
| | 5925 | .dst_temps = .{.mem}, |
| | 5926 | .each = .{ .once = &.{ |
| | 5927 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 5928 | .{ ._, ._, .mov, .tmp1d, .si(0xff), ._, ._ }, |
| | 5929 | .{ .@"0:", ._, .mov, .tmp2d, .memsia(.src0d, .@"4", .tmp0, .add_4_len), ._, ._ }, |
| | 5930 | .{ ._, ._, .@"and", .tmp2d, .sa(.src0, .add_umax), ._, ._ }, |
| | 5931 | .{ ._, ._r, .bs, .tmp2d, .tmp2d, ._, ._ }, |
| | 5932 | .{ ._, ._z, .cmov, .tmp2d, .tmp1d, ._, ._ }, |
| | 5933 | .{ ._, ._, .mov, .tmp3b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 5934 | .{ ._, ._, .sub, .tmp3b, .tmp2b, ._, ._ }, |
| | 5935 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp3b, ._, ._ }, |
| | 5936 | .{ ._, ._, .inc, .tmp0p, ._, ._, ._ }, |
| | 5937 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 5938 | } }, |
| | 5939 | }, .{ |
| | 5940 | .required_features = .{ .bsf_bsr_0_clobbers_result, .slow_incdec, null, null }, |
| | 5941 | .src_constraints = .{ .{ .scalar_int = .dword }, .any }, |
| | 5942 | .patterns = &.{ |
| | 5943 | .{ .src = .{ .to_mem, .none } }, |
| | 5944 | }, |
| | 5945 | .extra_temps = .{ |
| | 5946 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 5947 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5948 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5949 | .unused, |
| | 5950 | .unused, |
| | 5951 | .unused, |
| | 5952 | }, |
| | 5953 | .dst_temps = .{.mem}, |
| | 5954 | .each = .{ .once = &.{ |
| | 5955 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 5956 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_4_len), ._, ._ }, |
| | 5957 | .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ }, |
| | 5958 | .{ ._, ._r, .bs, .tmp1d, .tmp1d, ._, ._ }, |
| | 5959 | .{ ._, ._, .mov, .tmp2b, .sa(.src0, .add_bit_size), ._, ._ }, |
| | 5960 | .{ ._, ._z, .j, .@"1f", ._, ._, ._ }, |
| | 5961 | .{ ._, ._c, .st, ._, ._, ._, ._ }, |
| | 5962 | .{ ._, ._, .sbb, .tmp2b, .tmp1b, ._, ._ }, |
| | 5963 | .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp2b, ._, ._ }, |
| | 5964 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 5965 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 5966 | } }, |
| | 5967 | }, .{ |
| | 5968 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, |
| | 5969 | .src_constraints = .{ .{ .scalar_int = .dword }, .any }, |
| | 5970 | .patterns = &.{ |
| | 5971 | .{ .src = .{ .to_mem, .none } }, |
| | 5972 | }, |
| | 5973 | .extra_temps = .{ |
| | 5974 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 5975 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5976 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 5977 | .unused, |
| | 5978 | .unused, |
| | 5979 | .unused, |
| | 5980 | }, |
| | 5981 | .dst_temps = .{.mem}, |
| | 5982 | .each = .{ .once = &.{ |
| | 5983 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 5984 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_4_len), ._, ._ }, |
| | 5985 | .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ }, |
| | 5986 | .{ ._, ._r, .bs, .tmp1d, .tmp1d, ._, ._ }, |
| | 5987 | .{ ._, ._, .mov, .tmp2b, .sa(.src0, .add_bit_size), ._, ._ }, |
| | 5988 | .{ ._, ._z, .j, .@"1f", ._, ._, ._ }, |
| | 5989 | .{ ._, ._c, .st, ._, ._, ._, ._ }, |
| | 5990 | .{ ._, ._, .sbb, .tmp2b, .tmp1b, ._, ._ }, |
| | 5991 | .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp2b, ._, ._ }, |
| | 5992 | .{ ._, ._, .inc, .tmp0p, ._, ._, ._ }, |
| | 5993 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 5994 | } }, |
| | 5995 | }, .{ |
| | 5996 | .required_features = .{ .slow_incdec, null, null, null }, |
| | 5997 | .src_constraints = .{ .{ .scalar_int = .dword }, .any }, |
| | 5998 | .patterns = &.{ |
| | 5999 | .{ .src = .{ .to_mem, .none } }, |
| | 6000 | }, |
| | 6001 | .extra_temps = .{ |
| | 6002 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 6003 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 6004 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 6005 | .unused, |
| | 6006 | .unused, |
| | 6007 | .unused, |
| | 6008 | }, |
| | 6009 | .dst_temps = .{.mem}, |
| | 6010 | .each = .{ .once = &.{ |
| | 6011 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 6012 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_4_len), ._, ._ }, |
| | 6013 | .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ }, |
| | 6014 | .{ ._, ._, .mov, .tmp2d, .si(0xff), ._, ._ }, |
| | 6015 | .{ ._, ._r, .bs, .tmp2d, .tmp1d, ._, ._ }, |
| | 6016 | .{ ._, ._, .mov, .tmp1b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 6017 | .{ ._, ._, .sub, .tmp1b, .tmp2b, ._, ._ }, |
| | 6018 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp1b, ._, ._ }, |
| | 6019 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 6020 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 6021 | } }, |
| | 6022 | }, .{ |
| | 6023 | .src_constraints = .{ .{ .scalar_int = .dword }, .any }, |
| | 6024 | .patterns = &.{ |
| | 6025 | .{ .src = .{ .to_mem, .none } }, |
| | 6026 | }, |
| | 6027 | .extra_temps = .{ |
| | 6028 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 6029 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 6030 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 6031 | .unused, |
| | 6032 | .unused, |
| | 6033 | .unused, |
| | 6034 | }, |
| | 6035 | .dst_temps = .{.mem}, |
| | 6036 | .each = .{ .once = &.{ |
| | 6037 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 6038 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_4_len), ._, ._ }, |
| | 6039 | .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ }, |
| | 6040 | .{ ._, ._, .mov, .tmp2d, .si(0xff), ._, ._ }, |
| | 6041 | .{ ._, ._r, .bs, .tmp2d, .tmp1d, ._, ._ }, |
| | 6042 | .{ ._, ._, .mov, .tmp1b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 6043 | .{ ._, ._, .sub, .tmp1b, .tmp2b, ._, ._ }, |
| | 6044 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp1b, ._, ._ }, |
| | 6045 | .{ ._, ._, .inc, .tmp0p, ._, ._, ._ }, |
| | 6046 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 6047 | } }, |
| | 6048 | }, .{ |
| | 6049 | .required_features = .{ .@"64bit", .cmov, .bsf_bsr_0_clobbers_result, .slow_incdec }, |
| | 6050 | .src_constraints = .{ .{ .scalar_int = .qword }, .any }, |
| | 6051 | .patterns = &.{ |
| | 6052 | .{ .src = .{ .to_mem, .none } }, |
| | 6053 | }, |
| | 6054 | .extra_temps = .{ |
| | 6055 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 6056 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 6057 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 6058 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 6059 | .unused, |
| | 6060 | .unused, |
| | 6061 | }, |
| | 6062 | .dst_temps = .{.mem}, |
| | 6063 | .each = .{ .once = &.{ |
| | 6064 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 6065 | .{ ._, ._, .mov, .tmp1d, .si(0xff), ._, ._ }, |
| | 6066 | .{ .@"0:", ._, .mov, .tmp2q, .ua(.src0, .add_umax), ._, ._ }, |
| | 6067 | .{ ._, ._, .@"and", .tmp2q, .memsia(.src0q, .@"8", .tmp0, .add_8_len), ._, ._ }, |
| | 6068 | .{ ._, ._r, .bs, .tmp2q, .tmp2q, ._, ._ }, |
| | 6069 | .{ ._, ._z, .cmov, .tmp2d, .tmp1d, ._, ._ }, |
| | 6070 | .{ ._, ._, .mov, .tmp3b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 6071 | .{ ._, ._, .sub, .tmp3b, .tmp2b, ._, ._ }, |
| | 6072 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp3b, ._, ._ }, |
| | 6073 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 6074 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 6075 | } }, |
| | 6076 | }, .{ |
| | 6077 | .required_features = .{ .@"64bit", .cmov, .bsf_bsr_0_clobbers_result, null }, |
| | 6078 | .src_constraints = .{ .{ .scalar_int = .qword }, .any }, |
| | 6079 | .patterns = &.{ |
| | 6080 | .{ .src = .{ .to_mem, .none } }, |
| | 6081 | }, |
| | 6082 | .extra_temps = .{ |
| | 6083 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 6084 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 6085 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 6086 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 6087 | .unused, |
| | 6088 | .unused, |
| | 6089 | }, |
| | 6090 | .dst_temps = .{.mem}, |
| | 6091 | .each = .{ .once = &.{ |
| | 6092 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 6093 | .{ ._, ._, .mov, .tmp1d, .si(0xff), ._, ._ }, |
| | 6094 | .{ .@"0:", ._, .mov, .tmp2q, .ua(.src0, .add_umax), ._, ._ }, |
| | 6095 | .{ ._, ._, .@"and", .tmp2q, .memsia(.src0q, .@"8", .tmp0, .add_8_len), ._, ._ }, |
| | 6096 | .{ ._, ._r, .bs, .tmp2q, .tmp2q, ._, ._ }, |
| | 6097 | .{ ._, ._z, .cmov, .tmp2d, .tmp1d, ._, ._ }, |
| | 6098 | .{ ._, ._, .mov, .tmp3b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 6099 | .{ ._, ._, .sub, .tmp3b, .tmp2b, ._, ._ }, |
| | 6100 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp3b, ._, ._ }, |
| | 6101 | .{ ._, ._, .inc, .tmp0p, ._, ._, ._ }, |
| | 6102 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 6103 | } }, |
| | 6104 | }, .{ |
| | 6105 | .required_features = .{ .@"64bit", .bsf_bsr_0_clobbers_result, .slow_incdec, null }, |
| | 6106 | .src_constraints = .{ .{ .scalar_int = .qword }, .any }, |
| | 6107 | .patterns = &.{ |
| | 6108 | .{ .src = .{ .to_mem, .none } }, |
| | 6109 | }, |
| | 6110 | .extra_temps = .{ |
| | 6111 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 6112 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 6113 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 6114 | .unused, |
| | 6115 | .unused, |
| | 6116 | .unused, |
| | 6117 | }, |
| | 6118 | .dst_temps = .{.mem}, |
| | 6119 | .each = .{ .once = &.{ |
| | 6120 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 6121 | .{ .@"0:", ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ }, |
| | 6122 | .{ ._, ._, .@"and", .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_8_len), ._, ._ }, |
| | 6123 | .{ ._, ._r, .bs, .tmp1q, .tmp1q, ._, ._ }, |
| | 6124 | .{ ._, ._, .mov, .tmp2b, .sa(.src0, .add_bit_size), ._, ._ }, |
| | 6125 | .{ ._, ._z, .j, .@"1f", ._, ._, ._ }, |
| | 6126 | .{ ._, ._c, .st, ._, ._, ._, ._ }, |
| | 6127 | .{ ._, ._, .sbb, .tmp2b, .tmp1b, ._, ._ }, |
| | 6128 | .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp2b, ._, ._ }, |
| | 6129 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 6130 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 6131 | } }, |
| | 6132 | }, .{ |
| | 6133 | .required_features = .{ .@"64bit", .bsf_bsr_0_clobbers_result, null, null }, |
| | 6134 | .src_constraints = .{ .{ .scalar_int = .qword }, .any }, |
| | 6135 | .patterns = &.{ |
| | 6136 | .{ .src = .{ .to_mem, .none } }, |
| | 6137 | }, |
| | 6138 | .extra_temps = .{ |
| | 6139 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 6140 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 6141 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 6142 | .unused, |
| | 6143 | .unused, |
| | 6144 | .unused, |
| | 6145 | }, |
| | 6146 | .dst_temps = .{.mem}, |
| | 6147 | .each = .{ .once = &.{ |
| | 6148 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 6149 | .{ .@"0:", ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ }, |
| | 6150 | .{ ._, ._, .@"and", .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_8_len), ._, ._ }, |
| | 6151 | .{ ._, ._r, .bs, .tmp1q, .tmp1q, ._, ._ }, |
| | 6152 | .{ ._, ._, .mov, .tmp2b, .sa(.src0, .add_bit_size), ._, ._ }, |
| | 6153 | .{ ._, ._z, .j, .@"1f", ._, ._, ._ }, |
| | 6154 | .{ ._, ._c, .st, ._, ._, ._, ._ }, |
| | 6155 | .{ ._, ._, .sbb, .tmp2b, .tmp1b, ._, ._ }, |
| | 6156 | .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp2b, ._, ._ }, |
| | 6157 | .{ ._, ._, .inc, .tmp0p, ._, ._, ._ }, |
| | 6158 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 6159 | } }, |
| | 6160 | }, .{ |
| | 6161 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| | 6162 | .src_constraints = .{ .{ .scalar_int = .qword }, .any }, |
| | 6163 | .patterns = &.{ |
| | 6164 | .{ .src = .{ .to_mem, .none } }, |
| | 6165 | }, |
| | 6166 | .extra_temps = .{ |
| | 6167 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 6168 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 6169 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 6170 | .unused, |
| | 6171 | .unused, |
| | 6172 | .unused, |
| | 6173 | }, |
| | 6174 | .dst_temps = .{.mem}, |
| | 6175 | .each = .{ .once = &.{ |
| | 6176 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 6177 | .{ .@"0:", ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ }, |
| | 6178 | .{ ._, ._, .@"and", .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_8_len), ._, ._ }, |
| | 6179 | .{ ._, ._, .mov, .tmp2d, .si(0xff), ._, ._ }, |
| | 6180 | .{ ._, ._r, .bs, .tmp2q, .tmp1q, ._, ._ }, |
| | 6181 | .{ ._, ._, .mov, .tmp1b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 6182 | .{ ._, ._, .sub, .tmp1b, .tmp2b, ._, ._ }, |
| | 6183 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp1b, ._, ._ }, |
| | 6184 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 6185 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 6186 | } }, |
| | 6187 | }, .{ |
| | 6188 | .required_features = .{ .@"64bit", null, null, null }, |
| | 6189 | .src_constraints = .{ .{ .scalar_int = .qword }, .any }, |
| | 6190 | .patterns = &.{ |
| | 6191 | .{ .src = .{ .to_mem, .none } }, |
| | 6192 | }, |
| | 6193 | .extra_temps = .{ |
| | 6194 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 6195 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 6196 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 6197 | .unused, |
| | 6198 | .unused, |
| | 6199 | .unused, |
| | 6200 | }, |
| | 6201 | .dst_temps = .{.mem}, |
| | 6202 | .each = .{ .once = &.{ |
| | 6203 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 6204 | .{ .@"0:", ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ }, |
| | 6205 | .{ ._, ._, .@"and", .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_8_len), ._, ._ }, |
| | 6206 | .{ ._, ._, .mov, .tmp2d, .si(0xff), ._, ._ }, |
| | 6207 | .{ ._, ._r, .bs, .tmp2q, .tmp1q, ._, ._ }, |
| | 6208 | .{ ._, ._, .mov, .tmp1b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| | 6209 | .{ ._, ._, .sub, .tmp1b, .tmp2b, ._, ._ }, |
| | 6210 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp1b, ._, ._ }, |
| | 6211 | .{ ._, ._, .inc, .tmp0p, ._, ._, ._ }, |
| | 6212 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 6213 | } }, |
| | 6214 | }, .{ |
| | 6215 | .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null }, |
| | 6216 | .dst_constraints = .{.{ .scalar_int = .byte }}, |
| | 6217 | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .qword } }, .any }, |
| | 6218 | .patterns = &.{ |
| | 6219 | .{ .src = .{ .to_mem, .none } }, |
| | 6220 | }, |
| | 6221 | .extra_temps = .{ |
| | 6222 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 6223 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 6224 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 6225 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 6226 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 6227 | .unused, |
| | 6228 | }, |
| | 6229 | .dst_temps = .{.mem}, |
| | 6230 | .each = .{ .once = &.{ |
| | 6231 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 6232 | .{ ._, ._, .lea, .tmp1q, .mem(.src0), ._, ._ }, |
| | 6233 | .{ .@"0:", ._, .mov, .tmp2d, .sia(-16, .none, .add_src0_elem_size), ._, ._ }, |
| | 6234 | .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ }, |
| | 6235 | .{ .@"1:", ._, .@"and", .tmp3q, .leai(.qword, .tmp1, .tmp2), ._, ._ }, |
| | 6236 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 6237 | .{ ._, ._, .lzcnt, .tmp4q, .tmp3q, ._, ._ }, |
| | 6238 | .{ ._, ._nc, .j, .@"1f", ._, ._, ._ }, |
| | 6239 | .{ ._, ._, .mov, .tmp3q, .si(-1), ._, ._ }, |
| | 6240 | .{ ._, ._, .sub, .tmp2d, .si(8), ._, ._ }, |
| | 6241 | .{ ._, ._nc, .j, .@"1b", ._, ._, ._ }, |
| | 6242 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 6243 | .{ .@"1:", ._, .neg, .tmp2d, ._, ._, ._ }, |
| | 6244 | .{ ._, ._, .lea, .tmp3d, .leasiad(.none, .tmp4, .@"8", .tmp2, .add_src0_bit_size, -64), ._, ._ }, |
| | 6245 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp3b, ._, ._ }, |
| | 6246 | .{ ._, ._, .lea, .tmp1q, .leaa(.none, .tmp1, .add_src0_elem_size), ._, ._ }, |
| | 6247 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 6248 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 6249 | } }, |
| | 6250 | }, .{ |
| | 6251 | .required_features = .{ .@"64bit", .lzcnt, null, null }, |
| | 6252 | .dst_constraints = .{.{ .scalar_int = .byte }}, |
| | 6253 | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .qword } }, .any }, |
| | 6254 | .patterns = &.{ |
| | 6255 | .{ .src = .{ .to_mem, .none } }, |
| | 6256 | }, |
| | 6257 | .extra_temps = .{ |
| | 6258 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 6259 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 6260 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 6261 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 6262 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 6263 | .unused, |
| | 6264 | }, |
| | 6265 | .dst_temps = .{.mem}, |
| | 6266 | .each = .{ .once = &.{ |
| | 6267 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 6268 | .{ ._, ._, .lea, .tmp1q, .mem(.src0), ._, ._ }, |
| | 6269 | .{ .@"0:", ._, .mov, .tmp2d, .sia(-16, .none, .add_src0_elem_size), ._, ._ }, |
| | 6270 | .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ }, |
| | 6271 | .{ .@"1:", ._, .@"and", .tmp3q, .leai(.qword, .tmp1, .tmp2), ._, ._ }, |
| | 6272 | .{ ._, ._, .lzcnt, .tmp4q, .tmp3q, ._, ._ }, |
| | 6273 | .{ ._, ._nc, .j, .@"1f", ._, ._, ._ }, |
| | 6274 | .{ ._, ._, .mov, .tmp3q, .si(-1), ._, ._ }, |
| | 6275 | .{ ._, ._, .sub, .tmp2d, .si(8), ._, ._ }, |
| | 6276 | .{ ._, ._nc, .j, .@"1b", ._, ._, ._ }, |
| | 6277 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 6278 | .{ .@"1:", ._, .neg, .tmp2d, ._, ._, ._ }, |
| | 6279 | .{ ._, ._, .lea, .tmp3d, .leasiad(.none, .tmp4, .@"8", .tmp2, .add_src0_bit_size, -64), ._, ._ }, |
| | 6280 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp3b, ._, ._ }, |
| | 6281 | .{ ._, ._, .lea, .tmp1q, .leaa(.none, .tmp1, .add_src0_elem_size), ._, ._ }, |
| | 6282 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 6283 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 6284 | } }, |
| | 6285 | }, .{ |
| | 6286 | .required_features = .{ .@"64bit", null, null, null }, |
| | 6287 | .dst_constraints = .{.{ .scalar_int = .byte }}, |
| | 6288 | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .qword } }, .any }, |
| | 6289 | .patterns = &.{ |
| | 6290 | .{ .src = .{ .to_mem, .none } }, |
| | 6291 | }, |
| | 6292 | .extra_temps = .{ |
| | 6293 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 6294 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 6295 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 6296 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 6297 | .unused, |
| | 6298 | .unused, |
| | 6299 | }, |
| | 6300 | .dst_temps = .{.mem}, |
| | 6301 | .each = .{ .once = &.{ |
| | 6302 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 6303 | .{ ._, ._, .lea, .tmp1q, .mem(.src0), ._, ._ }, |
| | 6304 | .{ .@"0:", ._, .mov, .tmp2d, .sia(-16, .none, .add_src0_elem_size), ._, ._ }, |
| | 6305 | .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ }, |
| | 6306 | .{ .@"1:", ._, .@"and", .tmp3q, .leai(.qword, .tmp1, .tmp2), ._, ._ }, |
| | 6307 | .{ ._, ._r, .bs, .tmp3q, .tmp3q, ._, ._ }, |
| | 6308 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| | 6309 | .{ ._, ._, .mov, .tmp3q, .si(-1), ._, ._ }, |
| | 6310 | .{ ._, ._, .sub, .tmp2d, .si(8), ._, ._ }, |
| | 6311 | .{ ._, ._nc, .j, .@"1b", ._, ._, ._ }, |
| | 6312 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 6313 | .{ .@"1:", ._, .lea, .tmp3d, .leasiad(.none, .tmp3, .@"8", .tmp2, .sub_src0_bit_size, 1), ._, ._ }, |
| | 6314 | .{ ._, ._, .neg, .tmp3b, ._, ._, ._ }, |
| | 6315 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp3b, ._, ._ }, |
| | 6316 | .{ ._, ._, .lea, .tmp1q, .leaa(.none, .tmp1, .add_src0_elem_size), ._, ._ }, |
| | 6317 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 6318 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 6319 | } }, |
| | 6320 | }, .{ |
| | 6321 | .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null }, |
| | 6322 | .dst_constraints = .{.{ .scalar_int = .byte }}, |
| | 6323 | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| | 6324 | .patterns = &.{ |
| | 6325 | .{ .src = .{ .to_mem, .none } }, |
| | 6326 | }, |
| | 6327 | .extra_temps = .{ |
| | 6328 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 6329 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 6330 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 6331 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 6332 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 6333 | .unused, |
| | 6334 | }, |
| | 6335 | .dst_temps = .{.mem}, |
| | 6336 | .each = .{ .once = &.{ |
| | 6337 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 6338 | .{ ._, ._, .lea, .tmp1q, .mem(.src0), ._, ._ }, |
| | 6339 | .{ .@"0:", ._, .mov, .tmp2d, .sia(-8, .none, .add_src0_elem_size), ._, ._ }, |
| | 6340 | .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ }, |
| | 6341 | .{ .@"1:", ._, .@"and", .tmp3q, .leai(.qword, .tmp1, .tmp2), ._, ._ }, |
| | 6342 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 6343 | .{ ._, ._, .lzcnt, .tmp4q, .tmp3q, ._, ._ }, |
| | 6344 | .{ ._, ._nc, .j, .@"1f", ._, ._, ._ }, |
| | 6345 | .{ ._, ._, .mov, .tmp3q, .si(-1), ._, ._ }, |
| | 6346 | .{ ._, ._, .sub, .tmp2d, .si(8), ._, ._ }, |
| | 6347 | .{ ._, ._nc, .j, .@"1b", ._, ._, ._ }, |
| | 6348 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 6349 | .{ .@"1:", ._, .neg, .tmp2d, ._, ._, ._ }, |
| | 6350 | .{ ._, ._, .lea, .tmp3d, .leasiad(.none, .tmp4, .@"8", .tmp2, .add_src0_bit_size, -64), ._, ._ }, |
| | 6351 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp3b, ._, ._ }, |
| | 6352 | .{ ._, ._, .lea, .tmp1q, .leaa(.none, .tmp1, .add_src0_elem_size), ._, ._ }, |
| | 6353 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 6354 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 6355 | } }, |
| | 6356 | }, .{ |
| | 6357 | .required_features = .{ .@"64bit", .lzcnt, null, null }, |
| | 6358 | .dst_constraints = .{.{ .scalar_int = .byte }}, |
| | 6359 | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| | 6360 | .patterns = &.{ |
| | 6361 | .{ .src = .{ .to_mem, .none } }, |
| | 6362 | }, |
| | 6363 | .extra_temps = .{ |
| | 6364 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 6365 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 6366 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 6367 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 6368 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 6369 | .unused, |
| | 6370 | }, |
| | 6371 | .dst_temps = .{.mem}, |
| | 6372 | .each = .{ .once = &.{ |
| | 6373 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 6374 | .{ ._, ._, .lea, .tmp1q, .mem(.src0), ._, ._ }, |
| | 6375 | .{ .@"0:", ._, .mov, .tmp2d, .sia(-8, .none, .add_src0_elem_size), ._, ._ }, |
| | 6376 | .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ }, |
| | 6377 | .{ .@"1:", ._, .@"and", .tmp3q, .leai(.qword, .tmp1, .tmp2), ._, ._ }, |
| | 6378 | .{ ._, ._, .lzcnt, .tmp4q, .tmp3q, ._, ._ }, |
| | 6379 | .{ ._, ._nc, .j, .@"1f", ._, ._, ._ }, |
| | 6380 | .{ ._, ._, .mov, .tmp3q, .si(-1), ._, ._ }, |
| | 6381 | .{ ._, ._, .sub, .tmp2d, .si(8), ._, ._ }, |
| | 6382 | .{ ._, ._nc, .j, .@"1b", ._, ._, ._ }, |
| | 6383 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 6384 | .{ .@"1:", ._, .neg, .tmp2d, ._, ._, ._ }, |
| | 6385 | .{ ._, ._, .lea, .tmp3d, .leasiad(.none, .tmp4, .@"8", .tmp2, .add_src0_bit_size, -64), ._, ._ }, |
| | 6386 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp3b, ._, ._ }, |
| | 6387 | .{ ._, ._, .lea, .tmp1q, .leaa(.none, .tmp1, .add_src0_elem_size), ._, ._ }, |
| | 6388 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 6389 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 6390 | } }, |
| | 6391 | }, .{ |
| | 6392 | .required_features = .{ .@"64bit", null, null, null }, |
| | 6393 | .dst_constraints = .{.{ .scalar_int = .byte }}, |
| | 6394 | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| | 6395 | .patterns = &.{ |
| | 6396 | .{ .src = .{ .to_mem, .none } }, |
| | 6397 | }, |
| | 6398 | .extra_temps = .{ |
| | 6399 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 6400 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 6401 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 6402 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 6403 | .unused, |
| | 6404 | .unused, |
| | 6405 | }, |
| | 6406 | .dst_temps = .{.mem}, |
| | 6407 | .each = .{ .once = &.{ |
| | 6408 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 6409 | .{ ._, ._, .lea, .tmp1q, .mem(.src0), ._, ._ }, |
| | 6410 | .{ .@"0:", ._, .mov, .tmp2d, .sia(-8, .none, .add_src0_elem_size), ._, ._ }, |
| | 6411 | .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ }, |
| | 6412 | .{ .@"1:", ._, .@"and", .tmp3q, .leai(.qword, .tmp1, .tmp2), ._, ._ }, |
| | 6413 | .{ ._, ._r, .bs, .tmp3q, .tmp3q, ._, ._ }, |
| | 6414 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| | 6415 | .{ ._, ._, .mov, .tmp3q, .si(-1), ._, ._ }, |
| | 6416 | .{ ._, ._, .sub, .tmp2d, .si(8), ._, ._ }, |
| | 6417 | .{ ._, ._nc, .j, .@"1b", ._, ._, ._ }, |
| | 6418 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 6419 | .{ .@"1:", ._, .lea, .tmp3d, .leasiad(.none, .tmp3, .@"8", .tmp2, .sub_src0_bit_size, 1), ._, ._ }, |
| | 6420 | .{ ._, ._, .neg, .tmp3b, ._, ._, ._ }, |
| | 6421 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp3b, ._, ._ }, |
| | 6422 | .{ ._, ._, .lea, .tmp1q, .leaa(.none, .tmp1, .add_src0_elem_size), ._, ._ }, |
| | 6423 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 6424 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 6425 | } }, |
| | 6426 | }, .{ |
| | 6427 | .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null }, |
| | 6428 | .dst_constraints = .{.{ .scalar_int = .word }}, |
| | 6429 | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .qword } }, .any }, |
| | 6430 | .patterns = &.{ |
| | 6431 | .{ .src = .{ .to_mem, .none } }, |
| | 6432 | }, |
| | 6433 | .extra_temps = .{ |
| | 6434 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 6435 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 6436 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 6437 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 6438 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 6439 | .unused, |
| | 6440 | }, |
| | 6441 | .dst_temps = .{.mem}, |
| | 6442 | .each = .{ .once = &.{ |
| | 6443 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 6444 | .{ ._, ._, .lea, .tmp1q, .mem(.src0), ._, ._ }, |
| | 6445 | .{ .@"0:", ._, .mov, .tmp2d, .sia(-16, .none, .add_src0_elem_size), ._, ._ }, |
| | 6446 | .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ }, |
| | 6447 | .{ .@"1:", ._, .@"and", .tmp3q, .leai(.qword, .tmp1, .tmp2), ._, ._ }, |
| | 6448 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 6449 | .{ ._, ._, .lzcnt, .tmp4q, .tmp3q, ._, ._ }, |
| | 6450 | .{ ._, ._nc, .j, .@"1f", ._, ._, ._ }, |
| | 6451 | .{ ._, ._, .mov, .tmp3q, .si(-1), ._, ._ }, |
| | 6452 | .{ ._, ._, .sub, .tmp2d, .si(8), ._, ._ }, |
| | 6453 | .{ ._, ._nc, .j, .@"1b", ._, ._, ._ }, |
| | 6454 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 6455 | .{ .@"1:", ._, .neg, .tmp2d, ._, ._, ._ }, |
| | 6456 | .{ ._, ._, .lea, .tmp3d, .leasiad(.none, .tmp4, .@"8", .tmp2, .add_src0_bit_size, -64), ._, ._ }, |
| | 6457 | .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_2_len), .tmp3w, ._, ._ }, |
| | 6458 | .{ ._, ._, .lea, .tmp1q, .leaa(.none, .tmp1, .add_src0_elem_size), ._, ._ }, |
| | 6459 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 6460 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 6461 | } }, |
| | 6462 | }, .{ |
| | 6463 | .required_features = .{ .@"64bit", .lzcnt, null, null }, |
| | 6464 | .dst_constraints = .{.{ .scalar_int = .word }}, |
| | 6465 | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .qword } }, .any }, |
| | 6466 | .patterns = &.{ |
| | 6467 | .{ .src = .{ .to_mem, .none } }, |
| | 6468 | }, |
| | 6469 | .extra_temps = .{ |
| | 6470 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 6471 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 6472 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 6473 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 6474 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 6475 | .unused, |
| | 6476 | }, |
| | 6477 | .dst_temps = .{.mem}, |
| | 6478 | .each = .{ .once = &.{ |
| | 6479 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 6480 | .{ ._, ._, .lea, .tmp1q, .mem(.src0), ._, ._ }, |
| | 6481 | .{ .@"0:", ._, .mov, .tmp2d, .sia(-16, .none, .add_src0_elem_size), ._, ._ }, |
| | 6482 | .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ }, |
| | 6483 | .{ .@"1:", ._, .@"and", .tmp3q, .leai(.qword, .tmp1, .tmp2), ._, ._ }, |
| | 6484 | .{ ._, ._, .lzcnt, .tmp4q, .tmp3q, ._, ._ }, |
| | 6485 | .{ ._, ._nc, .j, .@"1f", ._, ._, ._ }, |
| | 6486 | .{ ._, ._, .mov, .tmp3q, .si(-1), ._, ._ }, |
| | 6487 | .{ ._, ._, .sub, .tmp2d, .si(8), ._, ._ }, |
| | 6488 | .{ ._, ._nc, .j, .@"1b", ._, ._, ._ }, |
| | 6489 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 6490 | .{ .@"1:", ._, .neg, .tmp2d, ._, ._, ._ }, |
| | 6491 | .{ ._, ._, .lea, .tmp3d, .leasiad(.none, .tmp4, .@"8", .tmp2, .add_src0_bit_size, -64), ._, ._ }, |
| | 6492 | .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_2_len), .tmp3w, ._, ._ }, |
| | 6493 | .{ ._, ._, .lea, .tmp1q, .leaa(.none, .tmp1, .add_src0_elem_size), ._, ._ }, |
| | 6494 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 6495 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 6496 | } }, |
| | 6497 | }, .{ |
| | 6498 | .required_features = .{ .@"64bit", null, null, null }, |
| | 6499 | .dst_constraints = .{.{ .scalar_int = .word }}, |
| | 6500 | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .qword } }, .any }, |
| | 6501 | .patterns = &.{ |
| | 6502 | .{ .src = .{ .to_mem, .none } }, |
| | 6503 | }, |
| | 6504 | .extra_temps = .{ |
| | 6505 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 6506 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 6507 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 6508 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 6509 | .unused, |
| | 6510 | .unused, |
| | 6511 | }, |
| | 6512 | .dst_temps = .{.mem}, |
| | 6513 | .each = .{ .once = &.{ |
| | 6514 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 6515 | .{ ._, ._, .lea, .tmp1q, .mem(.src0), ._, ._ }, |
| | 6516 | .{ .@"0:", ._, .mov, .tmp2d, .sia(-16, .none, .add_src0_elem_size), ._, ._ }, |
| | 6517 | .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ }, |
| | 6518 | .{ .@"1:", ._, .@"and", .tmp3q, .leai(.qword, .tmp1, .tmp2), ._, ._ }, |
| | 6519 | .{ ._, ._r, .bs, .tmp3q, .tmp3q, ._, ._ }, |
| | 6520 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| | 6521 | .{ ._, ._, .mov, .tmp3q, .si(-1), ._, ._ }, |
| | 6522 | .{ ._, ._, .sub, .tmp2d, .si(8), ._, ._ }, |
| | 6523 | .{ ._, ._nc, .j, .@"1b", ._, ._, ._ }, |
| | 6524 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 6525 | .{ .@"1:", ._, .lea, .tmp3d, .leasiad(.none, .tmp3, .@"8", .tmp2, .sub_src0_bit_size, 1), ._, ._ }, |
| | 6526 | .{ ._, ._, .neg, .tmp3d, ._, ._, ._ }, |
| | 6527 | .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_2_len), .tmp3w, ._, ._ }, |
| | 6528 | .{ ._, ._, .lea, .tmp1q, .leaa(.none, .tmp1, .add_src0_elem_size), ._, ._ }, |
| | 6529 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 6530 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 6531 | } }, |
| | 6532 | }, .{ |
| | 6533 | .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null }, |
| | 6534 | .dst_constraints = .{.{ .scalar_int = .word }}, |
| | 6535 | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| | 6536 | .patterns = &.{ |
| | 6537 | .{ .src = .{ .to_mem, .none } }, |
| | 6538 | }, |
| | 6539 | .extra_temps = .{ |
| | 6540 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 6541 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 6542 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 6543 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 6544 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 6545 | .unused, |
| | 6546 | }, |
| | 6547 | .dst_temps = .{.mem}, |
| | 6548 | .each = .{ .once = &.{ |
| | 6549 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 6550 | .{ ._, ._, .lea, .tmp1q, .mem(.src0), ._, ._ }, |
| | 6551 | .{ .@"0:", ._, .mov, .tmp2d, .sia(-8, .none, .add_src0_elem_size), ._, ._ }, |
| | 6552 | .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ }, |
| | 6553 | .{ .@"1:", ._, .@"and", .tmp3q, .leai(.qword, .tmp1, .tmp2), ._, ._ }, |
| | 6554 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 6555 | .{ ._, ._, .lzcnt, .tmp4q, .tmp3q, ._, ._ }, |
| | 6556 | .{ ._, ._nc, .j, .@"1f", ._, ._, ._ }, |
| | 6557 | .{ ._, ._, .mov, .tmp3q, .si(-1), ._, ._ }, |
| | 6558 | .{ ._, ._, .sub, .tmp2d, .si(8), ._, ._ }, |
| | 6559 | .{ ._, ._nc, .j, .@"1b", ._, ._, ._ }, |
| | 6560 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 6561 | .{ .@"1:", ._, .neg, .tmp2d, ._, ._, ._ }, |
| | 6562 | .{ ._, ._, .lea, .tmp3d, .leasiad(.none, .tmp4, .@"8", .tmp2, .add_src0_bit_size, -64), ._, ._ }, |
| | 6563 | .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_2_len), .tmp3w, ._, ._ }, |
| | 6564 | .{ ._, ._, .lea, .tmp1q, .leaa(.none, .tmp1, .add_src0_elem_size), ._, ._ }, |
| | 6565 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 6566 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 6567 | } }, |
| | 6568 | }, .{ |
| | 6569 | .required_features = .{ .@"64bit", .lzcnt, null, null }, |
| | 6570 | .dst_constraints = .{.{ .scalar_int = .word }}, |
| | 6571 | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| | 6572 | .patterns = &.{ |
| | 6573 | .{ .src = .{ .to_mem, .none } }, |
| | 6574 | }, |
| | 6575 | .extra_temps = .{ |
| | 6576 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 6577 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 6578 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 6579 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 6580 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 6581 | .unused, |
| | 6582 | }, |
| | 6583 | .dst_temps = .{.mem}, |
| | 6584 | .each = .{ .once = &.{ |
| | 6585 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 6586 | .{ ._, ._, .lea, .tmp1q, .mem(.src0), ._, ._ }, |
| | 6587 | .{ .@"0:", ._, .mov, .tmp2d, .sia(-8, .none, .add_src0_elem_size), ._, ._ }, |
| | 6588 | .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ }, |
| | 6589 | .{ .@"1:", ._, .@"and", .tmp3q, .leai(.qword, .tmp1, .tmp2), ._, ._ }, |
| | 6590 | .{ ._, ._, .lzcnt, .tmp4q, .tmp3q, ._, ._ }, |
| | 6591 | .{ ._, ._nc, .j, .@"1f", ._, ._, ._ }, |
| | 6592 | .{ ._, ._, .mov, .tmp3q, .si(-1), ._, ._ }, |
| | 6593 | .{ ._, ._, .sub, .tmp2d, .si(8), ._, ._ }, |
| | 6594 | .{ ._, ._nc, .j, .@"1b", ._, ._, ._ }, |
| | 6595 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 6596 | .{ .@"1:", ._, .neg, .tmp2d, ._, ._, ._ }, |
| | 6597 | .{ ._, ._, .lea, .tmp3d, .leasiad(.none, .tmp4, .@"8", .tmp2, .add_src0_bit_size, -64), ._, ._ }, |
| | 6598 | .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_2_len), .tmp3w, ._, ._ }, |
| | 6599 | .{ ._, ._, .lea, .tmp1q, .leaa(.none, .tmp1, .add_src0_elem_size), ._, ._ }, |
| | 6600 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 6601 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 6602 | } }, |
| | 6603 | }, .{ |
| | 6604 | .required_features = .{ .@"64bit", null, null, null }, |
| | 6605 | .dst_constraints = .{.{ .scalar_int = .word }}, |
| | 6606 | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| | 6607 | .patterns = &.{ |
| | 6608 | .{ .src = .{ .to_mem, .none } }, |
| | 6609 | }, |
| | 6610 | .extra_temps = .{ |
| | 6611 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 6612 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 6613 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 6614 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 6615 | .unused, |
| | 6616 | .unused, |
| | 6617 | }, |
| | 6618 | .dst_temps = .{.mem}, |
| | 6619 | .each = .{ .once = &.{ |
| | 6620 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| | 6621 | .{ ._, ._, .lea, .tmp1q, .mem(.src0), ._, ._ }, |
| | 6622 | .{ .@"0:", ._, .mov, .tmp2d, .sia(-8, .none, .add_src0_elem_size), ._, ._ }, |
| | 6623 | .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ }, |
| | 6624 | .{ .@"1:", ._, .@"and", .tmp3q, .leai(.qword, .tmp1, .tmp2), ._, ._ }, |
| | 6625 | .{ ._, ._r, .bs, .tmp3q, .tmp3q, ._, ._ }, |
| | 6626 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| | 6627 | .{ ._, ._, .mov, .tmp3q, .si(-1), ._, ._ }, |
| | 6628 | .{ ._, ._, .sub, .tmp2d, .si(8), ._, ._ }, |
| | 6629 | .{ ._, ._nc, .j, .@"1b", ._, ._, ._ }, |
| | 6630 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 6631 | .{ .@"1:", ._, .lea, .tmp3d, .leasiad(.none, .tmp3, .@"8", .tmp2, .sub_src0_bit_size, 1), ._, ._ }, |
| | 6632 | .{ ._, ._, .neg, .tmp3d, ._, ._, ._ }, |
| | 6633 | .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_2_len), .tmp3w, ._, ._ }, |
| | 6634 | .{ ._, ._, .lea, .tmp1q, .leaa(.none, .tmp1, .add_src0_elem_size), ._, ._ }, |
| | 6635 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 6636 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 6637 | } }, |
| | 6638 | } }) catch |err| switch (err) { |
| | 6639 | error.SelectFailed => return cg.fail("failed to select {s} {} {}", .{ |
| | 6640 | @tagName(air_tag), |
| | 6641 | cg.typeOf(ty_op.operand).fmt(pt), |
| | 6642 | ops[0].tracking(cg), |
| | 6643 | }), |
| | 6644 | else => |e| return e, |
| | 6645 | }; |
| | 6646 | if (ops[0].index != res[0].index) try ops[0].die(cg); |
| | 6647 | try res[0].moveTo(inst, cg); |
| | 6648 | }, |
| | 6649 | |
| | 6650 | .cmp_vector, .cmp_vector_optimized => |air_tag| if (use_old) try cg.airCmpVector(inst) else fallback: { |
| | 6651 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| | 6652 | const extra = cg.air.extraData(Air.VectorCmp, ty_pl.payload).data; |
| | 6653 | switch (extra.compareOperator()) { |
| | 6654 | .eq, .neq => {}, |
| | 6655 | else => break :fallback try cg.airCmpVector(inst), |
| | 6656 | } |
| | 6657 | var ops = try cg.tempsFromOperands(inst, .{ extra.lhs, extra.rhs }); |
| | 6658 | var res: [1]Temp = undefined; |
| | 6659 | switch (extra.compareOperator()) { |
| | 6660 | .lt => unreachable, |
| | 6661 | .lte => unreachable, |
| | 6662 | .eq, .neq => |cmp_op| cg.select(&res, &.{cg.typeOfIndex(inst)}, &ops, switch (@as(Condition, switch (cmp_op) { |
| | 6663 | else => unreachable, |
| | 6664 | .eq => .e, |
| | 6665 | .neq => .ne, |
| | 6666 | })) { |
| | 6667 | else => unreachable, |
| | 6668 | inline .e, .ne => |cc| comptime &.{ .{ |
| | 6669 | .required_features = .{ .avx2, null, null, null }, |
| | 6670 | .src_constraints = .{ .{ .scalar_int = .byte }, .{ .scalar_int = .byte } }, |
| | 6671 | .patterns = &.{ |
| | 6672 | .{ .src = .{ .to_ymm, .mem } }, |
| | 6673 | .{ .src = .{ .mem, .to_ymm }, .commute = .{ 0, 1 } }, |
| | 6674 | .{ .src = .{ .to_ymm, .to_ymm } }, |
| | 6675 | }, |
| | 6676 | .dst_temps = .{.{ .rc_mask = .{ .rc = .sse, .info = .{ |
| | 6677 | .kind = .all, |
| | 6678 | .inverted = switch (cc) { |
| | 6679 | else => unreachable, |
| | 6680 | .e => false, |
| | 6681 | .ne => true, |
| | 6682 | }, |
| | 6683 | .scalar = .byte, |
| | 6684 | } } }}, |
| | 6685 | .each = .{ .once = &.{ |
| | 6686 | .{ ._, .vp_b, .cmpeq, .dst0y, .src0y, .src1y, ._ }, |
| | 6687 | } }, |
| | 6688 | }, .{ |
| | 6689 | .required_features = .{ .avx2, null, null, null }, |
| | 6690 | .src_constraints = .{ .{ .scalar_int = .word }, .{ .scalar_int = .word } }, |
| | 6691 | .patterns = &.{ |
| | 6692 | .{ .src = .{ .to_ymm, .mem } }, |
| | 6693 | .{ .src = .{ .mem, .to_ymm }, .commute = .{ 0, 1 } }, |
| | 6694 | .{ .src = .{ .to_ymm, .to_ymm } }, |
| | 6695 | }, |
| | 6696 | .dst_temps = .{.{ .rc_mask = .{ .rc = .sse, .info = .{ |
| | 6697 | .kind = .all, |
| | 6698 | .inverted = switch (cc) { |
| | 6699 | else => unreachable, |
| | 6700 | .e => false, |
| | 6701 | .ne => true, |
| | 6702 | }, |
| | 6703 | .scalar = .word, |
| | 6704 | } } }}, |
| | 6705 | .each = .{ .once = &.{ |
| | 6706 | .{ ._, .vp_w, .cmpeq, .dst0y, .src0y, .src1y, ._ }, |
| | 6707 | } }, |
| | 6708 | }, .{ |
| | 6709 | .required_features = .{ .avx2, null, null, null }, |
| | 6710 | .src_constraints = .{ .{ .scalar_int = .dword }, .{ .scalar_int = .dword } }, |
| | 6711 | .patterns = &.{ |
| | 6712 | .{ .src = .{ .to_ymm, .mem } }, |
| | 6713 | .{ .src = .{ .mem, .to_ymm }, .commute = .{ 0, 1 } }, |
| | 6714 | .{ .src = .{ .to_ymm, .to_ymm } }, |
| | 6715 | }, |
| | 6716 | .dst_temps = .{.{ .rc_mask = .{ .rc = .sse, .info = .{ |
| | 6717 | .kind = .all, |
| | 6718 | .inverted = switch (cc) { |
| | 6719 | else => unreachable, |
| | 6720 | .e => false, |
| | 6721 | .ne => true, |
| | 6722 | }, |
| | 6723 | .scalar = .dword, |
| | 6724 | } } }}, |
| | 6725 | .each = .{ .once = &.{ |
| | 6726 | .{ ._, .vp_d, .cmpeq, .dst0y, .src0y, .src1y, ._ }, |
| | 6727 | } }, |
| | 6728 | }, .{ |
| | 6729 | .required_features = .{ .avx2, null, null, null }, |
| | 6730 | .src_constraints = .{ .{ .scalar_int = .qword }, .{ .scalar_int = .qword } }, |
| | 6731 | .patterns = &.{ |
| | 6732 | .{ .src = .{ .to_ymm, .mem } }, |
| | 6733 | .{ .src = .{ .mem, .to_ymm }, .commute = .{ 0, 1 } }, |
| | 6734 | .{ .src = .{ .to_ymm, .to_ymm } }, |
| 2968 | }, | 6735 | }, |
| 2969 | .dst_temps = .{.{ .rc_mask = .{ .rc = .sse, .info = .{ | 6736 | .dst_temps = .{.{ .rc_mask = .{ .rc = .sse, .info = .{ |
| 2970 | .kind = .all, | 6737 | .kind = .all, |
| ... | @@ -2979,12 +6746,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2979,12 +6746,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2979 | .{ ._, .vp_q, .cmpeq, .dst0y, .src0y, .src1y, ._ }, | 6746 | .{ ._, .vp_q, .cmpeq, .dst0y, .src0y, .src1y, ._ }, |
| 2980 | } }, | 6747 | } }, |
| 2981 | }, .{ | 6748 | }, .{ |
| 2982 | .required_features = .{ .avx, null }, | 6749 | .required_features = .{ .avx, null, null, null }, |
| 2983 | .src_constraints = .{ .{ .int = .byte }, .{ .int = .byte } }, | 6750 | .src_constraints = .{ .{ .scalar_int = .byte }, .{ .scalar_int = .byte } }, |
| 2984 | .patterns = &.{ | 6751 | .patterns = &.{ |
| 2985 | .{ .src = .{ .xmm, .mem } }, | 6752 | .{ .src = .{ .to_xmm, .mem } }, |
| 2986 | .{ .src = .{ .mem, .xmm }, .commute = .{ 0, 1 } }, | 6753 | .{ .src = .{ .mem, .to_xmm }, .commute = .{ 0, 1 } }, |
| 2987 | .{ .src = .{ .xmm, .xmm } }, | 6754 | .{ .src = .{ .to_xmm, .to_xmm } }, |
| 2988 | }, | 6755 | }, |
| 2989 | .dst_temps = .{.{ .rc_mask = .{ .rc = .sse, .info = .{ | 6756 | .dst_temps = .{.{ .rc_mask = .{ .rc = .sse, .info = .{ |
| 2990 | .kind = .all, | 6757 | .kind = .all, |
| ... | @@ -2999,12 +6766,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2999,12 +6766,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2999 | .{ ._, .vp_b, .cmpeq, .dst0x, .src0x, .src1x, ._ }, | 6766 | .{ ._, .vp_b, .cmpeq, .dst0x, .src0x, .src1x, ._ }, |
| 3000 | } }, | 6767 | } }, |
| 3001 | }, .{ | 6768 | }, .{ |
| 3002 | .required_features = .{ .avx, null }, | 6769 | .required_features = .{ .avx, null, null, null }, |
| 3003 | .src_constraints = .{ .{ .int = .word }, .{ .int = .word } }, | 6770 | .src_constraints = .{ .{ .scalar_int = .word }, .{ .scalar_int = .word } }, |
| 3004 | .patterns = &.{ | 6771 | .patterns = &.{ |
| 3005 | .{ .src = .{ .xmm, .mem } }, | 6772 | .{ .src = .{ .to_xmm, .mem } }, |
| 3006 | .{ .src = .{ .mem, .xmm }, .commute = .{ 0, 1 } }, | 6773 | .{ .src = .{ .mem, .to_xmm }, .commute = .{ 0, 1 } }, |
| 3007 | .{ .src = .{ .xmm, .xmm } }, | 6774 | .{ .src = .{ .to_xmm, .to_xmm } }, |
| 3008 | }, | 6775 | }, |
| 3009 | .dst_temps = .{.{ .rc_mask = .{ .rc = .sse, .info = .{ | 6776 | .dst_temps = .{.{ .rc_mask = .{ .rc = .sse, .info = .{ |
| 3010 | .kind = .all, | 6777 | .kind = .all, |
| ... | @@ -3019,12 +6786,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3019,12 +6786,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3019 | .{ ._, .vp_w, .cmpeq, .dst0x, .src0x, .src1x, ._ }, | 6786 | .{ ._, .vp_w, .cmpeq, .dst0x, .src0x, .src1x, ._ }, |
| 3020 | } }, | 6787 | } }, |
| 3021 | }, .{ | 6788 | }, .{ |
| 3022 | .required_features = .{ .avx, null }, | 6789 | .required_features = .{ .avx, null, null, null }, |
| 3023 | .src_constraints = .{ .{ .int = .dword }, .{ .int = .dword } }, | 6790 | .src_constraints = .{ .{ .scalar_int = .dword }, .{ .scalar_int = .dword } }, |
| 3024 | .patterns = &.{ | 6791 | .patterns = &.{ |
| 3025 | .{ .src = .{ .xmm, .mem } }, | 6792 | .{ .src = .{ .to_xmm, .mem } }, |
| 3026 | .{ .src = .{ .mem, .xmm }, .commute = .{ 0, 1 } }, | 6793 | .{ .src = .{ .mem, .to_xmm }, .commute = .{ 0, 1 } }, |
| 3027 | .{ .src = .{ .xmm, .xmm } }, | 6794 | .{ .src = .{ .to_xmm, .to_xmm } }, |
| 3028 | }, | 6795 | }, |
| 3029 | .dst_temps = .{.{ .rc_mask = .{ .rc = .sse, .info = .{ | 6796 | .dst_temps = .{.{ .rc_mask = .{ .rc = .sse, .info = .{ |
| 3030 | .kind = .all, | 6797 | .kind = .all, |
| ... | @@ -3039,12 +6806,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3039,12 +6806,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3039 | .{ ._, .vp_d, .cmpeq, .dst0x, .src0x, .src1x, ._ }, | 6806 | .{ ._, .vp_d, .cmpeq, .dst0x, .src0x, .src1x, ._ }, |
| 3040 | } }, | 6807 | } }, |
| 3041 | }, .{ | 6808 | }, .{ |
| 3042 | .required_features = .{ .avx, null }, | 6809 | .required_features = .{ .avx, null, null, null }, |
| 3043 | .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword } }, | 6810 | .src_constraints = .{ .{ .scalar_int = .qword }, .{ .scalar_int = .qword } }, |
| 3044 | .patterns = &.{ | 6811 | .patterns = &.{ |
| 3045 | .{ .src = .{ .xmm, .mem } }, | 6812 | .{ .src = .{ .to_xmm, .mem } }, |
| 3046 | .{ .src = .{ .mem, .xmm }, .commute = .{ 0, 1 } }, | 6813 | .{ .src = .{ .mem, .to_xmm }, .commute = .{ 0, 1 } }, |
| 3047 | .{ .src = .{ .xmm, .xmm } }, | 6814 | .{ .src = .{ .to_xmm, .to_xmm } }, |
| 3048 | }, | 6815 | }, |
| 3049 | .dst_temps = .{.{ .rc_mask = .{ .rc = .sse, .info = .{ | 6816 | .dst_temps = .{.{ .rc_mask = .{ .rc = .sse, .info = .{ |
| 3050 | .kind = .all, | 6817 | .kind = .all, |
| ... | @@ -3059,12 +6826,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3059,12 +6826,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3059 | .{ ._, .vp_q, .cmpeq, .dst0x, .src0x, .src1x, ._ }, | 6826 | .{ ._, .vp_q, .cmpeq, .dst0x, .src0x, .src1x, ._ }, |
| 3060 | } }, | 6827 | } }, |
| 3061 | }, .{ | 6828 | }, .{ |
| 3062 | .required_features = .{ .sse2, null }, | 6829 | .required_features = .{ .sse2, null, null, null }, |
| 3063 | .src_constraints = .{ .{ .int = .byte }, .{ .int = .byte } }, | 6830 | .src_constraints = .{ .{ .scalar_int = .byte }, .{ .scalar_int = .byte } }, |
| 3064 | .patterns = &.{ | 6831 | .patterns = &.{ |
| 3065 | .{ .src = .{ .mut_xmm, .mem } }, | 6832 | .{ .src = .{ .to_mut_xmm, .mem } }, |
| 3066 | .{ .src = .{ .mem, .mut_xmm }, .commute = .{ 0, 1 } }, | 6833 | .{ .src = .{ .mem, .to_mut_xmm }, .commute = .{ 0, 1 } }, |
| 3067 | .{ .src = .{ .mut_xmm, .xmm } }, | 6834 | .{ .src = .{ .to_mut_xmm, .to_xmm } }, |
| 3068 | }, | 6835 | }, |
| 3069 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ | 6836 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 3070 | .kind = .all, | 6837 | .kind = .all, |
| ... | @@ -3079,12 +6846,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3079,12 +6846,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3079 | .{ ._, .p_b, .cmpeq, .dst0x, .src1x, ._, ._ }, | 6846 | .{ ._, .p_b, .cmpeq, .dst0x, .src1x, ._, ._ }, |
| 3080 | } }, | 6847 | } }, |
| 3081 | }, .{ | 6848 | }, .{ |
| 3082 | .required_features = .{ .sse2, null }, | 6849 | .required_features = .{ .sse2, null, null, null }, |
| 3083 | .src_constraints = .{ .{ .int = .word }, .{ .int = .word } }, | 6850 | .src_constraints = .{ .{ .scalar_int = .word }, .{ .scalar_int = .word } }, |
| 3084 | .patterns = &.{ | 6851 | .patterns = &.{ |
| 3085 | .{ .src = .{ .mut_xmm, .mem } }, | 6852 | .{ .src = .{ .to_mut_xmm, .mem } }, |
| 3086 | .{ .src = .{ .mem, .mut_xmm }, .commute = .{ 0, 1 } }, | 6853 | .{ .src = .{ .mem, .to_mut_xmm }, .commute = .{ 0, 1 } }, |
| 3087 | .{ .src = .{ .mut_xmm, .xmm } }, | 6854 | .{ .src = .{ .to_mut_xmm, .to_xmm } }, |
| 3088 | }, | 6855 | }, |
| 3089 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ | 6856 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 3090 | .kind = .all, | 6857 | .kind = .all, |
| ... | @@ -3099,12 +6866,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3099,12 +6866,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3099 | .{ ._, .p_w, .cmpeq, .dst0x, .src1x, ._, ._ }, | 6866 | .{ ._, .p_w, .cmpeq, .dst0x, .src1x, ._, ._ }, |
| 3100 | } }, | 6867 | } }, |
| 3101 | }, .{ | 6868 | }, .{ |
| 3102 | .required_features = .{ .sse2, null }, | 6869 | .required_features = .{ .sse2, null, null, null }, |
| 3103 | .src_constraints = .{ .{ .int = .dword }, .{ .int = .dword } }, | 6870 | .src_constraints = .{ .{ .scalar_int = .dword }, .{ .scalar_int = .dword } }, |
| 3104 | .patterns = &.{ | 6871 | .patterns = &.{ |
| 3105 | .{ .src = .{ .mut_xmm, .mem } }, | 6872 | .{ .src = .{ .to_mut_xmm, .mem } }, |
| 3106 | .{ .src = .{ .mem, .mut_xmm }, .commute = .{ 0, 1 } }, | 6873 | .{ .src = .{ .mem, .to_mut_xmm }, .commute = .{ 0, 1 } }, |
| 3107 | .{ .src = .{ .mut_xmm, .xmm } }, | 6874 | .{ .src = .{ .to_mut_xmm, .to_xmm } }, |
| 3108 | }, | 6875 | }, |
| 3109 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ | 6876 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 3110 | .kind = .all, | 6877 | .kind = .all, |
| ... | @@ -3119,12 +6886,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3119,12 +6886,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3119 | .{ ._, .p_d, .cmpeq, .dst0x, .src1x, ._, ._ }, | 6886 | .{ ._, .p_d, .cmpeq, .dst0x, .src1x, ._, ._ }, |
| 3120 | } }, | 6887 | } }, |
| 3121 | }, .{ | 6888 | }, .{ |
| 3122 | .required_features = .{ .sse4_1, null }, | 6889 | .required_features = .{ .sse4_1, null, null, null }, |
| 3123 | .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword } }, | 6890 | .src_constraints = .{ .{ .scalar_int = .qword }, .{ .scalar_int = .qword } }, |
| 3124 | .patterns = &.{ | 6891 | .patterns = &.{ |
| 3125 | .{ .src = .{ .mut_xmm, .mem } }, | 6892 | .{ .src = .{ .to_mut_xmm, .mem } }, |
| 3126 | .{ .src = .{ .mem, .mut_xmm }, .commute = .{ 0, 1 } }, | 6893 | .{ .src = .{ .mem, .to_mut_xmm }, .commute = .{ 0, 1 } }, |
| 3127 | .{ .src = .{ .mut_xmm, .xmm } }, | 6894 | .{ .src = .{ .to_mut_xmm, .to_xmm } }, |
| 3128 | }, | 6895 | }, |
| 3129 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ | 6896 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 3130 | .kind = .all, | 6897 | .kind = .all, |
| ... | @@ -3139,12 +6906,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3139,12 +6906,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3139 | .{ ._, .p_q, .cmpeq, .dst0x, .src1x, ._, ._ }, | 6906 | .{ ._, .p_q, .cmpeq, .dst0x, .src1x, ._, ._ }, |
| 3140 | } }, | 6907 | } }, |
| 3141 | }, .{ | 6908 | }, .{ |
| 3142 | .required_features = .{ .mmx, null }, | 6909 | .required_features = .{ .mmx, null, null, null }, |
| 3143 | .src_constraints = .{ .{ .int = .byte }, .{ .int = .byte } }, | 6910 | .src_constraints = .{ .{ .scalar_int = .byte }, .{ .scalar_int = .byte } }, |
| 3144 | .patterns = &.{ | 6911 | .patterns = &.{ |
| 3145 | .{ .src = .{ .mut_mm, .mem } }, | 6912 | .{ .src = .{ .to_mut_mm, .mem } }, |
| 3146 | .{ .src = .{ .mem, .mut_mm }, .commute = .{ 0, 1 } }, | 6913 | .{ .src = .{ .mem, .to_mut_mm }, .commute = .{ 0, 1 } }, |
| 3147 | .{ .src = .{ .mut_mm, .mm } }, | 6914 | .{ .src = .{ .to_mut_mm, .to_mm } }, |
| 3148 | }, | 6915 | }, |
| 3149 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ | 6916 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 3150 | .kind = .all, | 6917 | .kind = .all, |
| ... | @@ -3159,12 +6926,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3159,12 +6926,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3159 | .{ ._, .p_b, .cmpeq, .dst0q, .src1q, ._, ._ }, | 6926 | .{ ._, .p_b, .cmpeq, .dst0q, .src1q, ._, ._ }, |
| 3160 | } }, | 6927 | } }, |
| 3161 | }, .{ | 6928 | }, .{ |
| 3162 | .required_features = .{ .mmx, null }, | 6929 | .required_features = .{ .mmx, null, null, null }, |
| 3163 | .src_constraints = .{ .{ .int = .word }, .{ .int = .word } }, | 6930 | .src_constraints = .{ .{ .scalar_int = .word }, .{ .scalar_int = .word } }, |
| 3164 | .patterns = &.{ | 6931 | .patterns = &.{ |
| 3165 | .{ .src = .{ .mut_mm, .mem } }, | 6932 | .{ .src = .{ .to_mut_mm, .mem } }, |
| 3166 | .{ .src = .{ .mem, .mut_mm }, .commute = .{ 0, 1 } }, | 6933 | .{ .src = .{ .mem, .to_mut_mm }, .commute = .{ 0, 1 } }, |
| 3167 | .{ .src = .{ .mut_mm, .mm } }, | 6934 | .{ .src = .{ .to_mut_mm, .to_mm } }, |
| 3168 | }, | 6935 | }, |
| 3169 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ | 6936 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 3170 | .kind = .all, | 6937 | .kind = .all, |
| ... | @@ -3179,12 +6946,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3179,12 +6946,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3179 | .{ ._, .p_w, .cmpeq, .dst0q, .src1q, ._, ._ }, | 6946 | .{ ._, .p_w, .cmpeq, .dst0q, .src1q, ._, ._ }, |
| 3180 | } }, | 6947 | } }, |
| 3181 | }, .{ | 6948 | }, .{ |
| 3182 | .required_features = .{ .mmx, null }, | 6949 | .required_features = .{ .mmx, null, null, null }, |
| 3183 | .src_constraints = .{ .{ .int = .dword }, .{ .int = .dword } }, | 6950 | .src_constraints = .{ .{ .scalar_int = .dword }, .{ .scalar_int = .dword } }, |
| 3184 | .patterns = &.{ | 6951 | .patterns = &.{ |
| 3185 | .{ .src = .{ .mut_mm, .mem } }, | 6952 | .{ .src = .{ .to_mut_mm, .mem } }, |
| 3186 | .{ .src = .{ .mem, .mut_mm }, .commute = .{ 0, 1 } }, | 6953 | .{ .src = .{ .mem, .to_mut_mm }, .commute = .{ 0, 1 } }, |
| 3187 | .{ .src = .{ .mut_mm, .mm } }, | 6954 | .{ .src = .{ .to_mut_mm, .to_mm } }, |
| 3188 | }, | 6955 | }, |
| 3189 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ | 6956 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 3190 | .kind = .all, | 6957 | .kind = .all, |
| ... | @@ -3203,550 +6970,182 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3203,550 +6970,182 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3203 | .patterns = &.{ | 6970 | .patterns = &.{ |
| 3204 | .{ .src = .{ .mut_mem, .imm8 } }, | 6971 | .{ .src = .{ .mut_mem, .imm8 } }, |
| 3205 | .{ .src = .{ .imm8, .mut_mem }, .commute = .{ 0, 1 } }, | 6972 | .{ .src = .{ .imm8, .mut_mem }, .commute = .{ 0, 1 } }, |
| 3206 | .{ .src = .{ .mut_gpr, .imm8 } }, | 6973 | .{ .src = .{ .to_mut_gpr, .imm8 } }, |
| 3207 | .{ .src = .{ .imm8, .mut_gpr }, .commute = .{ 0, 1 } }, | 6974 | .{ .src = .{ .imm8, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 3208 | .{ .src = .{ .mut_mem, .gpr } }, | 6975 | .{ .src = .{ .mut_mem, .to_gpr } }, |
| 3209 | .{ .src = .{ .gpr, .mut_mem }, .commute = .{ 0, 1 } }, | 6976 | .{ .src = .{ .to_gpr, .mut_mem }, .commute = .{ 0, 1 } }, |
| 3210 | .{ .src = .{ .mut_gpr, .mem } }, | 6977 | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 3211 | .{ .src = .{ .mem, .mut_gpr }, .commute = .{ 0, 1 } }, | 6978 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 3212 | .{ .src = .{ .mut_gpr, .gpr } }, | 6979 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 3213 | }, | | |
| 3214 | .clobbers = .{ .eflags = true }, | | |
| 3215 | .dst_temps = .{.{ .ref = .src0 }}, | | |
| 3216 | .each = .{ .once = switch (cc) { | | |
| 3217 | else => unreachable, | | |
| 3218 | .e => &.{ | | |
| 3219 | .{ ._, ._, .xor, .dst0b, .src1b, ._, ._ }, | | |
| 3220 | .{ ._, ._, .not, .dst0b, ._, ._, ._ }, | | |
| 3221 | }, | | |
| 3222 | .ne => &.{ | | |
| 3223 | .{ ._, ._, .xor, .dst0b, .src1b, ._, ._ }, | | |
| 3224 | }, | | |
| 3225 | } }, | | |
| 3226 | }, .{ | | |
| 3227 | .src_constraints = .{ .{ .bool_vec = .word }, .{ .bool_vec = .word } }, | | |
| 3228 | .patterns = &.{ | | |
| 3229 | .{ .src = .{ .mut_mem, .imm16 } }, | | |
| 3230 | .{ .src = .{ .imm16, .mut_mem }, .commute = .{ 0, 1 } }, | | |
| 3231 | .{ .src = .{ .mut_gpr, .imm16 } }, | | |
| 3232 | .{ .src = .{ .imm16, .mut_gpr }, .commute = .{ 0, 1 } }, | | |
| 3233 | .{ .src = .{ .mut_mem, .gpr } }, | | |
| 3234 | .{ .src = .{ .gpr, .mut_mem }, .commute = .{ 0, 1 } }, | | |
| 3235 | .{ .src = .{ .mut_gpr, .mem } }, | | |
| 3236 | .{ .src = .{ .mem, .mut_gpr }, .commute = .{ 0, 1 } }, | | |
| 3237 | .{ .src = .{ .mut_gpr, .gpr } }, | | |
| 3238 | }, | | |
| 3239 | .clobbers = .{ .eflags = true }, | | |
| 3240 | .dst_temps = .{.{ .ref = .src0 }}, | | |
| 3241 | .each = .{ .once = switch (cc) { | | |
| 3242 | else => unreachable, | | |
| 3243 | .e => &.{ | | |
| 3244 | .{ ._, ._, .xor, .dst0w, .src1w, ._, ._ }, | | |
| 3245 | .{ ._, ._, .not, .dst0w, ._, ._, ._ }, | | |
| 3246 | }, | | |
| 3247 | .ne => &.{ | | |
| 3248 | .{ ._, ._, .xor, .dst0w, .src1w, ._, ._ }, | | |
| 3249 | }, | | |
| 3250 | } }, | | |
| 3251 | }, .{ | | |
| 3252 | .src_constraints = .{ .{ .bool_vec = .dword }, .{ .bool_vec = .dword } }, | | |
| 3253 | .patterns = &.{ | | |
| 3254 | .{ .src = .{ .mut_mem, .imm32 } }, | | |
| 3255 | .{ .src = .{ .imm32, .mut_mem }, .commute = .{ 0, 1 } }, | | |
| 3256 | .{ .src = .{ .mut_gpr, .imm32 } }, | | |
| 3257 | .{ .src = .{ .imm32, .mut_gpr }, .commute = .{ 0, 1 } }, | | |
| 3258 | .{ .src = .{ .mut_mem, .gpr } }, | | |
| 3259 | .{ .src = .{ .gpr, .mut_mem }, .commute = .{ 0, 1 } }, | | |
| 3260 | .{ .src = .{ .mut_gpr, .mem } }, | | |
| 3261 | .{ .src = .{ .mem, .mut_gpr }, .commute = .{ 0, 1 } }, | | |
| 3262 | .{ .src = .{ .mut_gpr, .gpr } }, | | |
| 3263 | }, | | |
| 3264 | .clobbers = .{ .eflags = true }, | | |
| 3265 | .dst_temps = .{.{ .ref = .src0 }}, | | |
| 3266 | .each = .{ .once = switch (cc) { | | |
| 3267 | else => unreachable, | | |
| 3268 | .e => &.{ | | |
| 3269 | .{ ._, ._, .xor, .dst0d, .src1d, ._, ._ }, | | |
| 3270 | .{ ._, ._, .not, .dst0d, ._, ._, ._ }, | | |
| 3271 | }, | | |
| 3272 | .ne => &.{ | | |
| 3273 | .{ ._, ._, .xor, .dst0d, .src1d, ._, ._ }, | | |
| 3274 | }, | | |
| 3275 | } }, | | |
| 3276 | }, .{ | | |
| 3277 | .required_features = .{ .@"64bit", null }, | | |
| 3278 | .src_constraints = .{ .{ .bool_vec = .qword }, .{ .bool_vec = .qword } }, | | |
| 3279 | .patterns = &.{ | | |
| 3280 | .{ .src = .{ .mut_mem, .simm32 } }, | | |
| 3281 | .{ .src = .{ .simm32, .mut_mem }, .commute = .{ 0, 1 } }, | | |
| 3282 | .{ .src = .{ .mut_gpr, .simm32 } }, | | |
| 3283 | .{ .src = .{ .simm32, .mut_gpr }, .commute = .{ 0, 1 } }, | | |
| 3284 | .{ .src = .{ .mut_mem, .gpr } }, | | |
| 3285 | .{ .src = .{ .gpr, .mut_mem }, .commute = .{ 0, 1 } }, | | |
| 3286 | .{ .src = .{ .mut_gpr, .mem } }, | | |
| 3287 | .{ .src = .{ .mem, .mut_gpr }, .commute = .{ 0, 1 } }, | | |
| 3288 | .{ .src = .{ .mut_gpr, .gpr } }, | | |
| 3289 | }, | 6980 | }, |
| 3290 | .clobbers = .{ .eflags = true }, | | |
| 3291 | .dst_temps = .{.{ .ref = .src0 }}, | 6981 | .dst_temps = .{.{ .ref = .src0 }}, |
| 3292 | .each = .{ .once = switch (cc) { | | |
| 3293 | else => unreachable, | | |
| 3294 | .e => &.{ | | |
| 3295 | .{ ._, ._, .xor, .dst0q, .src1q, ._, ._ }, | | |
| 3296 | .{ ._, ._, .not, .dst0q, ._, ._, ._ }, | | |
| 3297 | }, | | |
| 3298 | .ne => &.{ | | |
| 3299 | .{ ._, ._, .xor, .dst0q, .src1q, ._, ._ }, | | |
| 3300 | }, | | |
| 3301 | } }, | | |
| 3302 | }, .{ | | |
| 3303 | .src_constraints = .{ .any_bool_vec, .any_bool_vec }, | | |
| 3304 | .patterns = &.{ | | |
| 3305 | .{ .src = .{ .to_mem, .to_mem } }, | | |
| 3306 | }, | | |
| 3307 | .clobbers = .{ .eflags = true }, | 6982 | .clobbers = .{ .eflags = true }, |
| 3308 | .extra_temps = .{ | 6983 | .each = .{ .once = switch (cc) { |
| 3309 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 6984 | else => unreachable, |
| 3310 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 6985 | .e => &.{ |
| 3311 | .unused, | 6986 | .{ ._, ._, .xor, .dst0b, .src1b, ._, ._ }, |
| 3312 | .unused, | 6987 | .{ ._, ._, .not, .dst0b, ._, ._, ._ }, |
| 3313 | .unused, | 6988 | }, |
| 3314 | .unused, | 6989 | .ne => &.{ |
| 3315 | }, | 6990 | .{ ._, ._, .xor, .dst0b, .src1b, ._, ._ }, |
| 3316 | .dst_temps = .{.mem}, | | |
| 3317 | .each = .{ .once = switch (cc) { | | |
| 3318 | else => unreachable, | | |
| 3319 | .e => &.{ | | |
| 3320 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | | |
| 3321 | .{ .@"0:", ._, .mov, .tmp1p, .memia(.src0p, .tmp0, .add_size), ._, ._ }, | | |
| 3322 | .{ ._, ._, .xor, .tmp1p, .memia(.src1p, .tmp0, .add_size), ._, ._ }, | | |
| 3323 | .{ ._, ._, .not, .tmp1p, ._, ._, ._ }, | | |
| 3324 | .{ ._, ._, .mov, .memia(.dst0p, .tmp0, .add_size), .tmp1p, ._, ._ }, | | |
| 3325 | .{ ._, ._, .add, .tmp0p, .a(.tmp1, .add_size), ._, ._ }, | | |
| 3326 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 3327 | }, | | |
| 3328 | .ne => &.{ | | |
| 3329 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | | |
| 3330 | .{ .@"0:", ._, .mov, .tmp1p, .memia(.src0p, .tmp0, .add_size), ._, ._ }, | | |
| 3331 | .{ ._, ._, .xor, .tmp1p, .memia(.src1p, .tmp0, .add_size), ._, ._ }, | | |
| 3332 | .{ ._, ._, .mov, .memia(.dst0p, .tmp0, .add_size), .tmp1p, ._, ._ }, | | |
| 3333 | .{ ._, ._, .add, .tmp0p, .a(.tmp1, .add_size), ._, ._ }, | | |
| 3334 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 3335 | }, | | |
| 3336 | } }, | | |
| 3337 | }, .{ | | |
| 3338 | .required_features = .{ .avx2, null }, | | |
| 3339 | .src_constraints = .{ .{ .int = .byte }, .{ .int = .byte } }, | | |
| 3340 | .patterns = &.{ | | |
| 3341 | .{ .src = .{ .to_mem, .to_mem } }, | | |
| 3342 | }, | | |
| 3343 | .extra_temps = .{ | | |
| 3344 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | | |
| 3345 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | | |
| 3346 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | | |
| 3347 | .{ .kind = .{ .rc = .sse } }, | | |
| 3348 | .unused, | | |
| 3349 | .unused, | | |
| 3350 | }, | | |
| 3351 | .dst_temps = .{.mem}, | | |
| 3352 | .each = .{ .once = switch (cc) { | | |
| 3353 | else => unreachable, | | |
| 3354 | .e => &.{ | | |
| 3355 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | | |
| 3356 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | | |
| 3357 | .{ .@"0:", .v_dqu, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, | | |
| 3358 | .{ ._, .vp_b, .cmpeq, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_size), ._ }, | | |
| 3359 | .{ ._, .vp_b, .movmsk, .tmp2d, .tmp3y, ._, ._ }, | | |
| 3360 | .{ ._, ._, .mov, .memi(.dst0d, .tmp1), .tmp2d, ._, ._ }, | | |
| 3361 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 4), ._, ._ }, | | |
| 3362 | .{ ._, ._, .add, .tmp0p, .i(32), ._, ._ }, | | |
| 3363 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 3364 | }, | | |
| 3365 | .ne => &.{ | | |
| 3366 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | | |
| 3367 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | | |
| 3368 | .{ .@"0:", .v_dqu, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, | | |
| 3369 | .{ ._, .vp_b, .cmpeq, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_size), ._ }, | | |
| 3370 | .{ ._, .vp_b, .movmsk, .tmp2d, .tmp3y, ._, ._ }, | | |
| 3371 | .{ ._, ._, .not, .tmp2d, ._, ._, ._ }, | | |
| 3372 | .{ ._, ._, .mov, .memi(.dst0d, .tmp1), .tmp2d, ._, ._ }, | | |
| 3373 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 4), ._, ._ }, | | |
| 3374 | .{ ._, ._, .add, .tmp0p, .i(32), ._, ._ }, | | |
| 3375 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 3376 | }, | | |
| 3377 | } }, | | |
| 3378 | }, .{ | | |
| 3379 | .required_features = .{ .avx2, null }, | | |
| 3380 | .src_constraints = .{ .{ .int = .word }, .{ .int = .word } }, | | |
| 3381 | .patterns = &.{ | | |
| 3382 | .{ .src = .{ .to_mem, .to_mem } }, | | |
| 3383 | }, | | |
| 3384 | .extra_temps = .{ | | |
| 3385 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | | |
| 3386 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | | |
| 3387 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, | | |
| 3388 | .{ .kind = .{ .rc = .sse } }, | | |
| 3389 | .unused, | | |
| 3390 | .unused, | | |
| 3391 | }, | | |
| 3392 | .dst_temps = .{.mem}, | | |
| 3393 | .each = .{ .once = switch (cc) { | | |
| 3394 | else => unreachable, | | |
| 3395 | .e => &.{ | | |
| 3396 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | | |
| 3397 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | | |
| 3398 | .{ .@"0:", .v_dqu, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, | | |
| 3399 | .{ ._, .vp_w, .cmpeq, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_size), ._ }, | | |
| 3400 | .{ ._, .vp_b, .ackssw, .tmp3y, .tmp3y, .tmp3y, ._ }, | | |
| 3401 | .{ ._, .vp_b, .movmsk, .tmp2d, .tmp3y, ._, ._ }, | | |
| 3402 | .{ ._, ._, .mov, .memi(.dst0w, .tmp1), .tmp2w, ._, ._ }, | | |
| 3403 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 2), ._, ._ }, | | |
| 3404 | .{ ._, ._, .add, .tmp0p, .i(32), ._, ._ }, | | |
| 3405 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 3406 | }, | | |
| 3407 | .ne => &.{ | | |
| 3408 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | | |
| 3409 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | | |
| 3410 | .{ .@"0:", .v_dqu, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, | | |
| 3411 | .{ ._, .vp_w, .cmpeq, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_size), ._ }, | | |
| 3412 | .{ ._, .vp_b, .ackssw, .tmp3y, .tmp3y, .tmp3y, ._ }, | | |
| 3413 | .{ ._, .vp_b, .movmsk, .tmp2d, .tmp3y, ._, ._ }, | | |
| 3414 | .{ ._, ._, .not, .tmp2d, ._, ._, ._ }, | | |
| 3415 | .{ ._, ._, .mov, .memi(.dst0w, .tmp1), .tmp2w, ._, ._ }, | | |
| 3416 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 2), ._, ._ }, | | |
| 3417 | .{ ._, ._, .add, .tmp0p, .i(32), ._, ._ }, | | |
| 3418 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 3419 | }, | | |
| 3420 | } }, | | |
| 3421 | }, .{ | | |
| 3422 | .required_features = .{ .avx2, null }, | | |
| 3423 | .src_constraints = .{ .{ .int = .dword }, .{ .int = .dword } }, | | |
| 3424 | .patterns = &.{ | | |
| 3425 | .{ .src = .{ .to_mem, .to_mem } }, | | |
| 3426 | }, | | |
| 3427 | .extra_temps = .{ | | |
| 3428 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | | |
| 3429 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | | |
| 3430 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | | |
| 3431 | .{ .kind = .{ .rc = .sse } }, | | |
| 3432 | .unused, | | |
| 3433 | .unused, | | |
| 3434 | }, | | |
| 3435 | .dst_temps = .{.mem}, | | |
| 3436 | .each = .{ .once = switch (cc) { | | |
| 3437 | else => unreachable, | | |
| 3438 | .e => &.{ | | |
| 3439 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | | |
| 3440 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | | |
| 3441 | .{ .@"0:", .v_dqu, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, | | |
| 3442 | .{ ._, .vp_d, .cmpeq, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_size), ._ }, | | |
| 3443 | .{ ._, .v_ps, .movmsk, .tmp2d, .tmp3y, ._, ._ }, | | |
| 3444 | .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ }, | | |
| 3445 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 1), ._, ._ }, | | |
| 3446 | .{ ._, ._, .add, .tmp0p, .i(32), ._, ._ }, | | |
| 3447 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 3448 | }, | | |
| 3449 | .ne => &.{ | | |
| 3450 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | | |
| 3451 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | | |
| 3452 | .{ .@"0:", .v_dqu, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, | | |
| 3453 | .{ ._, .vp_d, .cmpeq, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_size), ._ }, | | |
| 3454 | .{ ._, .v_ps, .movmsk, .tmp2d, .tmp3y, ._, ._ }, | | |
| 3455 | .{ ._, ._, .not, .tmp2b, ._, ._, ._ }, | | |
| 3456 | .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ }, | | |
| 3457 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 1), ._, ._ }, | | |
| 3458 | .{ ._, ._, .add, .tmp0p, .i(32), ._, ._ }, | | |
| 3459 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 3460 | }, | 6991 | }, |
| 3461 | } }, | 6992 | } }, |
| 3462 | }, .{ | 6993 | }, .{ |
| 3463 | .required_features = .{ .avx2, null }, | 6994 | .src_constraints = .{ .{ .bool_vec = .word }, .{ .bool_vec = .word } }, |
| 3464 | .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword } }, | | |
| 3465 | .patterns = &.{ | 6995 | .patterns = &.{ |
| 3466 | .{ .src = .{ .to_mem, .to_mem } }, | 6996 | .{ .src = .{ .mut_mem, .imm16 } }, |
| 3467 | }, | 6997 | .{ .src = .{ .imm16, .mut_mem }, .commute = .{ 0, 1 } }, |
| 3468 | .extra_temps = .{ | 6998 | .{ .src = .{ .to_mut_gpr, .imm16 } }, |
| 3469 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 6999 | .{ .src = .{ .imm16, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 3470 | .{ .type = .u32, .kind = .{ .reg = .rcx } }, | 7000 | .{ .src = .{ .mut_mem, .to_gpr } }, |
| 3471 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 7001 | .{ .src = .{ .to_gpr, .mut_mem }, .commute = .{ 0, 1 } }, |
| 3472 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 7002 | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 3473 | .{ .kind = .{ .rc = .sse } }, | 7003 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 3474 | .unused, | 7004 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 3475 | }, | 7005 | }, |
| 3476 | .dst_temps = .{.mem}, | 7006 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 7007 | .clobbers = .{ .eflags = true }, |
| 3477 | .each = .{ .once = switch (cc) { | 7008 | .each = .{ .once = switch (cc) { |
| 3478 | else => unreachable, | 7009 | else => unreachable, |
| 3479 | .e => &.{ | 7010 | .e => &.{ |
| 3480 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 7011 | .{ ._, ._, .xor, .dst0w, .src1w, ._, ._ }, |
| 3481 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 7012 | .{ ._, ._, .not, .dst0w, ._, ._, ._ }, |
| 3482 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, | | |
| 3483 | .{ .@"0:", .v_dqu, .mov, .tmp4y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, | | |
| 3484 | .{ ._, .vp_q, .cmpeq, .tmp4y, .tmp4y, .memia(.src1y, .tmp0, .add_size), ._ }, | | |
| 3485 | .{ ._, .v_pd, .movmsk, .tmp3d, .tmp4y, ._, ._ }, | | |
| 3486 | .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ }, | | |
| 3487 | .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ }, | | |
| 3488 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 4), ._, ._ }, | | |
| 3489 | .{ ._, ._, .@"test", .tmp1d, .i(0b111), ._, ._ }, | | |
| 3490 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, | | |
| 3491 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, | | |
| 3492 | .{ ._, ._r, .sh, .tmp3d, .i(3), ._, ._ }, | | |
| 3493 | .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ }, | | |
| 3494 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, | | |
| 3495 | .{ .@"1:", ._, .add, .tmp0p, .i(32), ._, ._ }, | | |
| 3496 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 3497 | .{ ._, ._, .@"test", .tmp1d, .i(0b111), ._, ._ }, | | |
| 3498 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, | | |
| 3499 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, | | |
| 3500 | .{ ._, ._r, .sh, .tmp3d, .i(3), ._, ._ }, | | |
| 3501 | .{ ._, ._, .mov, .memi(.dst0b, .tmp3), .tmp2b, ._, ._ }, | | |
| 3502 | }, | 7013 | }, |
| 3503 | .ne => &.{ | 7014 | .ne => &.{ |
| 3504 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 7015 | .{ ._, ._, .xor, .dst0w, .src1w, ._, ._ }, |
| 3505 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | | |
| 3506 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, | | |
| 3507 | .{ .@"0:", .v_dqu, .mov, .tmp4y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, | | |
| 3508 | .{ ._, .vp_q, .cmpeq, .tmp4y, .tmp4y, .memia(.src1y, .tmp0, .add_size), ._ }, | | |
| 3509 | .{ ._, .v_pd, .movmsk, .tmp3d, .tmp4y, ._, ._ }, | | |
| 3510 | .{ ._, ._, .xor, .tmp3b, .i(0b1111), ._, ._ }, | | |
| 3511 | .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ }, | | |
| 3512 | .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ }, | | |
| 3513 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 4), ._, ._ }, | | |
| 3514 | .{ ._, ._, .@"test", .tmp1d, .i(0b111), ._, ._ }, | | |
| 3515 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, | | |
| 3516 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, | | |
| 3517 | .{ ._, ._r, .sh, .tmp3d, .i(3), ._, ._ }, | | |
| 3518 | .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ }, | | |
| 3519 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, | | |
| 3520 | .{ .@"1:", ._, .add, .tmp0p, .i(32), ._, ._ }, | | |
| 3521 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 3522 | .{ ._, ._, .@"test", .tmp1d, .i(0b111), ._, ._ }, | | |
| 3523 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, | | |
| 3524 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, | | |
| 3525 | .{ ._, ._r, .sh, .tmp3d, .i(3), ._, ._ }, | | |
| 3526 | .{ ._, ._, .mov, .memi(.dst0b, .tmp3), .tmp2b, ._, ._ }, | | |
| 3527 | }, | 7016 | }, |
| 3528 | } }, | 7017 | } }, |
| 3529 | }, .{ | 7018 | }, .{ |
| 3530 | .required_features = .{ .avx, null }, | 7019 | .src_constraints = .{ .{ .bool_vec = .dword }, .{ .bool_vec = .dword } }, |
| 3531 | .src_constraints = .{ .{ .int = .byte }, .{ .int = .byte } }, | | |
| 3532 | .patterns = &.{ | 7020 | .patterns = &.{ |
| 3533 | .{ .src = .{ .to_mem, .to_mem } }, | 7021 | .{ .src = .{ .mut_mem, .imm32 } }, |
| 3534 | }, | 7022 | .{ .src = .{ .imm32, .mut_mem }, .commute = .{ 0, 1 } }, |
| 3535 | .extra_temps = .{ | 7023 | .{ .src = .{ .to_mut_gpr, .imm32 } }, |
| 3536 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 7024 | .{ .src = .{ .imm32, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 3537 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 7025 | .{ .src = .{ .mut_mem, .to_gpr } }, |
| 3538 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, | 7026 | .{ .src = .{ .to_gpr, .mut_mem }, .commute = .{ 0, 1 } }, |
| 3539 | .{ .kind = .{ .rc = .sse } }, | 7027 | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 3540 | .unused, | 7028 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 3541 | .unused, | 7029 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 3542 | }, | 7030 | }, |
| 3543 | .dst_temps = .{.mem}, | 7031 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 7032 | .clobbers = .{ .eflags = true }, |
| 3544 | .each = .{ .once = switch (cc) { | 7033 | .each = .{ .once = switch (cc) { |
| 3545 | else => unreachable, | 7034 | else => unreachable, |
| 3546 | .e => &.{ | 7035 | .e => &.{ |
| 3547 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 7036 | .{ ._, ._, .xor, .dst0d, .src1d, ._, ._ }, |
| 3548 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 7037 | .{ ._, ._, .not, .dst0d, ._, ._, ._ }, |
| 3549 | .{ .@"0:", .v_dqu, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | | |
| 3550 | .{ ._, .vp_b, .cmpeq, .tmp3x, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._ }, | | |
| 3551 | .{ ._, .vp_b, .movmsk, .tmp2d, .tmp3x, ._, ._ }, | | |
| 3552 | .{ ._, ._, .mov, .memi(.dst0w, .tmp1), .tmp2w, ._, ._ }, | | |
| 3553 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 2), ._, ._ }, | | |
| 3554 | .{ ._, ._, .add, .tmp0p, .i(16), ._, ._ }, | | |
| 3555 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 3556 | }, | 7038 | }, |
| 3557 | .ne => &.{ | 7039 | .ne => &.{ |
| 3558 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 7040 | .{ ._, ._, .xor, .dst0d, .src1d, ._, ._ }, |
| 3559 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | | |
| 3560 | .{ .@"0:", .v_dqu, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | | |
| 3561 | .{ ._, .vp_b, .cmpeq, .tmp3x, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._ }, | | |
| 3562 | .{ ._, .vp_b, .movmsk, .tmp2d, .tmp3x, ._, ._ }, | | |
| 3563 | .{ ._, ._, .not, .tmp2d, ._, ._, ._ }, | | |
| 3564 | .{ ._, ._, .mov, .memi(.dst0w, .tmp1), .tmp2w, ._, ._ }, | | |
| 3565 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 2), ._, ._ }, | | |
| 3566 | .{ ._, ._, .add, .tmp0p, .i(16), ._, ._ }, | | |
| 3567 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 3568 | }, | 7041 | }, |
| 3569 | } }, | 7042 | } }, |
| 3570 | }, .{ | 7043 | }, .{ |
| 3571 | .required_features = .{ .avx, null }, | 7044 | .required_features = .{ .@"64bit", null, null, null }, |
| 3572 | .src_constraints = .{ .{ .int = .word }, .{ .int = .word } }, | 7045 | .src_constraints = .{ .{ .bool_vec = .qword }, .{ .bool_vec = .qword } }, |
| 3573 | .patterns = &.{ | 7046 | .patterns = &.{ |
| 3574 | .{ .src = .{ .to_mem, .to_mem } }, | 7047 | .{ .src = .{ .mut_mem, .simm32 } }, |
| 3575 | }, | 7048 | .{ .src = .{ .simm32, .mut_mem }, .commute = .{ 0, 1 } }, |
| 3576 | .extra_temps = .{ | 7049 | .{ .src = .{ .to_mut_gpr, .simm32 } }, |
| 3577 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 7050 | .{ .src = .{ .simm32, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 3578 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 7051 | .{ .src = .{ .mut_mem, .to_gpr } }, |
| 3579 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 7052 | .{ .src = .{ .to_gpr, .mut_mem }, .commute = .{ 0, 1 } }, |
| 3580 | .{ .kind = .{ .rc = .sse } }, | 7053 | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 3581 | .unused, | 7054 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 3582 | .unused, | 7055 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 3583 | }, | 7056 | }, |
| 3584 | .dst_temps = .{.mem}, | 7057 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 7058 | .clobbers = .{ .eflags = true }, |
| 3585 | .each = .{ .once = switch (cc) { | 7059 | .each = .{ .once = switch (cc) { |
| 3586 | else => unreachable, | 7060 | else => unreachable, |
| 3587 | .e => &.{ | 7061 | .e => &.{ |
| 3588 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 7062 | .{ ._, ._, .xor, .dst0q, .src1q, ._, ._ }, |
| 3589 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 7063 | .{ ._, ._, .not, .dst0q, ._, ._, ._ }, |
| 3590 | .{ .@"0:", .v_dqu, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | | |
| 3591 | .{ ._, .vp_w, .cmpeq, .tmp3x, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._ }, | | |
| 3592 | .{ ._, .vp_b, .ackssw, .tmp3x, .tmp3x, .tmp3x, ._ }, | | |
| 3593 | .{ ._, .vp_b, .movmsk, .tmp2d, .tmp3x, ._, ._ }, | | |
| 3594 | .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ }, | | |
| 3595 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 1), ._, ._ }, | | |
| 3596 | .{ ._, ._, .add, .tmp0p, .i(16), ._, ._ }, | | |
| 3597 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 3598 | }, | 7064 | }, |
| 3599 | .ne => &.{ | 7065 | .ne => &.{ |
| 3600 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 7066 | .{ ._, ._, .xor, .dst0q, .src1q, ._, ._ }, |
| 3601 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | | |
| 3602 | .{ .@"0:", .v_dqu, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | | |
| 3603 | .{ ._, .vp_w, .cmpeq, .tmp3x, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._ }, | | |
| 3604 | .{ ._, .vp_b, .ackssw, .tmp3x, .tmp3x, .tmp3x, ._ }, | | |
| 3605 | .{ ._, .vp_b, .movmsk, .tmp2d, .tmp3x, ._, ._ }, | | |
| 3606 | .{ ._, ._, .not, .tmp2b, ._, ._, ._ }, | | |
| 3607 | .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ }, | | |
| 3608 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 1), ._, ._ }, | | |
| 3609 | .{ ._, ._, .add, .tmp0p, .i(16), ._, ._ }, | | |
| 3610 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 3611 | }, | 7067 | }, |
| 3612 | } }, | 7068 | } }, |
| 3613 | }, .{ | 7069 | }, .{ |
| 3614 | .required_features = .{ .avx, null }, | 7070 | .src_constraints = .{ .any_bool_vec, .any_bool_vec }, |
| 3615 | .src_constraints = .{ .{ .int = .dword }, .{ .int = .dword } }, | | |
| 3616 | .patterns = &.{ | 7071 | .patterns = &.{ |
| 3617 | .{ .src = .{ .to_mem, .to_mem } }, | 7072 | .{ .src = .{ .to_mem, .to_mem } }, |
| 3618 | }, | 7073 | }, |
| 3619 | .extra_temps = .{ | 7074 | .extra_temps = .{ |
| 3620 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 7075 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3621 | .{ .type = .u32, .kind = .{ .reg = .rcx } }, | 7076 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 3622 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 7077 | .unused, |
| 3623 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 7078 | .unused, |
| 3624 | .{ .kind = .{ .rc = .sse } }, | 7079 | .unused, |
| 3625 | .unused, | 7080 | .unused, |
| 3626 | }, | 7081 | }, |
| 3627 | .dst_temps = .{.mem}, | 7082 | .dst_temps = .{.mem}, |
| | 7083 | .clobbers = .{ .eflags = true }, |
| 3628 | .each = .{ .once = switch (cc) { | 7084 | .each = .{ .once = switch (cc) { |
| 3629 | else => unreachable, | 7085 | else => unreachable, |
| 3630 | .e => &.{ | 7086 | .e => &.{ |
| 3631 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 7087 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 3632 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 7088 | .{ .@"0:", ._, .mov, .tmp1p, .memia(.src0p, .tmp0, .add_size), ._, ._ }, |
| 3633 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, | 7089 | .{ ._, ._, .xor, .tmp1p, .memia(.src1p, .tmp0, .add_size), ._, ._ }, |
| 3634 | .{ .@"0:", .v_dqu, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 7090 | .{ ._, ._, .not, .tmp1p, ._, ._, ._ }, |
| 3635 | .{ ._, .vp_d, .cmpeq, .tmp4x, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._ }, | 7091 | .{ ._, ._, .mov, .memia(.dst0p, .tmp0, .add_size), .tmp1p, ._, ._ }, |
| 3636 | .{ ._, .v_ps, .movmsk, .tmp3d, .tmp4x, ._, ._ }, | 7092 | .{ ._, ._, .add, .tmp0p, .sa(.tmp1, .add_size), ._, ._ }, |
| 3637 | .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ }, | | |
| 3638 | .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ }, | | |
| 3639 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 4), ._, ._ }, | | |
| 3640 | .{ ._, ._, .@"test", .tmp1d, .i(0b111), ._, ._ }, | | |
| 3641 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, | | |
| 3642 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, | | |
| 3643 | .{ ._, ._r, .sh, .tmp3d, .i(3), ._, ._ }, | | |
| 3644 | .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ }, | | |
| 3645 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, | | |
| 3646 | .{ .@"1:", ._, .add, .tmp0p, .i(16), ._, ._ }, | | |
| 3647 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 7093 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3648 | .{ ._, ._, .@"test", .tmp1d, .i(0b111), ._, ._ }, | | |
| 3649 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, | | |
| 3650 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, | | |
| 3651 | .{ ._, ._r, .sh, .tmp3d, .i(3), ._, ._ }, | | |
| 3652 | .{ ._, ._, .mov, .memi(.dst0b, .tmp3), .tmp2b, ._, ._ }, | | |
| 3653 | }, | 7094 | }, |
| 3654 | .ne => &.{ | 7095 | .ne => &.{ |
| 3655 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 7096 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 3656 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 7097 | .{ .@"0:", ._, .mov, .tmp1p, .memia(.src0p, .tmp0, .add_size), ._, ._ }, |
| 3657 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, | 7098 | .{ ._, ._, .xor, .tmp1p, .memia(.src1p, .tmp0, .add_size), ._, ._ }, |
| 3658 | .{ .@"0:", .v_dqu, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 7099 | .{ ._, ._, .mov, .memia(.dst0p, .tmp0, .add_size), .tmp1p, ._, ._ }, |
| 3659 | .{ ._, .vp_d, .cmpeq, .tmp4x, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._ }, | 7100 | .{ ._, ._, .add, .tmp0p, .sa(.tmp1, .add_size), ._, ._ }, |
| 3660 | .{ ._, .v_ps, .movmsk, .tmp3d, .tmp4x, ._, ._ }, | | |
| 3661 | .{ ._, ._, .xor, .tmp3b, .i(0b1111), ._, ._ }, | | |
| 3662 | .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ }, | | |
| 3663 | .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ }, | | |
| 3664 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 4), ._, ._ }, | | |
| 3665 | .{ ._, ._, .@"test", .tmp1d, .i(0b111), ._, ._ }, | | |
| 3666 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, | | |
| 3667 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, | | |
| 3668 | .{ ._, ._r, .sh, .tmp3d, .i(3), ._, ._ }, | | |
| 3669 | .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ }, | | |
| 3670 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, | | |
| 3671 | .{ .@"1:", ._, .add, .tmp0p, .i(16), ._, ._ }, | | |
| 3672 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 7101 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3673 | .{ ._, ._, .@"test", .tmp1d, .i(0b111), ._, ._ }, | | |
| 3674 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, | | |
| 3675 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, | | |
| 3676 | .{ ._, ._r, .sh, .tmp3d, .i(3), ._, ._ }, | | |
| 3677 | .{ ._, ._, .mov, .memi(.dst0b, .tmp3), .tmp2b, ._, ._ }, | | |
| 3678 | }, | 7102 | }, |
| 3679 | } }, | 7103 | } }, |
| 3680 | }, .{ | 7104 | }, .{ |
| 3681 | .required_features = .{ .avx, null }, | 7105 | .required_features = .{ .avx2, null, null, null }, |
| 3682 | .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword } }, | 7106 | .src_constraints = .{ .{ .scalar_int = .byte }, .{ .scalar_int = .byte } }, |
| 3683 | .patterns = &.{ | 7107 | .patterns = &.{ |
| 3684 | .{ .src = .{ .to_mem, .to_mem } }, | 7108 | .{ .src = .{ .to_mem, .to_mem } }, |
| 3685 | }, | 7109 | }, |
| 3686 | .extra_temps = .{ | 7110 | .extra_temps = .{ |
| 3687 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 7111 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3688 | .{ .type = .u32, .kind = .{ .reg = .rcx } }, | 7112 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 3689 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 7113 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 3690 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | | |
| 3691 | .{ .kind = .{ .rc = .sse } }, | 7114 | .{ .kind = .{ .rc = .sse } }, |
| 3692 | .unused, | 7115 | .unused, |
| | 7116 | .unused, |
| 3693 | }, | 7117 | }, |
| 3694 | .dst_temps = .{.mem}, | 7118 | .dst_temps = .{.mem}, |
| | 7119 | .clobbers = .{ .eflags = true }, |
| 3695 | .each = .{ .once = switch (cc) { | 7120 | .each = .{ .once = switch (cc) { |
| 3696 | else => unreachable, | 7121 | else => unreachable, |
| 3697 | .e => &.{ | 7122 | .e => &.{ |
| 3698 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 7123 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 3699 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 7124 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 3700 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, | 7125 | .{ .@"0:", .v_dqu, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 3701 | .{ .@"0:", .v_dqu, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 7126 | .{ ._, .vp_b, .cmpeq, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_size), ._ }, |
| 3702 | .{ ._, .vp_q, .cmpeq, .tmp4x, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._ }, | 7127 | .{ ._, .vp_b, .movmsk, .tmp2d, .tmp3y, ._, ._ }, |
| 3703 | .{ ._, .v_pd, .movmsk, .tmp3d, .tmp4x, ._, ._ }, | 7128 | .{ ._, ._, .mov, .memi(.dst0d, .tmp1), .tmp2d, ._, ._ }, |
| 3704 | .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ }, | 7129 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 4), ._, ._ }, |
| 3705 | .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ }, | 7130 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 3706 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 2), ._, ._ }, | | |
| 3707 | .{ ._, ._, .@"test", .tmp1d, .i(0b111), ._, ._ }, | | |
| 3708 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, | | |
| 3709 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, | | |
| 3710 | .{ ._, ._r, .sh, .tmp3d, .i(3), ._, ._ }, | | |
| 3711 | .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ }, | | |
| 3712 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, | | |
| 3713 | .{ .@"1:", ._, .add, .tmp0p, .i(16), ._, ._ }, | | |
| 3714 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 7131 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3715 | .{ ._, ._, .@"test", .tmp1d, .i(0b111), ._, ._ }, | | |
| 3716 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, | | |
| 3717 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, | | |
| 3718 | .{ ._, ._r, .sh, .tmp3d, .i(3), ._, ._ }, | | |
| 3719 | .{ ._, ._, .mov, .memi(.dst0b, .tmp3), .tmp2b, ._, ._ }, | | |
| 3720 | }, | 7132 | }, |
| 3721 | .ne => &.{ | 7133 | .ne => &.{ |
| 3722 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 7134 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 3723 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 7135 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 3724 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, | 7136 | .{ .@"0:", .v_dqu, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 3725 | .{ .@"0:", .v_dqu, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 7137 | .{ ._, .vp_b, .cmpeq, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_size), ._ }, |
| 3726 | .{ ._, .vp_q, .cmpeq, .tmp4x, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._ }, | 7138 | .{ ._, .vp_b, .movmsk, .tmp2d, .tmp3y, ._, ._ }, |
| 3727 | .{ ._, .v_pd, .movmsk, .tmp3d, .tmp4x, ._, ._ }, | 7139 | .{ ._, ._, .not, .tmp2d, ._, ._, ._ }, |
| 3728 | .{ ._, ._, .xor, .tmp3b, .i(0b11), ._, ._ }, | 7140 | .{ ._, ._, .mov, .memi(.dst0d, .tmp1), .tmp2d, ._, ._ }, |
| 3729 | .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ }, | 7141 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 4), ._, ._ }, |
| 3730 | .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ }, | 7142 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 3731 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 2), ._, ._ }, | | |
| 3732 | .{ ._, ._, .@"test", .tmp1d, .i(0b111), ._, ._ }, | | |
| 3733 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, | | |
| 3734 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, | | |
| 3735 | .{ ._, ._r, .sh, .tmp3d, .i(3), ._, ._ }, | | |
| 3736 | .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ }, | | |
| 3737 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, | | |
| 3738 | .{ .@"1:", ._, .add, .tmp0p, .i(16), ._, ._ }, | | |
| 3739 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 7143 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3740 | .{ ._, ._, .@"test", .tmp1d, .i(0b111), ._, ._ }, | | |
| 3741 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, | | |
| 3742 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, | | |
| 3743 | .{ ._, ._r, .sh, .tmp3d, .i(3), ._, ._ }, | | |
| 3744 | .{ ._, ._, .mov, .memi(.dst0b, .tmp3), .tmp2b, ._, ._ }, | | |
| 3745 | }, | 7144 | }, |
| 3746 | } }, | 7145 | } }, |
| 3747 | }, .{ | 7146 | }, .{ |
| 3748 | .required_features = .{ .sse2, null }, | 7147 | .required_features = .{ .avx2, null, null, null }, |
| 3749 | .src_constraints = .{ .{ .int = .byte }, .{ .int = .byte } }, | 7148 | .src_constraints = .{ .{ .scalar_int = .word }, .{ .scalar_int = .word } }, |
| 3750 | .patterns = &.{ | 7149 | .patterns = &.{ |
| 3751 | .{ .src = .{ .to_mem, .to_mem } }, | 7150 | .{ .src = .{ .to_mem, .to_mem } }, |
| 3752 | }, | 7151 | }, |
| ... | @@ -3759,35 +7158,38 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3759,35 +7158,38 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3759 | .unused, | 7158 | .unused, |
| 3760 | }, | 7159 | }, |
| 3761 | .dst_temps = .{.mem}, | 7160 | .dst_temps = .{.mem}, |
| | 7161 | .clobbers = .{ .eflags = true }, |
| 3762 | .each = .{ .once = switch (cc) { | 7162 | .each = .{ .once = switch (cc) { |
| 3763 | else => unreachable, | 7163 | else => unreachable, |
| 3764 | .e => &.{ | 7164 | .e => &.{ |
| 3765 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 7165 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 3766 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 7166 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 3767 | .{ .@"0:", ._dqu, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 7167 | .{ .@"0:", .v_dqu, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 3768 | .{ ._, .p_b, .cmpeq, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, | 7168 | .{ ._, .vp_w, .cmpeq, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_size), ._ }, |
| 3769 | .{ ._, .p_b, .movmsk, .tmp2d, .tmp3x, ._, ._ }, | 7169 | .{ ._, .vp_b, .ackssw, .tmp3y, .tmp3y, .tmp3y, ._ }, |
| | 7170 | .{ ._, .vp_b, .movmsk, .tmp2d, .tmp3y, ._, ._ }, |
| 3770 | .{ ._, ._, .mov, .memi(.dst0w, .tmp1), .tmp2w, ._, ._ }, | 7171 | .{ ._, ._, .mov, .memi(.dst0w, .tmp1), .tmp2w, ._, ._ }, |
| 3771 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 2), ._, ._ }, | 7172 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 2), ._, ._ }, |
| 3772 | .{ ._, ._, .add, .tmp0p, .i(16), ._, ._ }, | 7173 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 3773 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 7174 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3774 | }, | 7175 | }, |
| 3775 | .ne => &.{ | 7176 | .ne => &.{ |
| 3776 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 7177 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 3777 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 7178 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 3778 | .{ .@"0:", ._dqu, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 7179 | .{ .@"0:", .v_dqu, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 3779 | .{ ._, .p_b, .cmpeq, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, | 7180 | .{ ._, .vp_w, .cmpeq, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_size), ._ }, |
| 3780 | .{ ._, .p_b, .movmsk, .tmp2d, .tmp3x, ._, ._ }, | 7181 | .{ ._, .vp_b, .ackssw, .tmp3y, .tmp3y, .tmp3y, ._ }, |
| | 7182 | .{ ._, .vp_b, .movmsk, .tmp2d, .tmp3y, ._, ._ }, |
| 3781 | .{ ._, ._, .not, .tmp2d, ._, ._, ._ }, | 7183 | .{ ._, ._, .not, .tmp2d, ._, ._, ._ }, |
| 3782 | .{ ._, ._, .mov, .memi(.dst0w, .tmp1), .tmp2w, ._, ._ }, | 7184 | .{ ._, ._, .mov, .memi(.dst0w, .tmp1), .tmp2w, ._, ._ }, |
| 3783 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 2), ._, ._ }, | 7185 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 2), ._, ._ }, |
| 3784 | .{ ._, ._, .add, .tmp0p, .i(16), ._, ._ }, | 7186 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 3785 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 7187 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3786 | }, | 7188 | }, |
| 3787 | } }, | 7189 | } }, |
| 3788 | }, .{ | 7190 | }, .{ |
| 3789 | .required_features = .{ .sse2, null }, | 7191 | .required_features = .{ .avx2, null, null, null }, |
| 3790 | .src_constraints = .{ .{ .int = .word }, .{ .int = .word } }, | 7192 | .src_constraints = .{ .{ .scalar_int = .dword }, .{ .scalar_int = .dword } }, |
| 3791 | .patterns = &.{ | 7193 | .patterns = &.{ |
| 3792 | .{ .src = .{ .to_mem, .to_mem } }, | 7194 | .{ .src = .{ .to_mem, .to_mem } }, |
| 3793 | }, | 7195 | }, |
| ... | @@ -3800,37 +7202,36 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3800,37 +7202,36 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3800 | .unused, | 7202 | .unused, |
| 3801 | }, | 7203 | }, |
| 3802 | .dst_temps = .{.mem}, | 7204 | .dst_temps = .{.mem}, |
| | 7205 | .clobbers = .{ .eflags = true }, |
| 3803 | .each = .{ .once = switch (cc) { | 7206 | .each = .{ .once = switch (cc) { |
| 3804 | else => unreachable, | 7207 | else => unreachable, |
| 3805 | .e => &.{ | 7208 | .e => &.{ |
| 3806 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 7209 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 3807 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 7210 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 3808 | .{ .@"0:", ._dqu, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 7211 | .{ .@"0:", .v_dqu, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 3809 | .{ ._, .p_w, .cmpeq, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, | 7212 | .{ ._, .vp_d, .cmpeq, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_size), ._ }, |
| 3810 | .{ ._, .p_b, .ackssw, .tmp3x, .tmp3x, ._, ._ }, | 7213 | .{ ._, .v_ps, .movmsk, .tmp2d, .tmp3y, ._, ._ }, |
| 3811 | .{ ._, .p_b, .movmsk, .tmp2d, .tmp3x, ._, ._ }, | | |
| 3812 | .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ }, | 7214 | .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ }, |
| 3813 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 1), ._, ._ }, | 7215 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 1), ._, ._ }, |
| 3814 | .{ ._, ._, .add, .tmp0p, .i(16), ._, ._ }, | 7216 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 3815 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 7217 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3816 | }, | 7218 | }, |
| 3817 | .ne => &.{ | 7219 | .ne => &.{ |
| 3818 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 7220 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 3819 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 7221 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 3820 | .{ .@"0:", ._dqu, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 7222 | .{ .@"0:", .v_dqu, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 3821 | .{ ._, .p_w, .cmpeq, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, | 7223 | .{ ._, .vp_d, .cmpeq, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_size), ._ }, |
| 3822 | .{ ._, .p_b, .ackssw, .tmp3x, .tmp3x, ._, ._ }, | 7224 | .{ ._, .v_ps, .movmsk, .tmp2d, .tmp3y, ._, ._ }, |
| 3823 | .{ ._, .p_b, .movmsk, .tmp2d, .tmp3x, ._, ._ }, | | |
| 3824 | .{ ._, ._, .not, .tmp2b, ._, ._, ._ }, | 7225 | .{ ._, ._, .not, .tmp2b, ._, ._, ._ }, |
| 3825 | .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ }, | 7226 | .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ }, |
| 3826 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 1), ._, ._ }, | 7227 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 1), ._, ._ }, |
| 3827 | .{ ._, ._, .add, .tmp0p, .i(16), ._, ._ }, | 7228 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 3828 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 7229 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3829 | }, | 7230 | }, |
| 3830 | } }, | 7231 | } }, |
| 3831 | }, .{ | 7232 | }, .{ |
| 3832 | .required_features = .{ .sse2, null }, | 7233 | .required_features = .{ .avx2, null, null, null }, |
| 3833 | .src_constraints = .{ .{ .int = .dword }, .{ .int = .dword } }, | 7234 | .src_constraints = .{ .{ .scalar_int = .qword }, .{ .scalar_int = .qword } }, |
| 3834 | .patterns = &.{ | 7235 | .patterns = &.{ |
| 3835 | .{ .src = .{ .to_mem, .to_mem } }, | 7236 | .{ .src = .{ .to_mem, .to_mem } }, |
| 3836 | }, | 7237 | }, |
| ... | @@ -3843,128 +7244,104 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3843,128 +7244,104 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3843 | .unused, | 7244 | .unused, |
| 3844 | }, | 7245 | }, |
| 3845 | .dst_temps = .{.mem}, | 7246 | .dst_temps = .{.mem}, |
| | 7247 | .clobbers = .{ .eflags = true }, |
| 3846 | .each = .{ .once = switch (cc) { | 7248 | .each = .{ .once = switch (cc) { |
| 3847 | else => unreachable, | 7249 | else => unreachable, |
| 3848 | .e => &.{ | 7250 | .e => &.{ |
| 3849 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 7251 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 3850 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 7252 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 3851 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, | 7253 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, |
| 3852 | .{ .@"0:", ._dqu, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 7254 | .{ .@"0:", .v_dqu, .mov, .tmp4y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 3853 | .{ ._, .p_d, .cmpeq, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, | 7255 | .{ ._, .vp_q, .cmpeq, .tmp4y, .tmp4y, .memia(.src1y, .tmp0, .add_size), ._ }, |
| 3854 | .{ ._, ._ps, .movmsk, .tmp3d, .tmp4x, ._, ._ }, | 7256 | .{ ._, .v_pd, .movmsk, .tmp3d, .tmp4y, ._, ._ }, |
| 3855 | .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ }, | 7257 | .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ }, |
| 3856 | .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ }, | 7258 | .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ }, |
| 3857 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 4), ._, ._ }, | 7259 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 4), ._, ._ }, |
| 3858 | .{ ._, ._, .@"test", .tmp1d, .i(0b111), ._, ._ }, | 7260 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| 3859 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, | 7261 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 3860 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, | 7262 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| 3861 | .{ ._, ._r, .sh, .tmp3d, .i(3), ._, ._ }, | 7263 | .{ ._, ._r, .sh, .tmp3d, .si(3), ._, ._ }, |
| 3862 | .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ }, | 7264 | .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ }, |
| 3863 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, | 7265 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, |
| 3864 | .{ .@"1:", ._, .add, .tmp0p, .i(16), ._, ._ }, | 7266 | .{ .@"1:", ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 3865 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 7267 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3866 | .{ ._, ._, .@"test", .tmp1d, .i(0b111), ._, ._ }, | 7268 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| 3867 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, | 7269 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| 3868 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, | 7270 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| 3869 | .{ ._, ._r, .sh, .tmp3d, .i(3), ._, ._ }, | 7271 | .{ ._, ._r, .sh, .tmp3d, .si(3), ._, ._ }, |
| 3870 | .{ ._, ._, .mov, .memi(.dst0b, .tmp3), .tmp2b, ._, ._ }, | 7272 | .{ ._, ._, .mov, .memi(.dst0b, .tmp3), .tmp2b, ._, ._ }, |
| 3871 | }, | 7273 | }, |
| 3872 | .ne => &.{ | 7274 | .ne => &.{ |
| 3873 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 7275 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 3874 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 7276 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 3875 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, | 7277 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, |
| 3876 | .{ .@"0:", ._dqu, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 7278 | .{ .@"0:", .v_dqu, .mov, .tmp4y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 3877 | .{ ._, .p_d, .cmpeq, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, | 7279 | .{ ._, .vp_q, .cmpeq, .tmp4y, .tmp4y, .memia(.src1y, .tmp0, .add_size), ._ }, |
| 3878 | .{ ._, ._ps, .movmsk, .tmp3d, .tmp4x, ._, ._ }, | 7280 | .{ ._, .v_pd, .movmsk, .tmp3d, .tmp4y, ._, ._ }, |
| 3879 | .{ ._, ._, .xor, .tmp3b, .i(0b1111), ._, ._ }, | 7281 | .{ ._, ._, .xor, .tmp3b, .si(0b1111), ._, ._ }, |
| 3880 | .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ }, | 7282 | .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ }, |
| 3881 | .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ }, | 7283 | .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ }, |
| 3882 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 4), ._, ._ }, | 7284 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 4), ._, ._ }, |
| 3883 | .{ ._, ._, .@"test", .tmp1d, .i(0b111), ._, ._ }, | 7285 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| 3884 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, | 7286 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 3885 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, | 7287 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| 3886 | .{ ._, ._r, .sh, .tmp3d, .i(3), ._, ._ }, | 7288 | .{ ._, ._r, .sh, .tmp3d, .si(3), ._, ._ }, |
| 3887 | .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ }, | 7289 | .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ }, |
| 3888 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, | 7290 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, |
| 3889 | .{ .@"1:", ._, .add, .tmp0p, .i(16), ._, ._ }, | 7291 | .{ .@"1:", ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 3890 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 7292 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3891 | .{ ._, ._, .@"test", .tmp1d, .i(0b111), ._, ._ }, | 7293 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| 3892 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, | 7294 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| 3893 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, | 7295 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| 3894 | .{ ._, ._r, .sh, .tmp3d, .i(3), ._, ._ }, | 7296 | .{ ._, ._r, .sh, .tmp3d, .si(3), ._, ._ }, |
| 3895 | .{ ._, ._, .mov, .memi(.dst0b, .tmp3), .tmp2b, ._, ._ }, | 7297 | .{ ._, ._, .mov, .memi(.dst0b, .tmp3), .tmp2b, ._, ._ }, |
| 3896 | }, | 7298 | }, |
| 3897 | } }, | 7299 | } }, |
| 3898 | }, .{ | 7300 | }, .{ |
| 3899 | .required_features = .{ .sse4_1, null }, | 7301 | .required_features = .{ .avx, null, null, null }, |
| 3900 | .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword } }, | 7302 | .src_constraints = .{ .{ .scalar_int = .byte }, .{ .scalar_int = .byte } }, |
| 3901 | .patterns = &.{ | 7303 | .patterns = &.{ |
| 3902 | .{ .src = .{ .to_mem, .to_mem } }, | 7304 | .{ .src = .{ .to_mem, .to_mem } }, |
| 3903 | }, | 7305 | }, |
| 3904 | .extra_temps = .{ | 7306 | .extra_temps = .{ |
| 3905 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 7307 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3906 | .{ .type = .u32, .kind = .{ .reg = .rcx } }, | 7308 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 3907 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 7309 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 3908 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | | |
| 3909 | .{ .kind = .{ .rc = .sse } }, | 7310 | .{ .kind = .{ .rc = .sse } }, |
| 3910 | .unused, | 7311 | .unused, |
| | 7312 | .unused, |
| 3911 | }, | 7313 | }, |
| 3912 | .dst_temps = .{.mem}, | 7314 | .dst_temps = .{.mem}, |
| | 7315 | .clobbers = .{ .eflags = true }, |
| 3913 | .each = .{ .once = switch (cc) { | 7316 | .each = .{ .once = switch (cc) { |
| 3914 | else => unreachable, | 7317 | else => unreachable, |
| 3915 | .e => &.{ | 7318 | .e => &.{ |
| 3916 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 7319 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 3917 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 7320 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 3918 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, | 7321 | .{ .@"0:", .v_dqu, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 3919 | .{ .@"0:", ._dqu, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 7322 | .{ ._, .vp_b, .cmpeq, .tmp3x, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._ }, |
| 3920 | .{ ._, .p_q, .cmpeq, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, | 7323 | .{ ._, .vp_b, .movmsk, .tmp2d, .tmp3x, ._, ._ }, |
| 3921 | .{ ._, ._pd, .movmsk, .tmp3d, .tmp4x, ._, ._ }, | 7324 | .{ ._, ._, .mov, .memi(.dst0w, .tmp1), .tmp2w, ._, ._ }, |
| 3922 | .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ }, | | |
| 3923 | .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ }, | | |
| 3924 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 2), ._, ._ }, | 7325 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 2), ._, ._ }, |
| 3925 | .{ ._, ._, .@"test", .tmp1d, .i(0b111), ._, ._ }, | 7326 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 3926 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, | | |
| 3927 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, | | |
| 3928 | .{ ._, ._r, .sh, .tmp3d, .i(3), ._, ._ }, | | |
| 3929 | .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ }, | | |
| 3930 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, | | |
| 3931 | .{ .@"1:", ._, .add, .tmp0p, .i(16), ._, ._ }, | | |
| 3932 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 7327 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3933 | .{ ._, ._, .@"test", .tmp1d, .i(0b111), ._, ._ }, | | |
| 3934 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, | | |
| 3935 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, | | |
| 3936 | .{ ._, ._r, .sh, .tmp3d, .i(3), ._, ._ }, | | |
| 3937 | .{ ._, ._, .mov, .memi(.dst0b, .tmp3), .tmp2b, ._, ._ }, | | |
| 3938 | }, | 7328 | }, |
| 3939 | .ne => &.{ | 7329 | .ne => &.{ |
| 3940 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 7330 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 3941 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 7331 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 3942 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, | 7332 | .{ .@"0:", .v_dqu, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 3943 | .{ .@"0:", ._dqu, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 7333 | .{ ._, .vp_b, .cmpeq, .tmp3x, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._ }, |
| 3944 | .{ ._, .p_q, .cmpeq, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, | 7334 | .{ ._, .vp_b, .movmsk, .tmp2d, .tmp3x, ._, ._ }, |
| 3945 | .{ ._, ._pd, .movmsk, .tmp3d, .tmp4x, ._, ._ }, | 7335 | .{ ._, ._, .not, .tmp2d, ._, ._, ._ }, |
| 3946 | .{ ._, ._, .xor, .tmp3b, .i(0b11), ._, ._ }, | 7336 | .{ ._, ._, .mov, .memi(.dst0w, .tmp1), .tmp2w, ._, ._ }, |
| 3947 | .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ }, | | |
| 3948 | .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ }, | | |
| 3949 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 2), ._, ._ }, | 7337 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 2), ._, ._ }, |
| 3950 | .{ ._, ._, .@"test", .tmp1d, .i(0b111), ._, ._ }, | 7338 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 3951 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, | | |
| 3952 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, | | |
| 3953 | .{ ._, ._r, .sh, .tmp3d, .i(3), ._, ._ }, | | |
| 3954 | .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ }, | | |
| 3955 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, | | |
| 3956 | .{ .@"1:", ._, .add, .tmp0p, .i(16), ._, ._ }, | | |
| 3957 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 7339 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3958 | .{ ._, ._, .@"test", .tmp1d, .i(0b111), ._, ._ }, | | |
| 3959 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, | | |
| 3960 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, | | |
| 3961 | .{ ._, ._r, .sh, .tmp3d, .i(3), ._, ._ }, | | |
| 3962 | .{ ._, ._, .mov, .memi(.dst0b, .tmp3), .tmp2b, ._, ._ }, | | |
| 3963 | }, | 7340 | }, |
| 3964 | } }, | 7341 | } }, |
| 3965 | }, .{ | 7342 | }, .{ |
| 3966 | .required_features = .{ .sse, .mmx }, | 7343 | .required_features = .{ .avx, null, null, null }, |
| 3967 | .src_constraints = .{ .{ .int = .byte }, .{ .int = .byte } }, | 7344 | .src_constraints = .{ .{ .scalar_int = .word }, .{ .scalar_int = .word } }, |
| 3968 | .patterns = &.{ | 7345 | .patterns = &.{ |
| 3969 | .{ .src = .{ .to_mem, .to_mem } }, | 7346 | .{ .src = .{ .to_mem, .to_mem } }, |
| 3970 | }, | 7347 | }, |
| ... | @@ -3972,111 +7349,111 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3972,111 +7349,111 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3972 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 7349 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3973 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 7350 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 3974 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 7351 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 3975 | .{ .kind = .{ .rc = .mmx } }, | 7352 | .{ .kind = .{ .rc = .sse } }, |
| 3976 | .unused, | 7353 | .unused, |
| 3977 | .unused, | 7354 | .unused, |
| 3978 | }, | 7355 | }, |
| 3979 | .dst_temps = .{.mem}, | 7356 | .dst_temps = .{.mem}, |
| | 7357 | .clobbers = .{ .eflags = true }, |
| 3980 | .each = .{ .once = switch (cc) { | 7358 | .each = .{ .once = switch (cc) { |
| 3981 | else => unreachable, | 7359 | else => unreachable, |
| 3982 | .e => &.{ | 7360 | .e => &.{ |
| 3983 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 7361 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 3984 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 7362 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 3985 | .{ .@"0:", ._q, .mov, .tmp3q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, | 7363 | .{ .@"0:", .v_dqu, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 3986 | .{ ._, .p_b, .cmpeq, .tmp3q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, | 7364 | .{ ._, .vp_w, .cmpeq, .tmp3x, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._ }, |
| 3987 | .{ ._, .p_b, .movmsk, .tmp2d, .tmp3q, ._, ._ }, | 7365 | .{ ._, .vp_b, .ackssw, .tmp3x, .tmp3x, .tmp3x, ._ }, |
| | 7366 | .{ ._, .vp_b, .movmsk, .tmp2d, .tmp3x, ._, ._ }, |
| 3988 | .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ }, | 7367 | .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ }, |
| 3989 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 1), ._, ._ }, | 7368 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 1), ._, ._ }, |
| 3990 | .{ ._, ._, .add, .tmp0p, .i(8), ._, ._ }, | 7369 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 3991 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 7370 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3992 | }, | 7371 | }, |
| 3993 | .ne => &.{ | 7372 | .ne => &.{ |
| 3994 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 7373 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 3995 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 7374 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 3996 | .{ .@"0:", ._q, .mov, .tmp3q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, | 7375 | .{ .@"0:", .v_dqu, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 3997 | .{ ._, .p_b, .cmpeq, .tmp3q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, | 7376 | .{ ._, .vp_w, .cmpeq, .tmp3x, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._ }, |
| 3998 | .{ ._, .p_b, .movmsk, .tmp2d, .tmp3q, ._, ._ }, | 7377 | .{ ._, .vp_b, .ackssw, .tmp3x, .tmp3x, .tmp3x, ._ }, |
| | 7378 | .{ ._, .vp_b, .movmsk, .tmp2d, .tmp3x, ._, ._ }, |
| 3999 | .{ ._, ._, .not, .tmp2b, ._, ._, ._ }, | 7379 | .{ ._, ._, .not, .tmp2b, ._, ._, ._ }, |
| 4000 | .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ }, | 7380 | .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ }, |
| 4001 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 1), ._, ._ }, | 7381 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 1), ._, ._ }, |
| 4002 | .{ ._, ._, .add, .tmp0p, .i(8), ._, ._ }, | 7382 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 4003 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 7383 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4004 | }, | 7384 | }, |
| 4005 | } }, | 7385 | } }, |
| 4006 | }, .{ | 7386 | }, .{ |
| 4007 | .required_features = .{ .sse, .mmx }, | 7387 | .required_features = .{ .avx, null, null, null }, |
| 4008 | .src_constraints = .{ .{ .int = .word }, .{ .int = .word } }, | 7388 | .src_constraints = .{ .{ .scalar_int = .dword }, .{ .scalar_int = .dword } }, |
| 4009 | .patterns = &.{ | 7389 | .patterns = &.{ |
| 4010 | .{ .src = .{ .to_mem, .to_mem } }, | 7390 | .{ .src = .{ .to_mem, .to_mem } }, |
| 4011 | }, | 7391 | }, |
| 4012 | .extra_temps = .{ | 7392 | .extra_temps = .{ |
| 4013 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 7393 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4014 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 7394 | .{ .type = .u32, .kind = .{ .reg = .rcx } }, |
| 4015 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 7395 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 4016 | .{ .kind = .{ .rc = .mmx } }, | | |
| 4017 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 7396 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 4018 | .{ .kind = .{ .rc = .mmx } }, | 7397 | .{ .kind = .{ .rc = .sse } }, |
| | 7398 | .unused, |
| 4019 | }, | 7399 | }, |
| 4020 | .dst_temps = .{.mem}, | 7400 | .dst_temps = .{.mem}, |
| | 7401 | .clobbers = .{ .eflags = true }, |
| 4021 | .each = .{ .once = switch (cc) { | 7402 | .each = .{ .once = switch (cc) { |
| 4022 | else => unreachable, | 7403 | else => unreachable, |
| 4023 | .e => &.{ | 7404 | .e => &.{ |
| 4024 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 7405 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4025 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 7406 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 4026 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, | 7407 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, |
| 4027 | .{ ._, .p_, .xor, .tmp3q, .tmp3q, ._, ._ }, | 7408 | .{ .@"0:", .v_dqu, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 4028 | .{ .@"0:", ._q, .mov, .tmp5q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, | 7409 | .{ ._, .vp_d, .cmpeq, .tmp4x, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._ }, |
| 4029 | .{ ._, .p_w, .cmpeq, .tmp5q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, | 7410 | .{ ._, .v_ps, .movmsk, .tmp3d, .tmp4x, ._, ._ }, |
| 4030 | .{ ._, .p_b, .ackssw, .tmp5q, .tmp3q, ._, ._ }, | 7411 | .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ }, |
| 4031 | .{ ._, .p_b, .movmsk, .tmp4d, .tmp5q, ._, ._ }, | 7412 | .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ }, |
| 4032 | .{ ._, ._l, .ro, .tmp4b, .tmp1b, ._, ._ }, | | |
| 4033 | .{ ._, ._, .@"or", .tmp2b, .tmp4b, ._, ._ }, | | |
| 4034 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 4), ._, ._ }, | 7413 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 4), ._, ._ }, |
| 4035 | .{ ._, ._, .@"test", .tmp1d, .i(0b111), ._, ._ }, | 7414 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| 4036 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, | 7415 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 4037 | .{ ._, ._, .mov, .tmp4d, .tmp1d, ._, ._ }, | 7416 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| 4038 | .{ ._, ._r, .sh, .tmp4d, .i(3), ._, ._ }, | 7417 | .{ ._, ._r, .sh, .tmp3d, .si(3), ._, ._ }, |
| 4039 | .{ ._, ._, .mov, .memid(.dst0b, .tmp4, -1), .tmp2b, ._, ._ }, | 7418 | .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ }, |
| 4040 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, | 7419 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, |
| 4041 | .{ .@"1:", ._, .add, .tmp0p, .i(8), ._, ._ }, | 7420 | .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 4042 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 7421 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4043 | .{ ._, ._, .@"test", .tmp1d, .i(0b111), ._, ._ }, | 7422 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| 4044 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, | 7423 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| 4045 | .{ ._, ._, .mov, .tmp4d, .tmp1d, ._, ._ }, | 7424 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| 4046 | .{ ._, ._r, .sh, .tmp4d, .i(3), ._, ._ }, | 7425 | .{ ._, ._r, .sh, .tmp3d, .si(3), ._, ._ }, |
| 4047 | .{ ._, ._, .mov, .memi(.dst0b, .tmp4), .tmp2b, ._, ._ }, | 7426 | .{ ._, ._, .mov, .memi(.dst0b, .tmp3), .tmp2b, ._, ._ }, |
| 4048 | }, | 7427 | }, |
| 4049 | .ne => &.{ | 7428 | .ne => &.{ |
| 4050 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 7429 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4051 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 7430 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 4052 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, | 7431 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, |
| 4053 | .{ ._, .p_, .xor, .tmp3q, .tmp3q, ._, ._ }, | 7432 | .{ .@"0:", .v_dqu, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 4054 | .{ .@"0:", ._q, .mov, .tmp5q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, | 7433 | .{ ._, .vp_d, .cmpeq, .tmp4x, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._ }, |
| 4055 | .{ ._, .p_w, .cmpeq, .tmp5q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, | 7434 | .{ ._, .v_ps, .movmsk, .tmp3d, .tmp4x, ._, ._ }, |
| 4056 | .{ ._, .p_b, .ackssw, .tmp5q, .tmp3q, ._, ._ }, | 7435 | .{ ._, ._, .xor, .tmp3b, .si(0b1111), ._, ._ }, |
| 4057 | .{ ._, .p_b, .movmsk, .tmp4d, .tmp5q, ._, ._ }, | 7436 | .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ }, |
| 4058 | .{ ._, ._, .xor, .tmp4b, .i(0b1111), ._, ._ }, | 7437 | .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ }, |
| 4059 | .{ ._, ._l, .ro, .tmp4b, .tmp1b, ._, ._ }, | | |
| 4060 | .{ ._, ._, .@"or", .tmp2b, .tmp4b, ._, ._ }, | | |
| 4061 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 4), ._, ._ }, | 7438 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 4), ._, ._ }, |
| 4062 | .{ ._, ._, .@"test", .tmp1d, .i(0b111), ._, ._ }, | 7439 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| 4063 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, | 7440 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 4064 | .{ ._, ._, .mov, .tmp4d, .tmp1d, ._, ._ }, | 7441 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| 4065 | .{ ._, ._r, .sh, .tmp4d, .i(3), ._, ._ }, | 7442 | .{ ._, ._r, .sh, .tmp3d, .si(3), ._, ._ }, |
| 4066 | .{ ._, ._, .mov, .memid(.dst0b, .tmp4, -1), .tmp2b, ._, ._ }, | 7443 | .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ }, |
| 4067 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, | 7444 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, |
| 4068 | .{ .@"1:", ._, .add, .tmp0p, .i(8), ._, ._ }, | 7445 | .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 4069 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 7446 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4070 | .{ ._, ._, .@"test", .tmp1d, .i(0b111), ._, ._ }, | 7447 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| 4071 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, | 7448 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| 4072 | .{ ._, ._, .mov, .tmp4d, .tmp1d, ._, ._ }, | 7449 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| 4073 | .{ ._, ._r, .sh, .tmp4d, .i(3), ._, ._ }, | 7450 | .{ ._, ._r, .sh, .tmp3d, .si(3), ._, ._ }, |
| 4074 | .{ ._, ._, .mov, .memi(.dst0b, .tmp4), .tmp2b, ._, ._ }, | 7451 | .{ ._, ._, .mov, .memi(.dst0b, .tmp3), .tmp2b, ._, ._ }, |
| 4075 | }, | 7452 | }, |
| 4076 | } }, | 7453 | } }, |
| 4077 | }, .{ | 7454 | }, .{ |
| 4078 | .required_features = .{ .sse, .mmx }, | 7455 | .required_features = .{ .avx, null, null, null }, |
| 4079 | .src_constraints = .{ .{ .int = .dword }, .{ .int = .dword } }, | 7456 | .src_constraints = .{ .{ .scalar_int = .qword }, .{ .scalar_int = .qword } }, |
| 4080 | .patterns = &.{ | 7457 | .patterns = &.{ |
| 4081 | .{ .src = .{ .to_mem, .to_mem } }, | 7458 | .{ .src = .{ .to_mem, .to_mem } }, |
| 4082 | }, | 7459 | }, |
| ... | @@ -4084,578 +7461,535 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4084,578 +7461,535 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4084 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 7461 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4085 | .{ .type = .u32, .kind = .{ .reg = .rcx } }, | 7462 | .{ .type = .u32, .kind = .{ .reg = .rcx } }, |
| 4086 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 7463 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 4087 | .{ .kind = .{ .rc = .mmx } }, | | |
| 4088 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 7464 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 4089 | .{ .kind = .{ .rc = .mmx } }, | 7465 | .{ .kind = .{ .rc = .sse } }, |
| | 7466 | .unused, |
| 4090 | }, | 7467 | }, |
| 4091 | .dst_temps = .{.mem}, | 7468 | .dst_temps = .{.mem}, |
| | 7469 | .clobbers = .{ .eflags = true }, |
| 4092 | .each = .{ .once = switch (cc) { | 7470 | .each = .{ .once = switch (cc) { |
| 4093 | else => unreachable, | 7471 | else => unreachable, |
| 4094 | .e => &.{ | 7472 | .e => &.{ |
| 4095 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 7473 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4096 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 7474 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 4097 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, | 7475 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, |
| 4098 | .{ ._, .p_, .xor, .tmp3q, .tmp3q, ._, ._ }, | 7476 | .{ .@"0:", .v_dqu, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 4099 | .{ .@"0:", ._q, .mov, .tmp5q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, | 7477 | .{ ._, .vp_q, .cmpeq, .tmp4x, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._ }, |
| 4100 | .{ ._, .p_d, .cmpeq, .tmp5q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, | 7478 | .{ ._, .v_pd, .movmsk, .tmp3d, .tmp4x, ._, ._ }, |
| 4101 | .{ ._, .p_w, .ackssd, .tmp5q, .tmp3q, ._, ._ }, | 7479 | .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ }, |
| 4102 | .{ ._, .p_b, .ackssw, .tmp5q, .tmp3q, ._, ._ }, | 7480 | .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ }, |
| 4103 | .{ ._, .p_b, .movmsk, .tmp4d, .tmp5q, ._, ._ }, | | |
| 4104 | .{ ._, ._l, .ro, .tmp4b, .tmp1b, ._, ._ }, | | |
| 4105 | .{ ._, ._, .@"or", .tmp2b, .tmp4b, ._, ._ }, | | |
| 4106 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 2), ._, ._ }, | 7481 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 2), ._, ._ }, |
| 4107 | .{ ._, ._, .@"test", .tmp1d, .i(0b111), ._, ._ }, | 7482 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| 4108 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, | 7483 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 4109 | .{ ._, ._, .mov, .tmp4d, .tmp1d, ._, ._ }, | 7484 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| 4110 | .{ ._, ._r, .sh, .tmp4d, .i(3), ._, ._ }, | 7485 | .{ ._, ._r, .sh, .tmp3d, .si(3), ._, ._ }, |
| 4111 | .{ ._, ._, .mov, .memid(.dst0b, .tmp4, -1), .tmp2b, ._, ._ }, | 7486 | .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ }, |
| 4112 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, | 7487 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, |
| 4113 | .{ .@"1:", ._, .add, .tmp0p, .i(8), ._, ._ }, | 7488 | .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 4114 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 7489 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4115 | .{ ._, ._, .@"test", .tmp1d, .i(0b111), ._, ._ }, | 7490 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| 4116 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, | 7491 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| 4117 | .{ ._, ._, .mov, .tmp4d, .tmp1d, ._, ._ }, | 7492 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| 4118 | .{ ._, ._r, .sh, .tmp4d, .i(3), ._, ._ }, | 7493 | .{ ._, ._r, .sh, .tmp3d, .si(3), ._, ._ }, |
| 4119 | .{ ._, ._, .mov, .memi(.dst0b, .tmp4), .tmp2b, ._, ._ }, | 7494 | .{ ._, ._, .mov, .memi(.dst0b, .tmp3), .tmp2b, ._, ._ }, |
| 4120 | }, | 7495 | }, |
| 4121 | .ne => &.{ | 7496 | .ne => &.{ |
| 4122 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 7497 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4123 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 7498 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 4124 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, | 7499 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, |
| 4125 | .{ ._, .p_, .xor, .tmp3q, .tmp3q, ._, ._ }, | 7500 | .{ .@"0:", .v_dqu, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 4126 | .{ .@"0:", ._q, .mov, .tmp5q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, | 7501 | .{ ._, .vp_q, .cmpeq, .tmp4x, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._ }, |
| 4127 | .{ ._, .p_d, .cmpeq, .tmp5q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, | 7502 | .{ ._, .v_pd, .movmsk, .tmp3d, .tmp4x, ._, ._ }, |
| 4128 | .{ ._, .p_w, .ackssd, .tmp5q, .tmp3q, ._, ._ }, | 7503 | .{ ._, ._, .xor, .tmp3b, .si(0b11), ._, ._ }, |
| 4129 | .{ ._, .p_b, .ackssw, .tmp5q, .tmp3q, ._, ._ }, | 7504 | .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ }, |
| 4130 | .{ ._, .p_b, .movmsk, .tmp4d, .tmp5q, ._, ._ }, | 7505 | .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ }, |
| 4131 | .{ ._, ._, .xor, .tmp4b, .i(0b11), ._, ._ }, | | |
| 4132 | .{ ._, ._l, .ro, .tmp4b, .tmp1b, ._, ._ }, | | |
| 4133 | .{ ._, ._, .@"or", .tmp2b, .tmp4b, ._, ._ }, | | |
| 4134 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 2), ._, ._ }, | 7506 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 2), ._, ._ }, |
| 4135 | .{ ._, ._, .@"test", .tmp1d, .i(0b111), ._, ._ }, | 7507 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| 4136 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, | 7508 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 4137 | .{ ._, ._, .mov, .tmp4d, .tmp1d, ._, ._ }, | 7509 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| 4138 | .{ ._, ._r, .sh, .tmp4d, .i(3), ._, ._ }, | 7510 | .{ ._, ._r, .sh, .tmp3d, .si(3), ._, ._ }, |
| 4139 | .{ ._, ._, .mov, .memid(.dst0b, .tmp4, -1), .tmp2b, ._, ._ }, | 7511 | .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ }, |
| 4140 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, | 7512 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, |
| 4141 | .{ .@"1:", ._, .add, .tmp0p, .i(8), ._, ._ }, | 7513 | .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 4142 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 7514 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4143 | .{ ._, ._, .@"test", .tmp1d, .i(0b111), ._, ._ }, | 7515 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| 4144 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, | 7516 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| 4145 | .{ ._, ._, .mov, .tmp4d, .tmp1d, ._, ._ }, | 7517 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| 4146 | .{ ._, ._r, .sh, .tmp4d, .i(3), ._, ._ }, | 7518 | .{ ._, ._r, .sh, .tmp3d, .si(3), ._, ._ }, |
| 4147 | .{ ._, ._, .mov, .memi(.dst0b, .tmp4), .tmp2b, ._, ._ }, | 7519 | .{ ._, ._, .mov, .memi(.dst0b, .tmp3), .tmp2b, ._, ._ }, |
| 4148 | }, | 7520 | }, |
| 4149 | } }, | | |
| 4150 | }, .{ | | |
| 4151 | .required_features = .{ .slow_incdec, null }, | | |
| 4152 | .dst_constraints = .{.{ .bool_vec = .byte }}, | | |
| 4153 | .src_constraints = .{ .{ .int = .byte }, .{ .int = .byte } }, | | |
| 4154 | .patterns = &.{ | | |
| 4155 | .{ .src = .{ .to_mem, .to_mem } }, | | |
| 4156 | }, | | |
| 4157 | .extra_temps = .{ | | |
| 4158 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | | |
| 4159 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | | |
| 4160 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | | |
| 4161 | .unused, | | |
| 4162 | .unused, | | |
| 4163 | .unused, | | |
| 4164 | }, | | |
| 4165 | .dst_temps = .{.{ .rc = .general_purpose }}, | | |
| 4166 | .each = .{ .once = &.{ | | |
| 4167 | .{ ._, ._, .xor, .dst0b, .dst0b, ._, ._ }, | | |
| 4168 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | | |
| 4169 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | | |
| 4170 | .{ .@"0:", ._, .mov, .tmp2b, .memia(.src0b, .tmp0, .add_size), ._, ._ }, | | |
| 4171 | .{ ._, ._, .cmp, .tmp2b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, | | |
| 4172 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | | |
| 4173 | .{ ._, ._l, .sh, .tmp2b, .tmp1b, ._, ._ }, | | |
| 4174 | .{ ._, ._, .@"or", .dst0b, .tmp2b, ._, ._ }, | | |
| 4175 | .{ ._, ._, .add, .tmp1b, .i(1), ._, ._ }, | | |
| 4176 | .{ ._, ._, .add, .tmp0p, .i(1), ._, ._ }, | | |
| 4177 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 4178 | } }, | | |
| 4179 | }, .{ | | |
| 4180 | .dst_constraints = .{.{ .bool_vec = .byte }}, | | |
| 4181 | .src_constraints = .{ .{ .int = .byte }, .{ .int = .byte } }, | | |
| 4182 | .patterns = &.{ | | |
| 4183 | .{ .src = .{ .to_mem, .to_mem } }, | | |
| 4184 | }, | | |
| 4185 | .extra_temps = .{ | | |
| 4186 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | | |
| 4187 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | | |
| 4188 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | | |
| 4189 | .unused, | | |
| 4190 | .unused, | | |
| 4191 | .unused, | | |
| 4192 | }, | | |
| 4193 | .dst_temps = .{.{ .rc = .general_purpose }}, | | |
| 4194 | .each = .{ .once = &.{ | | |
| 4195 | .{ ._, ._, .xor, .dst0b, .dst0b, ._, ._ }, | | |
| 4196 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | | |
| 4197 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | | |
| 4198 | .{ .@"0:", ._, .mov, .tmp2b, .memia(.src0b, .tmp0, .add_size), ._, ._ }, | | |
| 4199 | .{ ._, ._, .cmp, .tmp2b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, | | |
| 4200 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | | |
| 4201 | .{ ._, ._l, .sh, .tmp2b, .tmp1b, ._, ._ }, | | |
| 4202 | .{ ._, ._, .@"or", .dst0b, .tmp2b, ._, ._ }, | | |
| 4203 | .{ ._, ._, .inc, .tmp1b, ._, ._, ._ }, | | |
| 4204 | .{ ._, ._, .inc, .tmp0p, ._, ._, ._ }, | | |
| 4205 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | | |
| 4206 | } }, | | |
| 4207 | }, .{ | | |
| 4208 | .required_features = .{ .slow_incdec, null }, | | |
| 4209 | .dst_constraints = .{.{ .bool_vec = .byte }}, | | |
| 4210 | .src_constraints = .{ .{ .int = .word }, .{ .int = .word } }, | | |
| 4211 | .patterns = &.{ | | |
| 4212 | .{ .src = .{ .to_mem, .to_mem } }, | | |
| 4213 | }, | | |
| 4214 | .extra_temps = .{ | | |
| 4215 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | | |
| 4216 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | | |
| 4217 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, | | |
| 4218 | .unused, | | |
| 4219 | .unused, | | |
| 4220 | .unused, | | |
| 4221 | }, | | |
| 4222 | .dst_temps = .{.{ .rc = .general_purpose }}, | | |
| 4223 | .each = .{ .once = &.{ | | |
| 4224 | .{ ._, ._, .xor, .dst0b, .dst0b, ._, ._ }, | | |
| 4225 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | | |
| 4226 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | | |
| 4227 | .{ .@"0:", ._, .mov, .tmp2w, .memia(.src0w, .tmp0, .add_size), ._, ._ }, | | |
| 4228 | .{ ._, ._, .cmp, .tmp2w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, | | |
| 4229 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | | |
| 4230 | .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, | | |
| 4231 | .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, | | |
| 4232 | .{ ._, ._, .add, .tmp1b, .i(1), ._, ._ }, | | |
| 4233 | .{ ._, ._, .add, .tmp0p, .i(2), ._, ._ }, | | |
| 4234 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 4235 | } }, | | |
| 4236 | }, .{ | | |
| 4237 | .dst_constraints = .{.{ .bool_vec = .byte }}, | | |
| 4238 | .src_constraints = .{ .{ .int = .word }, .{ .int = .word } }, | | |
| 4239 | .patterns = &.{ | | |
| 4240 | .{ .src = .{ .to_mem, .to_mem } }, | | |
| 4241 | }, | | |
| 4242 | .extra_temps = .{ | | |
| 4243 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | | |
| 4244 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | | |
| 4245 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, | | |
| 4246 | .unused, | | |
| 4247 | .unused, | | |
| 4248 | .unused, | | |
| 4249 | }, | | |
| 4250 | .dst_temps = .{.{ .rc = .general_purpose }}, | | |
| 4251 | .each = .{ .once = &.{ | | |
| 4252 | .{ ._, ._, .xor, .dst0b, .dst0b, ._, ._ }, | | |
| 4253 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | | |
| 4254 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | | |
| 4255 | .{ .@"0:", ._, .mov, .tmp2w, .memia(.src0w, .tmp0, .add_size), ._, ._ }, | | |
| 4256 | .{ ._, ._, .cmp, .tmp2w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, | | |
| 4257 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | | |
| 4258 | .{ ._, ._l, .sh, .tmp2b, .tmp1b, ._, ._ }, | | |
| 4259 | .{ ._, ._, .@"or", .dst0b, .tmp2b, ._, ._ }, | | |
| 4260 | .{ ._, ._, .inc, .tmp1b, ._, ._, ._ }, | | |
| 4261 | .{ ._, ._, .add, .tmp0p, .i(2), ._, ._ }, | | |
| 4262 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 4263 | } }, | 7521 | } }, |
| 4264 | }, .{ | 7522 | }, .{ |
| 4265 | .required_features = .{ .slow_incdec, null }, | 7523 | .required_features = .{ .sse2, null, null, null }, |
| 4266 | .dst_constraints = .{.{ .bool_vec = .byte }}, | 7524 | .src_constraints = .{ .{ .scalar_int = .byte }, .{ .scalar_int = .byte } }, |
| 4267 | .src_constraints = .{ .{ .int = .dword }, .{ .int = .dword } }, | | |
| 4268 | .patterns = &.{ | 7525 | .patterns = &.{ |
| 4269 | .{ .src = .{ .to_mem, .to_mem } }, | 7526 | .{ .src = .{ .to_mem, .to_mem } }, |
| 4270 | }, | 7527 | }, |
| 4271 | .extra_temps = .{ | 7528 | .extra_temps = .{ |
| 4272 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 7529 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4273 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | | |
| 4274 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 7530 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 4275 | .unused, | 7531 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| | 7532 | .{ .kind = .{ .rc = .sse } }, |
| 4276 | .unused, | 7533 | .unused, |
| 4277 | .unused, | 7534 | .unused, |
| 4278 | }, | 7535 | }, |
| 4279 | .dst_temps = .{.{ .rc = .general_purpose }}, | 7536 | .dst_temps = .{.mem}, |
| 4280 | .each = .{ .once = &.{ | 7537 | .clobbers = .{ .eflags = true }, |
| 4281 | .{ ._, ._, .xor, .dst0b, .dst0b, ._, ._ }, | 7538 | .each = .{ .once = switch (cc) { |
| 4282 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 7539 | else => unreachable, |
| 4283 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | 7540 | .e => &.{ |
| 4284 | .{ .@"0:", ._, .mov, .tmp2d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, | 7541 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4285 | .{ ._, ._, .cmp, .tmp2d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, | 7542 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 4286 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 7543 | .{ .@"0:", ._dqu, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 4287 | .{ ._, ._l, .sh, .tmp2b, .tmp1b, ._, ._ }, | 7544 | .{ ._, .p_b, .cmpeq, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 4288 | .{ ._, ._, .@"or", .dst0b, .tmp2b, ._, ._ }, | 7545 | .{ ._, .p_b, .movmsk, .tmp2d, .tmp3x, ._, ._ }, |
| 4289 | .{ ._, ._, .add, .tmp1b, .i(1), ._, ._ }, | 7546 | .{ ._, ._, .mov, .memi(.dst0w, .tmp1), .tmp2w, ._, ._ }, |
| 4290 | .{ ._, ._, .add, .tmp0p, .i(4), ._, ._ }, | 7547 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 2), ._, ._ }, |
| 4291 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 7548 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 7549 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 7550 | }, |
| | 7551 | .ne => &.{ |
| | 7552 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| | 7553 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| | 7554 | .{ .@"0:", ._dqu, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| | 7555 | .{ ._, .p_b, .cmpeq, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| | 7556 | .{ ._, .p_b, .movmsk, .tmp2d, .tmp3x, ._, ._ }, |
| | 7557 | .{ ._, ._, .not, .tmp2d, ._, ._, ._ }, |
| | 7558 | .{ ._, ._, .mov, .memi(.dst0w, .tmp1), .tmp2w, ._, ._ }, |
| | 7559 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 2), ._, ._ }, |
| | 7560 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 7561 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 7562 | }, |
| 4292 | } }, | 7563 | } }, |
| 4293 | }, .{ | 7564 | }, .{ |
| 4294 | .dst_constraints = .{.{ .bool_vec = .byte }}, | 7565 | .required_features = .{ .sse2, null, null, null }, |
| 4295 | .src_constraints = .{ .{ .int = .dword }, .{ .int = .dword } }, | 7566 | .src_constraints = .{ .{ .scalar_int = .word }, .{ .scalar_int = .word } }, |
| 4296 | .patterns = &.{ | 7567 | .patterns = &.{ |
| 4297 | .{ .src = .{ .to_mem, .to_mem } }, | 7568 | .{ .src = .{ .to_mem, .to_mem } }, |
| 4298 | }, | 7569 | }, |
| 4299 | .extra_temps = .{ | 7570 | .extra_temps = .{ |
| 4300 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 7571 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4301 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | | |
| 4302 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 7572 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 4303 | .unused, | 7573 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 7574 | .{ .kind = .{ .rc = .sse } }, |
| 4304 | .unused, | 7575 | .unused, |
| 4305 | .unused, | 7576 | .unused, |
| 4306 | }, | 7577 | }, |
| 4307 | .dst_temps = .{.{ .rc = .general_purpose }}, | 7578 | .dst_temps = .{.mem}, |
| 4308 | .each = .{ .once = &.{ | 7579 | .clobbers = .{ .eflags = true }, |
| 4309 | .{ ._, ._, .xor, .dst0b, .dst0b, ._, ._ }, | 7580 | .each = .{ .once = switch (cc) { |
| 4310 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 7581 | else => unreachable, |
| 4311 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | 7582 | .e => &.{ |
| 4312 | .{ .@"0:", ._, .mov, .tmp2d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, | 7583 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4313 | .{ ._, ._, .cmp, .tmp2d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, | 7584 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 4314 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 7585 | .{ .@"0:", ._dqu, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 4315 | .{ ._, ._l, .sh, .tmp2b, .tmp1b, ._, ._ }, | 7586 | .{ ._, .p_w, .cmpeq, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 4316 | .{ ._, ._, .@"or", .dst0b, .tmp2b, ._, ._ }, | 7587 | .{ ._, .p_b, .ackssw, .tmp3x, .tmp3x, ._, ._ }, |
| 4317 | .{ ._, ._, .inc, .tmp1b, ._, ._, ._ }, | 7588 | .{ ._, .p_b, .movmsk, .tmp2d, .tmp3x, ._, ._ }, |
| 4318 | .{ ._, ._, .add, .tmp0p, .i(4), ._, ._ }, | 7589 | .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ }, |
| 4319 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 7590 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 1), ._, ._ }, |
| | 7591 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 7592 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 7593 | }, |
| | 7594 | .ne => &.{ |
| | 7595 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| | 7596 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| | 7597 | .{ .@"0:", ._dqu, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| | 7598 | .{ ._, .p_w, .cmpeq, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| | 7599 | .{ ._, .p_b, .ackssw, .tmp3x, .tmp3x, ._, ._ }, |
| | 7600 | .{ ._, .p_b, .movmsk, .tmp2d, .tmp3x, ._, ._ }, |
| | 7601 | .{ ._, ._, .not, .tmp2b, ._, ._, ._ }, |
| | 7602 | .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ }, |
| | 7603 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 1), ._, ._ }, |
| | 7604 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 7605 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 7606 | }, |
| 4320 | } }, | 7607 | } }, |
| 4321 | }, .{ | 7608 | }, .{ |
| 4322 | .required_features = .{ .@"64bit", .slow_incdec }, | 7609 | .required_features = .{ .sse2, null, null, null }, |
| 4323 | .dst_constraints = .{.{ .bool_vec = .byte }}, | 7610 | .src_constraints = .{ .{ .scalar_int = .dword }, .{ .scalar_int = .dword } }, |
| 4324 | .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword } }, | | |
| 4325 | .patterns = &.{ | 7611 | .patterns = &.{ |
| 4326 | .{ .src = .{ .to_mem, .to_mem } }, | 7612 | .{ .src = .{ .to_mem, .to_mem } }, |
| 4327 | }, | 7613 | }, |
| 4328 | .extra_temps = .{ | 7614 | .extra_temps = .{ |
| 4329 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 7615 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4330 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 7616 | .{ .type = .u32, .kind = .{ .reg = .rcx } }, |
| 4331 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 7617 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 4332 | .unused, | 7618 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 4333 | .unused, | 7619 | .{ .kind = .{ .rc = .sse } }, |
| 4334 | .unused, | 7620 | .unused, |
| 4335 | }, | 7621 | }, |
| 4336 | .dst_temps = .{.{ .rc = .general_purpose }}, | 7622 | .dst_temps = .{.mem}, |
| 4337 | .each = .{ .once = &.{ | 7623 | .clobbers = .{ .eflags = true }, |
| 4338 | .{ ._, ._, .xor, .dst0b, .dst0b, ._, ._ }, | 7624 | .each = .{ .once = switch (cc) { |
| 4339 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 7625 | else => unreachable, |
| 4340 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | 7626 | .e => &.{ |
| 4341 | .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, | 7627 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4342 | .{ ._, ._, .cmp, .tmp2q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, | 7628 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 4343 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 7629 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, |
| 4344 | .{ ._, ._l, .sh, .tmp2b, .tmp1b, ._, ._ }, | 7630 | .{ .@"0:", ._dqu, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 4345 | .{ ._, ._, .@"or", .dst0b, .tmp2b, ._, ._ }, | 7631 | .{ ._, .p_d, .cmpeq, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 4346 | .{ ._, ._, .add, .tmp1b, .i(1), ._, ._ }, | 7632 | .{ ._, ._ps, .movmsk, .tmp3d, .tmp4x, ._, ._ }, |
| 4347 | .{ ._, ._, .add, .tmp0p, .i(2), ._, ._ }, | 7633 | .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ }, |
| 4348 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 7634 | .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ }, |
| | 7635 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 4), ._, ._ }, |
| | 7636 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| | 7637 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| | 7638 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| | 7639 | .{ ._, ._r, .sh, .tmp3d, .si(3), ._, ._ }, |
| | 7640 | .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ }, |
| | 7641 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, |
| | 7642 | .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 7643 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 7644 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| | 7645 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| | 7646 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| | 7647 | .{ ._, ._r, .sh, .tmp3d, .si(3), ._, ._ }, |
| | 7648 | .{ ._, ._, .mov, .memi(.dst0b, .tmp3), .tmp2b, ._, ._ }, |
| | 7649 | }, |
| | 7650 | .ne => &.{ |
| | 7651 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| | 7652 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| | 7653 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, |
| | 7654 | .{ .@"0:", ._dqu, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| | 7655 | .{ ._, .p_d, .cmpeq, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| | 7656 | .{ ._, ._ps, .movmsk, .tmp3d, .tmp4x, ._, ._ }, |
| | 7657 | .{ ._, ._, .xor, .tmp3b, .si(0b1111), ._, ._ }, |
| | 7658 | .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ }, |
| | 7659 | .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ }, |
| | 7660 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 4), ._, ._ }, |
| | 7661 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| | 7662 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| | 7663 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| | 7664 | .{ ._, ._r, .sh, .tmp3d, .si(3), ._, ._ }, |
| | 7665 | .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ }, |
| | 7666 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, |
| | 7667 | .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 7668 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 7669 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| | 7670 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| | 7671 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| | 7672 | .{ ._, ._r, .sh, .tmp3d, .si(3), ._, ._ }, |
| | 7673 | .{ ._, ._, .mov, .memi(.dst0b, .tmp3), .tmp2b, ._, ._ }, |
| | 7674 | }, |
| 4349 | } }, | 7675 | } }, |
| 4350 | }, .{ | 7676 | }, .{ |
| 4351 | .required_features = .{ .@"64bit", null }, | 7677 | .required_features = .{ .sse4_1, null, null, null }, |
| 4352 | .dst_constraints = .{.{ .bool_vec = .byte }}, | 7678 | .src_constraints = .{ .{ .scalar_int = .qword }, .{ .scalar_int = .qword } }, |
| 4353 | .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword } }, | | |
| 4354 | .patterns = &.{ | 7679 | .patterns = &.{ |
| 4355 | .{ .src = .{ .to_mem, .to_mem } }, | 7680 | .{ .src = .{ .to_mem, .to_mem } }, |
| 4356 | }, | 7681 | }, |
| 4357 | .extra_temps = .{ | 7682 | .extra_temps = .{ |
| 4358 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 7683 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4359 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 7684 | .{ .type = .u32, .kind = .{ .reg = .rcx } }, |
| 4360 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 7685 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 4361 | .unused, | 7686 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 4362 | .unused, | 7687 | .{ .kind = .{ .rc = .sse } }, |
| 4363 | .unused, | | |
| 4364 | }, | | |
| 4365 | .dst_temps = .{.{ .rc = .general_purpose }}, | | |
| 4366 | .each = .{ .once = &.{ | | |
| 4367 | .{ ._, ._, .xor, .dst0b, .dst0b, ._, ._ }, | | |
| 4368 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | | |
| 4369 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | | |
| 4370 | .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, | | |
| 4371 | .{ ._, ._, .cmp, .tmp2q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, | | |
| 4372 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | | |
| 4373 | .{ ._, ._l, .sh, .tmp2b, .tmp1b, ._, ._ }, | | |
| 4374 | .{ ._, ._, .@"or", .dst0b, .tmp2b, ._, ._ }, | | |
| 4375 | .{ ._, ._, .inc, .tmp1b, ._, ._, ._ }, | | |
| 4376 | .{ ._, ._, .add, .tmp0p, .i(2), ._, ._ }, | | |
| 4377 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 4378 | } }, | | |
| 4379 | }, .{ | | |
| 4380 | .required_features = .{ .slow_incdec, null }, | | |
| 4381 | .dst_constraints = .{.{ .bool_vec = .byte }}, | | |
| 4382 | .patterns = &.{ | | |
| 4383 | .{ .src = .{ .to_mem, .to_mem } }, | | |
| 4384 | }, | | |
| 4385 | .extra_temps = .{ | | |
| 4386 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | | |
| 4387 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | | |
| 4388 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | | |
| 4389 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | | |
| 4390 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | | |
| 4391 | .unused, | | |
| 4392 | }, | | |
| 4393 | .dst_temps = .{.{ .rc = .general_purpose }}, | | |
| 4394 | .each = .{ .once = &.{ | | |
| 4395 | .{ ._, ._, .xor, .dst0b, .dst0b, ._, ._ }, | | |
| 4396 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, | | |
| 4397 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | | |
| 4398 | .{ .@"0:", ._, .mov, .tmp2d, .a(.src0p, .add_elem_limbs), ._, ._ }, | | |
| 4399 | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, | | |
| 4400 | .{ .@"1:", ._, .mov, .tmp4p, .memi(.src0p, .tmp0), ._, ._ }, | | |
| 4401 | .{ ._, ._, .xor, .tmp4p, .memi(.src1p, .tmp0), ._, ._ }, | | |
| 4402 | .{ ._, ._, .@"or", .tmp3p, .tmp4p, ._, ._ }, | | |
| 4403 | .{ ._, ._, .add, .tmp0p, .a(.tmp4, .add_size), ._, ._ }, | | |
| 4404 | .{ ._, ._, .sub, .tmp2d, .i(1), ._, ._ }, | | |
| 4405 | .{ ._, ._b, .j, .@"1b", ._, ._, ._ }, | | |
| 4406 | .{ ._, ._, .@"test", .tmp3p, .tmp3p, ._, ._ }, | | |
| 4407 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | | |
| 4408 | .{ ._, ._l, .sh, .tmp2b, .tmp1b, ._, ._ }, | | |
| 4409 | .{ ._, ._, .@"or", .dst0b, .tmp2b, ._, ._ }, | | |
| 4410 | .{ ._, ._, .add, .tmp1b, .i(1), ._, ._ }, | | |
| 4411 | .{ ._, ._, .cmp, .tmp1b, .a(.dst0, .add_len), ._, ._ }, | | |
| 4412 | .{ ._, ._b, .j, .@"0b", ._, ._, ._ }, | | |
| 4413 | } }, | | |
| 4414 | }, .{ | | |
| 4415 | .dst_constraints = .{.{ .bool_vec = .byte }}, | | |
| 4416 | .patterns = &.{ | | |
| 4417 | .{ .src = .{ .to_mem, .to_mem } }, | | |
| 4418 | }, | | |
| 4419 | .extra_temps = .{ | | |
| 4420 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | | |
| 4421 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | | |
| 4422 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | | |
| 4423 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | | |
| 4424 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | | |
| 4425 | .unused, | 7688 | .unused, |
| 4426 | }, | 7689 | }, |
| 4427 | .dst_temps = .{.{ .rc = .general_purpose }}, | 7690 | .dst_temps = .{.mem}, |
| 4428 | .each = .{ .once = &.{ | 7691 | .clobbers = .{ .eflags = true }, |
| 4429 | .{ ._, ._, .xor, .dst0b, .dst0b, ._, ._ }, | 7692 | .each = .{ .once = switch (cc) { |
| 4430 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, | 7693 | else => unreachable, |
| 4431 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | 7694 | .e => &.{ |
| 4432 | .{ .@"0:", ._, .mov, .tmp2d, .a(.src0p, .add_elem_limbs), ._, ._ }, | 7695 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4433 | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, | 7696 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 4434 | .{ .@"1:", ._, .mov, .tmp4p, .memi(.src0p, .tmp0), ._, ._ }, | 7697 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, |
| 4435 | .{ ._, ._, .xor, .tmp4p, .memi(.src1p, .tmp0), ._, ._ }, | 7698 | .{ .@"0:", ._dqu, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 4436 | .{ ._, ._, .@"or", .tmp3p, .tmp4p, ._, ._ }, | 7699 | .{ ._, .p_q, .cmpeq, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 4437 | .{ ._, ._, .add, .tmp0p, .a(.tmp4, .add_size), ._, ._ }, | 7700 | .{ ._, ._pd, .movmsk, .tmp3d, .tmp4x, ._, ._ }, |
| 4438 | .{ ._, ._, .dec, .tmp2d, ._, ._, ._ }, | 7701 | .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ }, |
| 4439 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, | 7702 | .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ }, |
| 4440 | .{ ._, ._, .@"test", .tmp3p, .tmp3p, ._, ._ }, | 7703 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 2), ._, ._ }, |
| 4441 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 7704 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| 4442 | .{ ._, ._l, .sh, .tmp2b, .tmp1b, ._, ._ }, | 7705 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 4443 | .{ ._, ._, .@"or", .dst0b, .tmp2b, ._, ._ }, | 7706 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| 4444 | .{ ._, ._, .inc, .tmp1b, ._, ._, ._ }, | 7707 | .{ ._, ._r, .sh, .tmp3d, .si(3), ._, ._ }, |
| 4445 | .{ ._, ._, .cmp, .tmp1b, .a(.dst0, .add_len), ._, ._ }, | 7708 | .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ }, |
| 4446 | .{ ._, ._b, .j, .@"0b", ._, ._, ._ }, | 7709 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, |
| | 7710 | .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 7711 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 7712 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| | 7713 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| | 7714 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| | 7715 | .{ ._, ._r, .sh, .tmp3d, .si(3), ._, ._ }, |
| | 7716 | .{ ._, ._, .mov, .memi(.dst0b, .tmp3), .tmp2b, ._, ._ }, |
| | 7717 | }, |
| | 7718 | .ne => &.{ |
| | 7719 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| | 7720 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| | 7721 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, |
| | 7722 | .{ .@"0:", ._dqu, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| | 7723 | .{ ._, .p_q, .cmpeq, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| | 7724 | .{ ._, ._pd, .movmsk, .tmp3d, .tmp4x, ._, ._ }, |
| | 7725 | .{ ._, ._, .xor, .tmp3b, .si(0b11), ._, ._ }, |
| | 7726 | .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ }, |
| | 7727 | .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ }, |
| | 7728 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 2), ._, ._ }, |
| | 7729 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| | 7730 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| | 7731 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| | 7732 | .{ ._, ._r, .sh, .tmp3d, .si(3), ._, ._ }, |
| | 7733 | .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ }, |
| | 7734 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, |
| | 7735 | .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 7736 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 7737 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| | 7738 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| | 7739 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| | 7740 | .{ ._, ._r, .sh, .tmp3d, .si(3), ._, ._ }, |
| | 7741 | .{ ._, ._, .mov, .memi(.dst0b, .tmp3), .tmp2b, ._, ._ }, |
| | 7742 | }, |
| 4447 | } }, | 7743 | } }, |
| 4448 | }, .{ | 7744 | }, .{ |
| 4449 | .required_features = .{ .slow_incdec, null }, | 7745 | .required_features = .{ .sse, .mmx, null, null }, |
| 4450 | .dst_constraints = .{.{ .bool_vec = .dword }}, | 7746 | .src_constraints = .{ .{ .scalar_int = .byte }, .{ .scalar_int = .byte } }, |
| 4451 | .src_constraints = .{ .{ .int = .byte }, .{ .int = .byte } }, | | |
| 4452 | .patterns = &.{ | 7747 | .patterns = &.{ |
| 4453 | .{ .src = .{ .to_mem, .to_mem } }, | 7748 | .{ .src = .{ .to_mem, .to_mem } }, |
| 4454 | }, | 7749 | }, |
| 4455 | .extra_temps = .{ | 7750 | .extra_temps = .{ |
| 4456 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 7751 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4457 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | | |
| 4458 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 7752 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 4459 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 7753 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 7754 | .{ .kind = .{ .rc = .mmx } }, |
| 4460 | .unused, | 7755 | .unused, |
| 4461 | .unused, | 7756 | .unused, |
| 4462 | }, | 7757 | }, |
| 4463 | .dst_temps = .{.{ .rc = .general_purpose }}, | 7758 | .dst_temps = .{.mem}, |
| 4464 | .each = .{ .once = &.{ | 7759 | .clobbers = .{ .eflags = true }, |
| 4465 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, | 7760 | .each = .{ .once = switch (cc) { |
| 4466 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 7761 | else => unreachable, |
| 4467 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | 7762 | .e => &.{ |
| 4468 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | 7763 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4469 | .{ ._, ._, .mov, .tmp3b, .memia(.src0b, .tmp0, .add_size), ._, ._ }, | 7764 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 4470 | .{ ._, ._, .cmp, .tmp3b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, | 7765 | .{ .@"0:", ._q, .mov, .tmp3q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 4471 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 7766 | .{ ._, .p_b, .cmpeq, .tmp3q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 4472 | .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, | 7767 | .{ ._, .p_b, .movmsk, .tmp2d, .tmp3q, ._, ._ }, |
| 4473 | .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, | 7768 | .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ }, |
| 4474 | .{ ._, ._, .add, .tmp1b, .i(1), ._, ._ }, | 7769 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 1), ._, ._ }, |
| 4475 | .{ ._, ._, .add, .tmp0p, .i(1), ._, ._ }, | 7770 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 4476 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 7771 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 7772 | }, |
| | 7773 | .ne => &.{ |
| | 7774 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| | 7775 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| | 7776 | .{ .@"0:", ._q, .mov, .tmp3q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| | 7777 | .{ ._, .p_b, .cmpeq, .tmp3q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| | 7778 | .{ ._, .p_b, .movmsk, .tmp2d, .tmp3q, ._, ._ }, |
| | 7779 | .{ ._, ._, .not, .tmp2b, ._, ._, ._ }, |
| | 7780 | .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ }, |
| | 7781 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 1), ._, ._ }, |
| | 7782 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 7783 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 7784 | }, |
| 4477 | } }, | 7785 | } }, |
| 4478 | }, .{ | 7786 | }, .{ |
| 4479 | .dst_constraints = .{.{ .bool_vec = .dword }}, | 7787 | .required_features = .{ .sse, .mmx, null, null }, |
| 4480 | .src_constraints = .{ .{ .int = .byte }, .{ .int = .byte } }, | 7788 | .src_constraints = .{ .{ .scalar_int = .word }, .{ .scalar_int = .word } }, |
| 4481 | .patterns = &.{ | 7789 | .patterns = &.{ |
| 4482 | .{ .src = .{ .to_mem, .to_mem } }, | 7790 | .{ .src = .{ .to_mem, .to_mem } }, |
| 4483 | }, | 7791 | }, |
| 4484 | .extra_temps = .{ | 7792 | .extra_temps = .{ |
| 4485 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 7793 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4486 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | | |
| 4487 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 7794 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 4488 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 7795 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 4489 | .unused, | 7796 | .{ .kind = .{ .rc = .mmx } }, |
| 4490 | .unused, | 7797 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 7798 | .{ .kind = .{ .rc = .mmx } }, |
| 4491 | }, | 7799 | }, |
| 4492 | .dst_temps = .{.{ .rc = .general_purpose }}, | 7800 | .dst_temps = .{.mem}, |
| 4493 | .each = .{ .once = &.{ | 7801 | .clobbers = .{ .eflags = true }, |
| 4494 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, | 7802 | .each = .{ .once = switch (cc) { |
| 4495 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 7803 | else => unreachable, |
| 4496 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | 7804 | .e => &.{ |
| 4497 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | 7805 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4498 | .{ ._, ._, .mov, .tmp3b, .memia(.src0b, .tmp0, .add_size), ._, ._ }, | 7806 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 4499 | .{ ._, ._, .cmp, .tmp3b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, | 7807 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, |
| 4500 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 7808 | .{ ._, .p_, .xor, .tmp3q, .tmp3q, ._, ._ }, |
| 4501 | .{ ._, ._l, .sh, .tmp2d, .tmp1d, ._, ._ }, | 7809 | .{ .@"0:", ._q, .mov, .tmp5q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 4502 | .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, | 7810 | .{ ._, .p_w, .cmpeq, .tmp5q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 4503 | .{ ._, ._, .inc, .tmp1b, ._, ._, ._ }, | 7811 | .{ ._, .p_b, .ackssw, .tmp5q, .tmp3q, ._, ._ }, |
| 4504 | .{ ._, ._, .inc, .tmp0p, ._, ._, ._ }, | 7812 | .{ ._, .p_b, .movmsk, .tmp4d, .tmp5q, ._, ._ }, |
| 4505 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 7813 | .{ ._, ._l, .ro, .tmp4b, .tmp1b, ._, ._ }, |
| | 7814 | .{ ._, ._, .@"or", .tmp2b, .tmp4b, ._, ._ }, |
| | 7815 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 4), ._, ._ }, |
| | 7816 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| | 7817 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| | 7818 | .{ ._, ._, .mov, .tmp4d, .tmp1d, ._, ._ }, |
| | 7819 | .{ ._, ._r, .sh, .tmp4d, .si(3), ._, ._ }, |
| | 7820 | .{ ._, ._, .mov, .memid(.dst0b, .tmp4, -1), .tmp2b, ._, ._ }, |
| | 7821 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, |
| | 7822 | .{ .@"1:", ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 7823 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 7824 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| | 7825 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| | 7826 | .{ ._, ._, .mov, .tmp4d, .tmp1d, ._, ._ }, |
| | 7827 | .{ ._, ._r, .sh, .tmp4d, .si(3), ._, ._ }, |
| | 7828 | .{ ._, ._, .mov, .memi(.dst0b, .tmp4), .tmp2b, ._, ._ }, |
| | 7829 | }, |
| | 7830 | .ne => &.{ |
| | 7831 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| | 7832 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| | 7833 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, |
| | 7834 | .{ ._, .p_, .xor, .tmp3q, .tmp3q, ._, ._ }, |
| | 7835 | .{ .@"0:", ._q, .mov, .tmp5q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| | 7836 | .{ ._, .p_w, .cmpeq, .tmp5q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| | 7837 | .{ ._, .p_b, .ackssw, .tmp5q, .tmp3q, ._, ._ }, |
| | 7838 | .{ ._, .p_b, .movmsk, .tmp4d, .tmp5q, ._, ._ }, |
| | 7839 | .{ ._, ._, .xor, .tmp4b, .si(0b1111), ._, ._ }, |
| | 7840 | .{ ._, ._l, .ro, .tmp4b, .tmp1b, ._, ._ }, |
| | 7841 | .{ ._, ._, .@"or", .tmp2b, .tmp4b, ._, ._ }, |
| | 7842 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 4), ._, ._ }, |
| | 7843 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| | 7844 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| | 7845 | .{ ._, ._, .mov, .tmp4d, .tmp1d, ._, ._ }, |
| | 7846 | .{ ._, ._r, .sh, .tmp4d, .si(3), ._, ._ }, |
| | 7847 | .{ ._, ._, .mov, .memid(.dst0b, .tmp4, -1), .tmp2b, ._, ._ }, |
| | 7848 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, |
| | 7849 | .{ .@"1:", ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 7850 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 7851 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| | 7852 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| | 7853 | .{ ._, ._, .mov, .tmp4d, .tmp1d, ._, ._ }, |
| | 7854 | .{ ._, ._r, .sh, .tmp4d, .si(3), ._, ._ }, |
| | 7855 | .{ ._, ._, .mov, .memi(.dst0b, .tmp4), .tmp2b, ._, ._ }, |
| | 7856 | }, |
| 4506 | } }, | 7857 | } }, |
| 4507 | }, .{ | 7858 | }, .{ |
| 4508 | .required_features = .{ .slow_incdec, null }, | 7859 | .required_features = .{ .sse, .mmx, null, null }, |
| 4509 | .dst_constraints = .{.{ .bool_vec = .dword }}, | 7860 | .src_constraints = .{ .{ .scalar_int = .dword }, .{ .scalar_int = .dword } }, |
| 4510 | .src_constraints = .{ .{ .int = .word }, .{ .int = .word } }, | | |
| 4511 | .patterns = &.{ | 7861 | .patterns = &.{ |
| 4512 | .{ .src = .{ .to_mem, .to_mem } }, | 7862 | .{ .src = .{ .to_mem, .to_mem } }, |
| 4513 | }, | 7863 | }, |
| 4514 | .extra_temps = .{ | 7864 | .extra_temps = .{ |
| 4515 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 7865 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4516 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 7866 | .{ .type = .u32, .kind = .{ .reg = .rcx } }, |
| 4517 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 7867 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 4518 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, | 7868 | .{ .kind = .{ .rc = .mmx } }, |
| 4519 | .unused, | 7869 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 4520 | .unused, | 7870 | .{ .kind = .{ .rc = .mmx } }, |
| 4521 | }, | 7871 | }, |
| 4522 | .dst_temps = .{.{ .rc = .general_purpose }}, | 7872 | .dst_temps = .{.mem}, |
| 4523 | .each = .{ .once = &.{ | 7873 | .clobbers = .{ .eflags = true }, |
| 4524 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, | 7874 | .each = .{ .once = switch (cc) { |
| 4525 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 7875 | else => unreachable, |
| 4526 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | 7876 | .e => &.{ |
| 4527 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | 7877 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4528 | .{ ._, ._, .mov, .tmp3w, .memia(.src0w, .tmp0, .add_size), ._, ._ }, | 7878 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 4529 | .{ ._, ._, .cmp, .tmp3w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, | 7879 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, |
| 4530 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 7880 | .{ ._, .p_, .xor, .tmp3q, .tmp3q, ._, ._ }, |
| 4531 | .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, | 7881 | .{ .@"0:", ._q, .mov, .tmp5q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 4532 | .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, | 7882 | .{ ._, .p_d, .cmpeq, .tmp5q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 4533 | .{ ._, ._, .add, .tmp1b, .i(1), ._, ._ }, | 7883 | .{ ._, .p_w, .ackssd, .tmp5q, .tmp3q, ._, ._ }, |
| 4534 | .{ ._, ._, .add, .tmp0p, .i(2), ._, ._ }, | 7884 | .{ ._, .p_b, .ackssw, .tmp5q, .tmp3q, ._, ._ }, |
| 4535 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 7885 | .{ ._, .p_b, .movmsk, .tmp4d, .tmp5q, ._, ._ }, |
| | 7886 | .{ ._, ._l, .ro, .tmp4b, .tmp1b, ._, ._ }, |
| | 7887 | .{ ._, ._, .@"or", .tmp2b, .tmp4b, ._, ._ }, |
| | 7888 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 2), ._, ._ }, |
| | 7889 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| | 7890 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| | 7891 | .{ ._, ._, .mov, .tmp4d, .tmp1d, ._, ._ }, |
| | 7892 | .{ ._, ._r, .sh, .tmp4d, .si(3), ._, ._ }, |
| | 7893 | .{ ._, ._, .mov, .memid(.dst0b, .tmp4, -1), .tmp2b, ._, ._ }, |
| | 7894 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, |
| | 7895 | .{ .@"1:", ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 7896 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 7897 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| | 7898 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| | 7899 | .{ ._, ._, .mov, .tmp4d, .tmp1d, ._, ._ }, |
| | 7900 | .{ ._, ._r, .sh, .tmp4d, .si(3), ._, ._ }, |
| | 7901 | .{ ._, ._, .mov, .memi(.dst0b, .tmp4), .tmp2b, ._, ._ }, |
| | 7902 | }, |
| | 7903 | .ne => &.{ |
| | 7904 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| | 7905 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| | 7906 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, |
| | 7907 | .{ ._, .p_, .xor, .tmp3q, .tmp3q, ._, ._ }, |
| | 7908 | .{ .@"0:", ._q, .mov, .tmp5q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| | 7909 | .{ ._, .p_d, .cmpeq, .tmp5q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| | 7910 | .{ ._, .p_w, .ackssd, .tmp5q, .tmp3q, ._, ._ }, |
| | 7911 | .{ ._, .p_b, .ackssw, .tmp5q, .tmp3q, ._, ._ }, |
| | 7912 | .{ ._, .p_b, .movmsk, .tmp4d, .tmp5q, ._, ._ }, |
| | 7913 | .{ ._, ._, .xor, .tmp4b, .si(0b11), ._, ._ }, |
| | 7914 | .{ ._, ._l, .ro, .tmp4b, .tmp1b, ._, ._ }, |
| | 7915 | .{ ._, ._, .@"or", .tmp2b, .tmp4b, ._, ._ }, |
| | 7916 | .{ ._, ._, .lea, .tmp1d, .lead(.none, .tmp1, 2), ._, ._ }, |
| | 7917 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| | 7918 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| | 7919 | .{ ._, ._, .mov, .tmp4d, .tmp1d, ._, ._ }, |
| | 7920 | .{ ._, ._r, .sh, .tmp4d, .si(3), ._, ._ }, |
| | 7921 | .{ ._, ._, .mov, .memid(.dst0b, .tmp4, -1), .tmp2b, ._, ._ }, |
| | 7922 | .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ }, |
| | 7923 | .{ .@"1:", ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 7924 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 7925 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| | 7926 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| | 7927 | .{ ._, ._, .mov, .tmp4d, .tmp1d, ._, ._ }, |
| | 7928 | .{ ._, ._r, .sh, .tmp4d, .si(3), ._, ._ }, |
| | 7929 | .{ ._, ._, .mov, .memi(.dst0b, .tmp4), .tmp2b, ._, ._ }, |
| | 7930 | }, |
| 4536 | } }, | 7931 | } }, |
| 4537 | }, .{ | 7932 | }, .{ |
| 4538 | .dst_constraints = .{.{ .bool_vec = .dword }}, | 7933 | .dst_constraints = .{.{ .bool_vec = .byte }}, |
| 4539 | .src_constraints = .{ .{ .int = .word }, .{ .int = .word } }, | 7934 | .src_constraints = .{ .{ .scalar_int = .byte }, .{ .scalar_int = .byte } }, |
| 4540 | .patterns = &.{ | 7935 | .patterns = &.{ |
| 4541 | .{ .src = .{ .to_mem, .to_mem } }, | 7936 | .{ .src = .{ .to_mem, .to_mem } }, |
| 4542 | }, | 7937 | }, |
| 4543 | .extra_temps = .{ | 7938 | .extra_temps = .{ |
| 4544 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 7939 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4545 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 7940 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 4546 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 7941 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 4547 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, | | |
| 4548 | .unused, | | |
| 4549 | .unused, | 7942 | .unused, |
| 4550 | }, | | |
| 4551 | .dst_temps = .{.{ .rc = .general_purpose }}, | | |
| 4552 | .each = .{ .once = &.{ | | |
| 4553 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, | | |
| 4554 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | | |
| 4555 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | | |
| 4556 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | | |
| 4557 | .{ ._, ._, .mov, .tmp3w, .memia(.src0w, .tmp0, .add_size), ._, ._ }, | | |
| 4558 | .{ ._, ._, .cmp, .tmp3w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, | | |
| 4559 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | | |
| 4560 | .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, | | |
| 4561 | .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, | | |
| 4562 | .{ ._, ._, .inc, .tmp1b, ._, ._, ._ }, | | |
| 4563 | .{ ._, ._, .add, .tmp0p, .i(2), ._, ._ }, | | |
| 4564 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 4565 | } }, | | |
| 4566 | }, .{ | | |
| 4567 | .required_features = .{ .slow_incdec, null }, | | |
| 4568 | .dst_constraints = .{.{ .bool_vec = .dword }}, | | |
| 4569 | .src_constraints = .{ .{ .int = .dword }, .{ .int = .dword } }, | | |
| 4570 | .patterns = &.{ | | |
| 4571 | .{ .src = .{ .to_mem, .to_mem } }, | | |
| 4572 | }, | | |
| 4573 | .extra_temps = .{ | | |
| 4574 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | | |
| 4575 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | | |
| 4576 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | | |
| 4577 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | | |
| 4578 | .unused, | 7943 | .unused, |
| 4579 | .unused, | 7944 | .unused, |
| 4580 | }, | 7945 | }, |
| 4581 | .dst_temps = .{.{ .rc = .general_purpose }}, | 7946 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 7947 | .clobbers = .{ .eflags = true }, |
| 4582 | .each = .{ .once = &.{ | 7948 | .each = .{ .once = &.{ |
| 4583 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, | 7949 | .{ ._, ._, .xor, .dst0b, .dst0b, ._, ._ }, |
| 4584 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 7950 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4585 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | 7951 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, |
| 4586 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | 7952 | .{ .@"0:", ._, .mov, .tmp2b, .memia(.src0b, .tmp0, .add_size), ._, ._ }, |
| 4587 | .{ ._, ._, .mov, .tmp3d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, | 7953 | .{ ._, ._, .cmp, .tmp2b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, |
| 4588 | .{ ._, ._, .cmp, .tmp3d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, | | |
| 4589 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 7954 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, |
| 4590 | .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, | 7955 | .{ ._, ._l, .sh, .tmp2b, .tmp1b, ._, ._ }, |
| 4591 | .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, | 7956 | .{ ._, ._, .@"or", .dst0b, .tmp2b, ._, ._ }, |
| 4592 | .{ ._, ._, .add, .tmp1b, .i(1), ._, ._ }, | 7957 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, |
| 4593 | .{ ._, ._, .add, .tmp0p, .i(4), ._, ._ }, | 7958 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 4594 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 7959 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4595 | } }, | 7960 | } }, |
| 4596 | }, .{ | 7961 | }, .{ |
| 4597 | .dst_constraints = .{.{ .bool_vec = .dword }}, | 7962 | .dst_constraints = .{.{ .bool_vec = .byte }}, |
| 4598 | .src_constraints = .{ .{ .int = .dword }, .{ .int = .dword } }, | 7963 | .src_constraints = .{ .{ .scalar_int = .word }, .{ .scalar_int = .word } }, |
| 4599 | .patterns = &.{ | 7964 | .patterns = &.{ |
| 4600 | .{ .src = .{ .to_mem, .to_mem } }, | 7965 | .{ .src = .{ .to_mem, .to_mem } }, |
| 4601 | }, | 7966 | }, |
| 4602 | .extra_temps = .{ | 7967 | .extra_temps = .{ |
| 4603 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 7968 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4604 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 7969 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 4605 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 7970 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 4606 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | | |
| 4607 | .unused, | | |
| 4608 | .unused, | 7971 | .unused, |
| 4609 | }, | | |
| 4610 | .dst_temps = .{.{ .rc = .general_purpose }}, | | |
| 4611 | .each = .{ .once = &.{ | | |
| 4612 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, | | |
| 4613 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | | |
| 4614 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | | |
| 4615 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | | |
| 4616 | .{ ._, ._, .mov, .tmp3d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, | | |
| 4617 | .{ ._, ._, .cmp, .tmp3d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, | | |
| 4618 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | | |
| 4619 | .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, | | |
| 4620 | .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, | | |
| 4621 | .{ ._, ._, .inc, .tmp1b, ._, ._, ._ }, | | |
| 4622 | .{ ._, ._, .add, .tmp0p, .i(4), ._, ._ }, | | |
| 4623 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 4624 | } }, | | |
| 4625 | }, .{ | | |
| 4626 | .required_features = .{ .@"64bit", .slow_incdec }, | | |
| 4627 | .dst_constraints = .{.{ .bool_vec = .dword }}, | | |
| 4628 | .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword } }, | | |
| 4629 | .patterns = &.{ | | |
| 4630 | .{ .src = .{ .to_mem, .to_mem } }, | | |
| 4631 | }, | | |
| 4632 | .extra_temps = .{ | | |
| 4633 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | | |
| 4634 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | | |
| 4635 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | | |
| 4636 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | | |
| 4637 | .unused, | 7972 | .unused, |
| 4638 | .unused, | 7973 | .unused, |
| 4639 | }, | 7974 | }, |
| 4640 | .dst_temps = .{.{ .rc = .general_purpose }}, | 7975 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 7976 | .clobbers = .{ .eflags = true }, |
| 4641 | .each = .{ .once = &.{ | 7977 | .each = .{ .once = &.{ |
| 4642 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, | 7978 | .{ ._, ._, .xor, .dst0b, .dst0b, ._, ._ }, |
| 4643 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 7979 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4644 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | 7980 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, |
| 4645 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | 7981 | .{ .@"0:", ._, .mov, .tmp2w, .memia(.src0w, .tmp0, .add_size), ._, ._ }, |
| 4646 | .{ ._, ._, .mov, .tmp3q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, | 7982 | .{ ._, ._, .cmp, .tmp2w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, |
| 4647 | .{ ._, ._, .cmp, .tmp3q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, | | |
| 4648 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 7983 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, |
| 4649 | .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, | 7984 | .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, |
| 4650 | .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, | 7985 | .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, |
| 4651 | .{ ._, ._, .add, .tmp1b, .i(1), ._, ._ }, | 7986 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, |
| 4652 | .{ ._, ._, .add, .tmp0p, .i(2), ._, ._ }, | 7987 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 4653 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 7988 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4654 | } }, | 7989 | } }, |
| 4655 | }, .{ | 7990 | }, .{ |
| 4656 | .required_features = .{ .@"64bit", null }, | 7991 | .dst_constraints = .{.{ .bool_vec = .byte }}, |
| 4657 | .dst_constraints = .{.{ .bool_vec = .dword }}, | 7992 | .src_constraints = .{ .{ .scalar_int = .dword }, .{ .scalar_int = .dword } }, |
| 4658 | .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword } }, | | |
| 4659 | .patterns = &.{ | 7993 | .patterns = &.{ |
| 4660 | .{ .src = .{ .to_mem, .to_mem } }, | 7994 | .{ .src = .{ .to_mem, .to_mem } }, |
| 4661 | }, | 7995 | }, |
| ... | @@ -4663,249 +7997,251 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4663,249 +7997,251 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4663 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 7997 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4664 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 7998 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 4665 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 7999 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 4666 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 8000 | .unused, |
| 4667 | .unused, | 8001 | .unused, |
| 4668 | .unused, | 8002 | .unused, |
| 4669 | }, | 8003 | }, |
| 4670 | .dst_temps = .{.{ .rc = .general_purpose }}, | 8004 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 8005 | .clobbers = .{ .eflags = true }, |
| 4671 | .each = .{ .once = &.{ | 8006 | .each = .{ .once = &.{ |
| 4672 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, | 8007 | .{ ._, ._, .xor, .dst0b, .dst0b, ._, ._ }, |
| 4673 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 8008 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4674 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | 8009 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, |
| 4675 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | 8010 | .{ .@"0:", ._, .mov, .tmp2d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, |
| 4676 | .{ ._, ._, .mov, .tmp3q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, | 8011 | .{ ._, ._, .cmp, .tmp2d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, |
| 4677 | .{ ._, ._, .cmp, .tmp3q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, | | |
| 4678 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 8012 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, |
| 4679 | .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, | 8013 | .{ ._, ._l, .sh, .tmp2b, .tmp1b, ._, ._ }, |
| 4680 | .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, | 8014 | .{ ._, ._, .@"or", .dst0b, .tmp2b, ._, ._ }, |
| 4681 | .{ ._, ._, .inc, .tmp1b, ._, ._, ._ }, | 8015 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, |
| 4682 | .{ ._, ._, .add, .tmp0p, .i(2), ._, ._ }, | 8016 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 4683 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 8017 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4684 | } }, | 8018 | } }, |
| 4685 | }, .{ | 8019 | }, .{ |
| 4686 | .required_features = .{ .slow_incdec, null }, | 8020 | .required_features = .{ .@"64bit", null, null, null }, |
| 4687 | .dst_constraints = .{.{ .bool_vec = .dword }}, | 8021 | .dst_constraints = .{.{ .bool_vec = .byte }}, |
| | 8022 | .src_constraints = .{ .{ .scalar_int = .qword }, .{ .scalar_int = .qword } }, |
| 4688 | .patterns = &.{ | 8023 | .patterns = &.{ |
| 4689 | .{ .src = .{ .to_mem, .to_mem } }, | 8024 | .{ .src = .{ .to_mem, .to_mem } }, |
| 4690 | }, | 8025 | }, |
| 4691 | .extra_temps = .{ | 8026 | .extra_temps = .{ |
| 4692 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 8027 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4693 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 8028 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 4694 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 8029 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 4695 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 8030 | .unused, |
| 4696 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 8031 | .unused, |
| 4697 | .unused, | 8032 | .unused, |
| 4698 | }, | 8033 | }, |
| 4699 | .dst_temps = .{.{ .rc = .general_purpose }}, | 8034 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 8035 | .clobbers = .{ .eflags = true }, |
| 4700 | .each = .{ .once = &.{ | 8036 | .each = .{ .once = &.{ |
| 4701 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, | 8037 | .{ ._, ._, .xor, .dst0b, .dst0b, ._, ._ }, |
| 4702 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, | 8038 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4703 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | 8039 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, |
| 4704 | .{ .@"0:", ._, .mov, .tmp2d, .a(.src0p, .add_elem_limbs), ._, ._ }, | 8040 | .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 4705 | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, | 8041 | .{ ._, ._, .cmp, .tmp2q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 4706 | .{ .@"1:", ._, .mov, .tmp4p, .memi(.src0p, .tmp0), ._, ._ }, | | |
| 4707 | .{ ._, ._, .xor, .tmp4p, .memi(.src1p, .tmp0), ._, ._ }, | | |
| 4708 | .{ ._, ._, .@"or", .tmp3p, .tmp4p, ._, ._ }, | | |
| 4709 | .{ ._, ._, .add, .tmp0p, .a(.tmp4, .add_size), ._, ._ }, | | |
| 4710 | .{ ._, ._, .sub, .tmp2d, .i(1), ._, ._ }, | | |
| 4711 | .{ ._, ._b, .j, .@"1b", ._, ._, ._ }, | | |
| 4712 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | | |
| 4713 | .{ ._, ._, .@"test", .tmp3p, .tmp3p, ._, ._ }, | | |
| 4714 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 8042 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, |
| 4715 | .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, | 8043 | .{ ._, ._l, .sh, .tmp2b, .tmp1b, ._, ._ }, |
| 4716 | .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, | 8044 | .{ ._, ._, .@"or", .dst0b, .tmp2b, ._, ._ }, |
| 4717 | .{ ._, ._, .add, .tmp1b, .i(1), ._, ._ }, | 8045 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, |
| 4718 | .{ ._, ._, .cmp, .tmp1b, .a(.dst0, .add_len), ._, ._ }, | 8046 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 4719 | .{ ._, ._b, .j, .@"0b", ._, ._, ._ }, | 8047 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4720 | } }, | 8048 | } }, |
| 4721 | }, .{ | 8049 | }, .{ |
| 4722 | .dst_constraints = .{.{ .bool_vec = .dword }}, | 8050 | .dst_constraints = .{.{ .bool_vec = .byte }}, |
| 4723 | .patterns = &.{ | 8051 | .patterns = &.{ |
| 4724 | .{ .src = .{ .to_mem, .to_mem } }, | 8052 | .{ .src = .{ .to_mem, .to_mem } }, |
| 4725 | }, | 8053 | }, |
| 4726 | .extra_temps = .{ | 8054 | .extra_temps = .{ |
| 4727 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 8055 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 4728 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 8056 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 4729 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 8057 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 4730 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 8058 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 4731 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 8059 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 4732 | .unused, | 8060 | .unused, |
| 4733 | }, | 8061 | }, |
| 4734 | .dst_temps = .{.{ .rc = .general_purpose }}, | 8062 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 8063 | .clobbers = .{ .eflags = true }, |
| 4735 | .each = .{ .once = &.{ | 8064 | .each = .{ .once = &.{ |
| 4736 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, | 8065 | .{ ._, ._, .xor, .dst0b, .dst0b, ._, ._ }, |
| 4737 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, | 8066 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 4738 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | 8067 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, |
| 4739 | .{ .@"0:", ._, .mov, .tmp2d, .a(.src0p, .add_elem_limbs), ._, ._ }, | 8068 | .{ .@"0:", ._, .mov, .tmp2d, .sa(.src0p, .add_elem_limbs), ._, ._ }, |
| 4740 | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, | 8069 | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, |
| 4741 | .{ .@"1:", ._, .mov, .tmp4p, .memi(.src0p, .tmp0), ._, ._ }, | 8070 | .{ .@"1:", ._, .mov, .tmp4p, .memi(.src0p, .tmp0), ._, ._ }, |
| 4742 | .{ ._, ._, .xor, .tmp4p, .memi(.src1p, .tmp0), ._, ._ }, | 8071 | .{ ._, ._, .xor, .tmp4p, .memi(.src1p, .tmp0), ._, ._ }, |
| 4743 | .{ ._, ._, .@"or", .tmp3p, .tmp4p, ._, ._ }, | 8072 | .{ ._, ._, .@"or", .tmp3p, .tmp4p, ._, ._ }, |
| 4744 | .{ ._, ._, .add, .tmp0p, .a(.tmp4, .add_size), ._, ._ }, | 8073 | .{ ._, ._, .add, .tmp0p, .sa(.tmp4, .add_size), ._, ._ }, |
| 4745 | .{ ._, ._, .dec, .tmp2d, ._, ._, ._ }, | 8074 | .{ ._, ._, .sub, .tmp2d, .si(1), ._, ._ }, |
| 4746 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, | 8075 | .{ ._, ._b, .j, .@"1b", ._, ._, ._ }, |
| 4747 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | | |
| 4748 | .{ ._, ._, .@"test", .tmp3p, .tmp3p, ._, ._ }, | 8076 | .{ ._, ._, .@"test", .tmp3p, .tmp3p, ._, ._ }, |
| 4749 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 8077 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, |
| 4750 | .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, | 8078 | .{ ._, ._l, .sh, .tmp2b, .tmp1b, ._, ._ }, |
| 4751 | .{ ._, ._, .@"or", .dst0d, .tmp2b, ._, ._ }, | 8079 | .{ ._, ._, .@"or", .dst0b, .tmp2b, ._, ._ }, |
| 4752 | .{ ._, ._, .inc, .tmp1b, ._, ._, ._ }, | 8080 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, |
| 4753 | .{ ._, ._, .cmp, .tmp1b, .a(.dst0, .add_len), ._, ._ }, | 8081 | .{ ._, ._, .cmp, .tmp1b, .sa(.dst0, .add_len), ._, ._ }, |
| 4754 | .{ ._, ._b, .j, .@"0b", ._, ._, ._ }, | 8082 | .{ ._, ._b, .j, .@"0b", ._, ._, ._ }, |
| 4755 | } }, | 8083 | } }, |
| 4756 | }, .{ | 8084 | }, .{ |
| 4757 | .required_features = .{ .@"64bit", .slow_incdec }, | 8085 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 4758 | .dst_constraints = .{.{ .bool_vec = .qword }}, | 8086 | .src_constraints = .{ .{ .scalar_int = .byte }, .{ .scalar_int = .byte } }, |
| 4759 | .src_constraints = .{ .{ .int = .byte }, .{ .int = .byte } }, | | |
| 4760 | .patterns = &.{ | 8087 | .patterns = &.{ |
| 4761 | .{ .src = .{ .to_mem, .to_mem } }, | 8088 | .{ .src = .{ .to_mem, .to_mem } }, |
| 4762 | }, | 8089 | }, |
| 4763 | .extra_temps = .{ | 8090 | .extra_temps = .{ |
| 4764 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 8091 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4765 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 8092 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 4766 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 8093 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 4767 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 8094 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 4768 | .unused, | 8095 | .unused, |
| 4769 | .unused, | 8096 | .unused, |
| 4770 | }, | 8097 | }, |
| 4771 | .dst_temps = .{.{ .rc = .general_purpose }}, | 8098 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 8099 | .clobbers = .{ .eflags = true }, |
| 4772 | .each = .{ .once = &.{ | 8100 | .each = .{ .once = &.{ |
| 4773 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, | 8101 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, |
| 4774 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 8102 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4775 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | 8103 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, |
| 4776 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | 8104 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 4777 | .{ ._, ._, .mov, .tmp3b, .memia(.src0b, .tmp0, .add_size), ._, ._ }, | 8105 | .{ ._, ._, .mov, .tmp3b, .memia(.src0b, .tmp0, .add_size), ._, ._ }, |
| 4778 | .{ ._, ._, .cmp, .tmp3b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, | 8106 | .{ ._, ._, .cmp, .tmp3b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, |
| 4779 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 8107 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, |
| 4780 | .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ }, | 8108 | .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, |
| 4781 | .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ }, | 8109 | .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, |
| 4782 | .{ ._, ._, .add, .tmp1b, .i(1), ._, ._ }, | 8110 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, |
| 4783 | .{ ._, ._, .add, .tmp0p, .i(1), ._, ._ }, | 8111 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 4784 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 8112 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4785 | } }, | 8113 | } }, |
| 4786 | }, .{ | 8114 | }, .{ |
| 4787 | .required_features = .{ .@"64bit", null }, | 8115 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 4788 | .dst_constraints = .{.{ .bool_vec = .qword }}, | 8116 | .src_constraints = .{ .{ .scalar_int = .word }, .{ .scalar_int = .word } }, |
| 4789 | .src_constraints = .{ .{ .int = .byte }, .{ .int = .byte } }, | | |
| 4790 | .patterns = &.{ | 8117 | .patterns = &.{ |
| 4791 | .{ .src = .{ .to_mem, .to_mem } }, | 8118 | .{ .src = .{ .to_mem, .to_mem } }, |
| 4792 | }, | 8119 | }, |
| 4793 | .extra_temps = .{ | 8120 | .extra_temps = .{ |
| 4794 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 8121 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4795 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 8122 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 4796 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 8123 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 4797 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 8124 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 4798 | .unused, | 8125 | .unused, |
| 4799 | .unused, | 8126 | .unused, |
| 4800 | }, | 8127 | }, |
| 4801 | .dst_temps = .{.{ .rc = .general_purpose }}, | 8128 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 8129 | .clobbers = .{ .eflags = true }, |
| 4802 | .each = .{ .once = &.{ | 8130 | .each = .{ .once = &.{ |
| 4803 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, | 8131 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, |
| 4804 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 8132 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4805 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | 8133 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, |
| 4806 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | 8134 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 4807 | .{ ._, ._, .mov, .tmp3b, .memia(.src0b, .tmp0, .add_size), ._, ._ }, | 8135 | .{ ._, ._, .mov, .tmp3w, .memia(.src0w, .tmp0, .add_size), ._, ._ }, |
| 4808 | .{ ._, ._, .cmp, .tmp3b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, | 8136 | .{ ._, ._, .cmp, .tmp3w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, |
| 4809 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 8137 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, |
| 4810 | .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ }, | 8138 | .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, |
| 4811 | .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ }, | 8139 | .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, |
| 4812 | .{ ._, ._, .inc, .tmp1b, ._, ._, ._ }, | 8140 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, |
| 4813 | .{ ._, ._, .inc, .tmp0p, ._, ._, ._ }, | 8141 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 4814 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 8142 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4815 | } }, | 8143 | } }, |
| 4816 | }, .{ | 8144 | }, .{ |
| 4817 | .required_features = .{ .@"64bit", .slow_incdec }, | 8145 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 4818 | .dst_constraints = .{.{ .bool_vec = .qword }}, | 8146 | .src_constraints = .{ .{ .scalar_int = .dword }, .{ .scalar_int = .dword } }, |
| 4819 | .src_constraints = .{ .{ .int = .word }, .{ .int = .word } }, | | |
| 4820 | .patterns = &.{ | 8147 | .patterns = &.{ |
| 4821 | .{ .src = .{ .to_mem, .to_mem } }, | 8148 | .{ .src = .{ .to_mem, .to_mem } }, |
| 4822 | }, | 8149 | }, |
| 4823 | .extra_temps = .{ | 8150 | .extra_temps = .{ |
| 4824 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 8151 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4825 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 8152 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 4826 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 8153 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 4827 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, | 8154 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 4828 | .unused, | 8155 | .unused, |
| 4829 | .unused, | 8156 | .unused, |
| 4830 | }, | 8157 | }, |
| 4831 | .dst_temps = .{.{ .rc = .general_purpose }}, | 8158 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 8159 | .clobbers = .{ .eflags = true }, |
| 4832 | .each = .{ .once = &.{ | 8160 | .each = .{ .once = &.{ |
| 4833 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, | 8161 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, |
| 4834 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 8162 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| | 8163 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, |
| 4835 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | 8164 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 4836 | .{ ._, ._, .mov, .tmp3w, .memia(.src0w, .tmp0, .add_size), ._, ._ }, | 8165 | .{ ._, ._, .mov, .tmp3d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, |
| 4837 | .{ ._, ._, .cmp, .tmp3w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, | 8166 | .{ ._, ._, .cmp, .tmp3d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, |
| 4838 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 8167 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, |
| 4839 | .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ }, | 8168 | .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, |
| 4840 | .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ }, | 8169 | .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, |
| 4841 | .{ ._, ._, .add, .tmp1b, .i(1), ._, ._ }, | 8170 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, |
| 4842 | .{ ._, ._, .add, .tmp0p, .i(2), ._, ._ }, | 8171 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 4843 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 8172 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4844 | } }, | 8173 | } }, |
| 4845 | }, .{ | 8174 | }, .{ |
| 4846 | .required_features = .{ .@"64bit", null }, | 8175 | .required_features = .{ .@"64bit", null, null, null }, |
| 4847 | .dst_constraints = .{.{ .bool_vec = .qword }}, | 8176 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 4848 | .src_constraints = .{ .{ .int = .word }, .{ .int = .word } }, | 8177 | .src_constraints = .{ .{ .scalar_int = .qword }, .{ .scalar_int = .qword } }, |
| 4849 | .patterns = &.{ | 8178 | .patterns = &.{ |
| 4850 | .{ .src = .{ .to_mem, .to_mem } }, | 8179 | .{ .src = .{ .to_mem, .to_mem } }, |
| 4851 | }, | 8180 | }, |
| 4852 | .extra_temps = .{ | 8181 | .extra_temps = .{ |
| 4853 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 8182 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4854 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 8183 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| | 8184 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 4855 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 8185 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 4856 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, | | |
| 4857 | .unused, | 8186 | .unused, |
| 4858 | .unused, | 8187 | .unused, |
| 4859 | }, | 8188 | }, |
| 4860 | .dst_temps = .{.{ .rc = .general_purpose }}, | 8189 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 8190 | .clobbers = .{ .eflags = true }, |
| 4861 | .each = .{ .once = &.{ | 8191 | .each = .{ .once = &.{ |
| 4862 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, | 8192 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, |
| 4863 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 8193 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4864 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | 8194 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, |
| 4865 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | 8195 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 4866 | .{ ._, ._, .mov, .tmp3w, .memia(.src0w, .tmp0, .add_size), ._, ._ }, | 8196 | .{ ._, ._, .mov, .tmp3q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 4867 | .{ ._, ._, .cmp, .tmp3w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, | 8197 | .{ ._, ._, .cmp, .tmp3q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 4868 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 8198 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, |
| 4869 | .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ }, | 8199 | .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, |
| 4870 | .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ }, | 8200 | .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, |
| 4871 | .{ ._, ._, .inc, .tmp1b, ._, ._, ._ }, | 8201 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, |
| 4872 | .{ ._, ._, .add, .tmp0p, .i(2), ._, ._ }, | 8202 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 4873 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 8203 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4874 | } }, | 8204 | } }, |
| 4875 | }, .{ | 8205 | }, .{ |
| 4876 | .required_features = .{ .@"64bit", .slow_incdec }, | 8206 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 4877 | .dst_constraints = .{.{ .bool_vec = .qword }}, | | |
| 4878 | .src_constraints = .{ .{ .int = .dword }, .{ .int = .dword } }, | | |
| 4879 | .patterns = &.{ | 8207 | .patterns = &.{ |
| 4880 | .{ .src = .{ .to_mem, .to_mem } }, | 8208 | .{ .src = .{ .to_mem, .to_mem } }, |
| 4881 | }, | 8209 | }, |
| 4882 | .extra_temps = .{ | 8210 | .extra_temps = .{ |
| 4883 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 8211 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 4884 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 8212 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 4885 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | | |
| 4886 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 8213 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 4887 | .unused, | 8214 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 8215 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 4888 | .unused, | 8216 | .unused, |
| 4889 | }, | 8217 | }, |
| 4890 | .dst_temps = .{.{ .rc = .general_purpose }}, | 8218 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 8219 | .clobbers = .{ .eflags = true }, |
| 4891 | .each = .{ .once = &.{ | 8220 | .each = .{ .once = &.{ |
| 4892 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, | 8221 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, |
| 4893 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 8222 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 4894 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | 8223 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, |
| 4895 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | 8224 | .{ .@"0:", ._, .mov, .tmp2d, .sa(.src0p, .add_elem_limbs), ._, ._ }, |
| 4896 | .{ ._, ._, .mov, .tmp3d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, | 8225 | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, |
| 4897 | .{ ._, ._, .cmp, .tmp3d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, | 8226 | .{ .@"1:", ._, .mov, .tmp4p, .memi(.src0p, .tmp0), ._, ._ }, |
| | 8227 | .{ ._, ._, .xor, .tmp4p, .memi(.src1p, .tmp0), ._, ._ }, |
| | 8228 | .{ ._, ._, .@"or", .tmp3p, .tmp4p, ._, ._ }, |
| | 8229 | .{ ._, ._, .add, .tmp0p, .sa(.tmp4, .add_size), ._, ._ }, |
| | 8230 | .{ ._, ._, .sub, .tmp2d, .si(1), ._, ._ }, |
| | 8231 | .{ ._, ._b, .j, .@"1b", ._, ._, ._ }, |
| | 8232 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 8233 | .{ ._, ._, .@"test", .tmp3p, .tmp3p, ._, ._ }, |
| 4898 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 8234 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, |
| 4899 | .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ }, | 8235 | .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, |
| 4900 | .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ }, | 8236 | .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, |
| 4901 | .{ ._, ._, .add, .tmp1b, .i(1), ._, ._ }, | 8237 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, |
| 4902 | .{ ._, ._, .add, .tmp0p, .i(4), ._, ._ }, | 8238 | .{ ._, ._, .cmp, .tmp1b, .sa(.dst0, .add_len), ._, ._ }, |
| 4903 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 8239 | .{ ._, ._b, .j, .@"0b", ._, ._, ._ }, |
| 4904 | } }, | 8240 | } }, |
| 4905 | }, .{ | 8241 | }, .{ |
| 4906 | .required_features = .{ .@"64bit", null }, | 8242 | .required_features = .{ .@"64bit", null, null, null }, |
| 4907 | .dst_constraints = .{.{ .bool_vec = .qword }}, | 8243 | .dst_constraints = .{.{ .bool_vec = .qword }}, |
| 4908 | .src_constraints = .{ .{ .int = .dword }, .{ .int = .dword } }, | 8244 | .src_constraints = .{ .{ .scalar_int = .byte }, .{ .scalar_int = .byte } }, |
| 4909 | .patterns = &.{ | 8245 | .patterns = &.{ |
| 4910 | .{ .src = .{ .to_mem, .to_mem } }, | 8246 | .{ .src = .{ .to_mem, .to_mem } }, |
| 4911 | }, | 8247 | }, |
| ... | @@ -4913,29 +8249,30 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4913,29 +8249,30 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4913 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 8249 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4914 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 8250 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 4915 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 8251 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 4916 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 8252 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 4917 | .unused, | 8253 | .unused, |
| 4918 | .unused, | 8254 | .unused, |
| 4919 | }, | 8255 | }, |
| 4920 | .dst_temps = .{.{ .rc = .general_purpose }}, | 8256 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 8257 | .clobbers = .{ .eflags = true }, |
| 4921 | .each = .{ .once = &.{ | 8258 | .each = .{ .once = &.{ |
| 4922 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, | 8259 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, |
| 4923 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 8260 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4924 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | 8261 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, |
| 4925 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | 8262 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 4926 | .{ ._, ._, .mov, .tmp3d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, | 8263 | .{ ._, ._, .mov, .tmp3b, .memia(.src0b, .tmp0, .add_size), ._, ._ }, |
| 4927 | .{ ._, ._, .cmp, .tmp3d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, | 8264 | .{ ._, ._, .cmp, .tmp3b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, |
| 4928 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 8265 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, |
| 4929 | .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ }, | 8266 | .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ }, |
| 4930 | .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ }, | 8267 | .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ }, |
| 4931 | .{ ._, ._, .inc, .tmp1b, ._, ._, ._ }, | 8268 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, |
| 4932 | .{ ._, ._, .add, .tmp0p, .i(4), ._, ._ }, | 8269 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 4933 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 8270 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4934 | } }, | 8271 | } }, |
| 4935 | }, .{ | 8272 | }, .{ |
| 4936 | .required_features = .{ .@"64bit", .slow_incdec }, | 8273 | .required_features = .{ .@"64bit", null, null, null }, |
| 4937 | .dst_constraints = .{.{ .bool_vec = .qword }}, | 8274 | .dst_constraints = .{.{ .bool_vec = .qword }}, |
| 4938 | .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword } }, | 8275 | .src_constraints = .{ .{ .scalar_int = .word }, .{ .scalar_int = .word } }, |
| 4939 | .patterns = &.{ | 8276 | .patterns = &.{ |
| 4940 | .{ .src = .{ .to_mem, .to_mem } }, | 8277 | .{ .src = .{ .to_mem, .to_mem } }, |
| 4941 | }, | 8278 | }, |
| ... | @@ -4943,29 +8280,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4943,29 +8280,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4943 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 8280 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4944 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 8281 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 4945 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 8282 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 4946 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 8283 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 4947 | .unused, | 8284 | .unused, |
| 4948 | .unused, | 8285 | .unused, |
| 4949 | }, | 8286 | }, |
| 4950 | .dst_temps = .{.{ .rc = .general_purpose }}, | 8287 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 8288 | .clobbers = .{ .eflags = true }, |
| 4951 | .each = .{ .once = &.{ | 8289 | .each = .{ .once = &.{ |
| 4952 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, | 8290 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, |
| 4953 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 8291 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4954 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | | |
| 4955 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | 8292 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 4956 | .{ ._, ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, | 8293 | .{ ._, ._, .mov, .tmp3w, .memia(.src0w, .tmp0, .add_size), ._, ._ }, |
| 4957 | .{ ._, ._, .cmp, .tmp2q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, | 8294 | .{ ._, ._, .cmp, .tmp3w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, |
| 4958 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 8295 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, |
| 4959 | .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ }, | 8296 | .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ }, |
| 4960 | .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ }, | 8297 | .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ }, |
| 4961 | .{ ._, ._, .add, .tmp1b, .i(1), ._, ._ }, | 8298 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, |
| 4962 | .{ ._, ._, .add, .tmp0p, .i(8), ._, ._ }, | 8299 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 4963 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 8300 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4964 | } }, | 8301 | } }, |
| 4965 | }, .{ | 8302 | }, .{ |
| 4966 | .required_features = .{ .@"64bit", null }, | 8303 | .required_features = .{ .@"64bit", null, null, null }, |
| 4967 | .dst_constraints = .{.{ .bool_vec = .qword }}, | 8304 | .dst_constraints = .{.{ .bool_vec = .qword }}, |
| 4968 | .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword } }, | 8305 | .src_constraints = .{ .{ .scalar_int = .dword }, .{ .scalar_int = .dword } }, |
| 4969 | .patterns = &.{ | 8306 | .patterns = &.{ |
| 4970 | .{ .src = .{ .to_mem, .to_mem } }, | 8307 | .{ .src = .{ .to_mem, .to_mem } }, |
| 4971 | }, | 8308 | }, |
| ... | @@ -4973,63 +8310,59 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4973,63 +8310,59 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4973 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 8310 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4974 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 8311 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 4975 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 8312 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 4976 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 8313 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 4977 | .unused, | 8314 | .unused, |
| 4978 | .unused, | 8315 | .unused, |
| 4979 | }, | 8316 | }, |
| 4980 | .dst_temps = .{.{ .rc = .general_purpose }}, | 8317 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 8318 | .clobbers = .{ .eflags = true }, |
| 4981 | .each = .{ .once = &.{ | 8319 | .each = .{ .once = &.{ |
| 4982 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, | 8320 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, |
| 4983 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 8321 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4984 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | 8322 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, |
| 4985 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | 8323 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 4986 | .{ ._, ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, | 8324 | .{ ._, ._, .mov, .tmp3d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, |
| 4987 | .{ ._, ._, .cmp, .tmp2q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, | 8325 | .{ ._, ._, .cmp, .tmp3d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, |
| 4988 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 8326 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, |
| 4989 | .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ }, | 8327 | .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ }, |
| 4990 | .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ }, | 8328 | .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ }, |
| 4991 | .{ ._, ._, .inc, .tmp1b, ._, ._, ._ }, | 8329 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, |
| 4992 | .{ ._, ._, .add, .tmp0p, .i(8), ._, ._ }, | 8330 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 4993 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 8331 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4994 | } }, | 8332 | } }, |
| 4995 | }, .{ | 8333 | }, .{ |
| 4996 | .required_features = .{ .@"64bit", .slow_incdec }, | 8334 | .required_features = .{ .@"64bit", null, null, null }, |
| 4997 | .dst_constraints = .{.{ .bool_vec = .qword }}, | 8335 | .dst_constraints = .{.{ .bool_vec = .qword }}, |
| | 8336 | .src_constraints = .{ .{ .scalar_int = .qword }, .{ .scalar_int = .qword } }, |
| 4998 | .patterns = &.{ | 8337 | .patterns = &.{ |
| 4999 | .{ .src = .{ .to_mem, .to_mem } }, | 8338 | .{ .src = .{ .to_mem, .to_mem } }, |
| 5000 | }, | 8339 | }, |
| 5001 | .extra_temps = .{ | 8340 | .extra_temps = .{ |
| 5002 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 8341 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5003 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 8342 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 5004 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 8343 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 5005 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 8344 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 5006 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 8345 | .unused, |
| 5007 | .unused, | 8346 | .unused, |
| 5008 | }, | 8347 | }, |
| 5009 | .dst_temps = .{.{ .rc = .general_purpose }}, | 8348 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 8349 | .clobbers = .{ .eflags = true }, |
| 5010 | .each = .{ .once = &.{ | 8350 | .each = .{ .once = &.{ |
| 5011 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, | 8351 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, |
| 5012 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, | 8352 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 5013 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | 8353 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, |
| 5014 | .{ .@"0:", ._, .mov, .tmp2d, .a(.src0p, .add_elem_limbs), ._, ._ }, | 8354 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 5015 | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, | 8355 | .{ ._, ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 5016 | .{ .@"1:", ._, .mov, .tmp4p, .memi(.src0p, .tmp0), ._, ._ }, | 8356 | .{ ._, ._, .cmp, .tmp2q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 5017 | .{ ._, ._, .xor, .tmp4p, .memi(.src1p, .tmp0), ._, ._ }, | | |
| 5018 | .{ ._, ._, .@"or", .tmp3p, .tmp4p, ._, ._ }, | | |
| 5019 | .{ ._, ._, .add, .tmp0p, .a(.tmp4, .add_size), ._, ._ }, | | |
| 5020 | .{ ._, ._, .sub, .tmp2d, .i(1), ._, ._ }, | | |
| 5021 | .{ ._, ._b, .j, .@"1b", ._, ._, ._ }, | | |
| 5022 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | | |
| 5023 | .{ ._, ._, .@"test", .tmp3p, .tmp3p, ._, ._ }, | | |
| 5024 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 8357 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, |
| 5025 | .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ }, | 8358 | .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ }, |
| 5026 | .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ }, | 8359 | .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ }, |
| 5027 | .{ ._, ._, .add, .tmp1b, .i(1), ._, ._ }, | 8360 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, |
| 5028 | .{ ._, ._, .cmp, .tmp1b, .a(.dst0, .add_len), ._, ._ }, | 8361 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 5029 | .{ ._, ._b, .j, .@"0b", ._, ._, ._ }, | 8362 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5030 | } }, | 8363 | } }, |
| 5031 | }, .{ | 8364 | }, .{ |
| 5032 | .required_features = .{ .@"64bit", null }, | 8365 | .required_features = .{ .@"64bit", null, null, null }, |
| 5033 | .dst_constraints = .{.{ .bool_vec = .qword }}, | 8366 | .dst_constraints = .{.{ .bool_vec = .qword }}, |
| 5034 | .patterns = &.{ | 8367 | .patterns = &.{ |
| 5035 | .{ .src = .{ .to_mem, .to_mem } }, | 8368 | .{ .src = .{ .to_mem, .to_mem } }, |
| ... | @@ -5043,30 +8376,30 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5043,30 +8376,30 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5043 | .unused, | 8376 | .unused, |
| 5044 | }, | 8377 | }, |
| 5045 | .dst_temps = .{.{ .rc = .general_purpose }}, | 8378 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 8379 | .clobbers = .{ .eflags = true }, |
| 5046 | .each = .{ .once = &.{ | 8380 | .each = .{ .once = &.{ |
| 5047 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, | 8381 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, |
| 5048 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, | 8382 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 5049 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | 8383 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, |
| 5050 | .{ .@"0:", ._, .mov, .tmp2d, .a(.src0p, .add_elem_limbs), ._, ._ }, | 8384 | .{ .@"0:", ._, .mov, .tmp2d, .sa(.src0p, .add_elem_limbs), ._, ._ }, |
| 5051 | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, | 8385 | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, |
| 5052 | .{ .@"1:", ._, .mov, .tmp4p, .memi(.src0p, .tmp0), ._, ._ }, | 8386 | .{ .@"1:", ._, .mov, .tmp4p, .memi(.src0p, .tmp0), ._, ._ }, |
| 5053 | .{ ._, ._, .xor, .tmp4p, .memi(.src1p, .tmp0), ._, ._ }, | 8387 | .{ ._, ._, .xor, .tmp4p, .memi(.src1p, .tmp0), ._, ._ }, |
| 5054 | .{ ._, ._, .@"or", .tmp3p, .tmp4p, ._, ._ }, | 8388 | .{ ._, ._, .@"or", .tmp3p, .tmp4p, ._, ._ }, |
| 5055 | .{ ._, ._, .add, .tmp0p, .a(.tmp4, .add_size), ._, ._ }, | 8389 | .{ ._, ._, .add, .tmp0p, .sa(.tmp4, .add_size), ._, ._ }, |
| 5056 | .{ ._, ._, .dec, .tmp2d, ._, ._, ._ }, | 8390 | .{ ._, ._, .sub, .tmp2d, .si(1), ._, ._ }, |
| 5057 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, | 8391 | .{ ._, ._b, .j, .@"1b", ._, ._, ._ }, |
| 5058 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | 8392 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 5059 | .{ ._, ._, .@"test", .tmp3p, .tmp3p, ._, ._ }, | 8393 | .{ ._, ._, .@"test", .tmp3p, .tmp3p, ._, ._ }, |
| 5060 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, | 8394 | .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, |
| 5061 | .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ }, | 8395 | .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ }, |
| 5062 | .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ }, | 8396 | .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ }, |
| 5063 | .{ ._, ._, .inc, .tmp1b, ._, ._, ._ }, | 8397 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, |
| 5064 | .{ ._, ._, .cmp, .tmp1b, .a(.dst0, .add_len), ._, ._ }, | 8398 | .{ ._, ._, .cmp, .tmp1b, .sa(.dst0, .add_len), ._, ._ }, |
| 5065 | .{ ._, ._b, .j, .@"0b", ._, ._, ._ }, | 8399 | .{ ._, ._b, .j, .@"0b", ._, ._, ._ }, |
| 5066 | } }, | 8400 | } }, |
| 5067 | }, .{ | 8401 | }, .{ |
| 5068 | .required_features = .{ .slow_incdec, null }, | 8402 | .src_constraints = .{ .{ .scalar_int = .byte }, .{ .scalar_int = .byte } }, |
| 5069 | .src_constraints = .{ .{ .int = .byte }, .{ .int = .byte } }, | | |
| 5070 | .patterns = &.{ | 8403 | .patterns = &.{ |
| 5071 | .{ .src = .{ .to_mem, .to_mem } }, | 8404 | .{ .src = .{ .to_mem, .to_mem } }, |
| 5072 | }, | 8405 | }, |
| ... | @@ -5079,8 +8412,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5079,8 +8412,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5079 | .unused, | 8412 | .unused, |
| 5080 | }, | 8413 | }, |
| 5081 | .dst_temps = .{.mem}, | 8414 | .dst_temps = .{.mem}, |
| | 8415 | .clobbers = .{ .eflags = true }, |
| 5082 | .each = .{ .once = &.{ | 8416 | .each = .{ .once = &.{ |
| 5083 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 8417 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 5084 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 8418 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 5085 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | 8419 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 5086 | .{ .@"0:", ._, .xor, .tmp3d, .tmp3d, ._, ._ }, | 8420 | .{ .@"0:", ._, .xor, .tmp3d, .tmp3d, ._, ._ }, |
| ... | @@ -5089,62 +8423,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5089,62 +8423,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5089 | .{ ._, .fromCondition(cc), .set, .tmp3b, ._, ._, ._ }, | 8423 | .{ ._, .fromCondition(cc), .set, .tmp3b, ._, ._, ._ }, |
| 5090 | .{ ._, ._l, .sh, .tmp3p, .tmp1b, ._, ._ }, | 8424 | .{ ._, ._l, .sh, .tmp3p, .tmp1b, ._, ._ }, |
| 5091 | .{ ._, ._, .@"or", .tmp2p, .tmp3p, ._, ._ }, | 8425 | .{ ._, ._, .@"or", .tmp2p, .tmp3p, ._, ._ }, |
| 5092 | .{ ._, ._, .add, .tmp1d, .i(1), ._, ._ }, | 8426 | .{ ._, ._, .add, .tmp1d, .si(1), ._, ._ }, |
| 5093 | .{ ._, ._, .@"test", .tmp1d, .ia(-1, .none, .add_ptr_bit_size), ._, ._ }, | 8427 | .{ ._, ._, .@"test", .tmp1d, .sia(-1, .none, .add_ptr_bit_size), ._, ._ }, |
| 5094 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, | 8428 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 5095 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, | 8429 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| 5096 | .{ ._, ._r, .sh, .tmp3d, .i(3), ._, ._ }, | 8430 | .{ ._, ._r, .sh, .tmp3d, .si(3), ._, ._ }, |
| 5097 | .{ ._, ._, .mov, .memia(.dst0p, .tmp3, .sub_ptr_size), .tmp2p, ._, ._ }, | 8431 | .{ ._, ._, .mov, .memia(.dst0p, .tmp3, .sub_ptr_size), .tmp2p, ._, ._ }, |
| 5098 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | 8432 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 5099 | .{ .@"1:", ._, .add, .tmp0p, .i(1), ._, ._ }, | 8433 | .{ .@"1:", ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 5100 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 8434 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5101 | .{ ._, ._, .@"test", .tmp1d, .ia(-1, .none, .add_ptr_bit_size), ._, ._ }, | 8435 | .{ ._, ._, .@"test", .tmp1d, .sia(-1, .none, .add_ptr_bit_size), ._, ._ }, |
| 5102 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, | | |
| 5103 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, | | |
| 5104 | .{ ._, ._r, .sh, .tmp3d, .i(3), ._, ._ }, | | |
| 5105 | .{ ._, ._, .mov, .memi(.dst0p, .tmp3), .tmp2p, ._, ._ }, | | |
| 5106 | } }, | | |
| 5107 | }, .{ | | |
| 5108 | .src_constraints = .{ .{ .int = .byte }, .{ .int = .byte } }, | | |
| 5109 | .patterns = &.{ | | |
| 5110 | .{ .src = .{ .to_mem, .to_mem } }, | | |
| 5111 | }, | | |
| 5112 | .extra_temps = .{ | | |
| 5113 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | | |
| 5114 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | | |
| 5115 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | | |
| 5116 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | | |
| 5117 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | | |
| 5118 | .unused, | | |
| 5119 | }, | | |
| 5120 | .dst_temps = .{.mem}, | | |
| 5121 | .each = .{ .once = &.{ | | |
| 5122 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | | |
| 5123 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | | |
| 5124 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | | |
| 5125 | .{ .@"0:", ._, .xor, .tmp3d, .tmp3d, ._, ._ }, | | |
| 5126 | .{ ._, ._, .mov, .tmp4b, .memia(.src0b, .tmp0, .add_size), ._, ._ }, | | |
| 5127 | .{ ._, ._, .cmp, .tmp4b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, | | |
| 5128 | .{ ._, .fromCondition(cc), .set, .tmp3b, ._, ._, ._ }, | | |
| 5129 | .{ ._, ._l, .sh, .tmp3p, .tmp1b, ._, ._ }, | | |
| 5130 | .{ ._, ._, .@"or", .tmp2p, .tmp3p, ._, ._ }, | | |
| 5131 | .{ ._, ._, .inc, .tmp1d, ._, ._, ._ }, | | |
| 5132 | .{ ._, ._, .@"test", .tmp1d, .ia(-1, .none, .add_ptr_bit_size), ._, ._ }, | | |
| 5133 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, | | |
| 5134 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, | | |
| 5135 | .{ ._, ._r, .sh, .tmp3d, .i(3), ._, ._ }, | | |
| 5136 | .{ ._, ._, .mov, .memia(.dst0p, .tmp3, .sub_ptr_size), .tmp2p, ._, ._ }, | | |
| 5137 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | | |
| 5138 | .{ .@"1:", ._, .inc, .tmp0p, ._, ._, ._ }, | | |
| 5139 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | | |
| 5140 | .{ ._, ._, .@"test", .tmp1d, .ia(-1, .none, .add_ptr_bit_size), ._, ._ }, | | |
| 5141 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, | 8436 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| 5142 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, | 8437 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| 5143 | .{ ._, ._r, .sh, .tmp3d, .i(3), ._, ._ }, | 8438 | .{ ._, ._r, .sh, .tmp3d, .si(3), ._, ._ }, |
| 5144 | .{ ._, ._, .mov, .memi(.dst0p, .tmp3), .tmp2p, ._, ._ }, | 8439 | .{ ._, ._, .mov, .memi(.dst0p, .tmp3), .tmp2p, ._, ._ }, |
| 5145 | } }, | 8440 | } }, |
| 5146 | } }, | 8441 | } }, |
| 5147 | }) catch |err2| switch (err2) { | 8442 | }) catch |err| switch (err) { |
| 5148 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ | 8443 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 5149 | @tagName(air_tag), | 8444 | @tagName(air_tag), |
| 5150 | cg.typeOf(extra.lhs).fmt(pt), | 8445 | cg.typeOf(extra.lhs).fmt(pt), |
| ... | @@ -5175,9 +8470,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5175,9 +8470,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5175 | .cmp_lte, .cmp_lte_optimized => .lte, | 8470 | .cmp_lte, .cmp_lte_optimized => .lte, |
| 5176 | .cmp_gte, .cmp_gte_optimized => .gte, | 8471 | .cmp_gte, .cmp_gte_optimized => .gte, |
| 5177 | .cmp_gt, .cmp_gt_optimized => .gt, | 8472 | .cmp_gt, .cmp_gt_optimized => .gt, |
| 5178 | }) else { | 8473 | }) else fallback: { |
| 5179 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; | 8474 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; |
| 5180 | const scalar_ty = cg.typeOf(bin_op.lhs).scalarType(zcu); | 8475 | const scalar_ty = cg.typeOf(bin_op.lhs).scalarType(zcu); |
| | 8476 | if (scalar_ty.isRuntimeFloat()) break :fallback try cg.airCmp(inst, switch (air_tag) { |
| | 8477 | else => unreachable, |
| | 8478 | .cmp_lt, .cmp_lt_optimized => .lt, |
| | 8479 | .cmp_lte, .cmp_lte_optimized => .lte, |
| | 8480 | .cmp_gte, .cmp_gte_optimized => .gte, |
| | 8481 | .cmp_gt, .cmp_gt_optimized => .gt, |
| | 8482 | }); |
| 5181 | const signedness = if (scalar_ty.isAbiInt(zcu)) | 8483 | const signedness = if (scalar_ty.isAbiInt(zcu)) |
| 5182 | scalar_ty.intInfo(zcu).signedness | 8484 | scalar_ty.intInfo(zcu).signedness |
| 5183 | else | 8485 | else |
| ... | @@ -5205,11 +8507,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5205,11 +8507,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5205 | .src_constraints = .{ .{ .int = .byte }, .{ .int = .byte } }, | 8507 | .src_constraints = .{ .{ .int = .byte }, .{ .int = .byte } }, |
| 5206 | .patterns = &.{ | 8508 | .patterns = &.{ |
| 5207 | .{ .src = .{ .imm8, .mem }, .commute = .{ 0, 1 } }, | 8509 | .{ .src = .{ .imm8, .mem }, .commute = .{ 0, 1 } }, |
| 5208 | .{ .src = .{ .imm8, .gpr }, .commute = .{ 0, 1 } }, | 8510 | .{ .src = .{ .imm8, .to_gpr }, .commute = .{ 0, 1 } }, |
| 5209 | .{ .src = .{ .mem, .gpr }, .commute = .{ 0, 1 } }, | 8511 | .{ .src = .{ .mem, .to_gpr }, .commute = .{ 0, 1 } }, |
| 5210 | }, | 8512 | }, |
| 5211 | .clobbers = .{ .eflags = true }, | | |
| 5212 | .dst_temps = .{.{ .cc = cc.commute() }}, | 8513 | .dst_temps = .{.{ .cc = cc.commute() }}, |
| | 8514 | .clobbers = .{ .eflags = true }, |
| 5213 | .each = .{ .once = &.{ | 8515 | .each = .{ .once = &.{ |
| 5214 | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, | 8516 | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, |
| 5215 | } }, | 8517 | } }, |
| ... | @@ -5217,12 +8519,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5217,12 +8519,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5217 | .src_constraints = .{ .{ .int = .byte }, .{ .int = .byte } }, | 8519 | .src_constraints = .{ .{ .int = .byte }, .{ .int = .byte } }, |
| 5218 | .patterns = &.{ | 8520 | .patterns = &.{ |
| 5219 | .{ .src = .{ .mem, .imm8 } }, | 8521 | .{ .src = .{ .mem, .imm8 } }, |
| 5220 | .{ .src = .{ .gpr, .imm8 } }, | 8522 | .{ .src = .{ .to_gpr, .imm8 } }, |
| 5221 | .{ .src = .{ .gpr, .mem } }, | 8523 | .{ .src = .{ .to_gpr, .mem } }, |
| 5222 | .{ .src = .{ .gpr, .gpr } }, | 8524 | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 5223 | }, | 8525 | }, |
| 5224 | .clobbers = .{ .eflags = true }, | | |
| 5225 | .dst_temps = .{.{ .cc = cc }}, | 8526 | .dst_temps = .{.{ .cc = cc }}, |
| | 8527 | .clobbers = .{ .eflags = true }, |
| 5226 | .each = .{ .once = &.{ | 8528 | .each = .{ .once = &.{ |
| 5227 | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, | 8529 | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, |
| 5228 | } }, | 8530 | } }, |
| ... | @@ -5230,11 +8532,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5230,11 +8532,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5230 | .src_constraints = .{ .{ .int = .word }, .{ .int = .word } }, | 8532 | .src_constraints = .{ .{ .int = .word }, .{ .int = .word } }, |
| 5231 | .patterns = &.{ | 8533 | .patterns = &.{ |
| 5232 | .{ .src = .{ .imm16, .mem }, .commute = .{ 0, 1 } }, | 8534 | .{ .src = .{ .imm16, .mem }, .commute = .{ 0, 1 } }, |
| 5233 | .{ .src = .{ .imm16, .gpr }, .commute = .{ 0, 1 } }, | 8535 | .{ .src = .{ .imm16, .to_gpr }, .commute = .{ 0, 1 } }, |
| 5234 | .{ .src = .{ .mem, .gpr }, .commute = .{ 0, 1 } }, | 8536 | .{ .src = .{ .mem, .to_gpr }, .commute = .{ 0, 1 } }, |
| 5235 | }, | 8537 | }, |
| 5236 | .clobbers = .{ .eflags = true }, | | |
| 5237 | .dst_temps = .{.{ .cc = cc.commute() }}, | 8538 | .dst_temps = .{.{ .cc = cc.commute() }}, |
| | 8539 | .clobbers = .{ .eflags = true }, |
| 5238 | .each = .{ .once = &.{ | 8540 | .each = .{ .once = &.{ |
| 5239 | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, | 8541 | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, |
| 5240 | } }, | 8542 | } }, |
| ... | @@ -5242,12 +8544,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5242,12 +8544,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5242 | .src_constraints = .{ .{ .int = .word }, .{ .int = .word } }, | 8544 | .src_constraints = .{ .{ .int = .word }, .{ .int = .word } }, |
| 5243 | .patterns = &.{ | 8545 | .patterns = &.{ |
| 5244 | .{ .src = .{ .mem, .imm16 } }, | 8546 | .{ .src = .{ .mem, .imm16 } }, |
| 5245 | .{ .src = .{ .gpr, .imm16 } }, | 8547 | .{ .src = .{ .to_gpr, .imm16 } }, |
| 5246 | .{ .src = .{ .gpr, .mem } }, | 8548 | .{ .src = .{ .to_gpr, .mem } }, |
| 5247 | .{ .src = .{ .gpr, .gpr } }, | 8549 | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 5248 | }, | 8550 | }, |
| 5249 | .clobbers = .{ .eflags = true }, | | |
| 5250 | .dst_temps = .{.{ .cc = cc }}, | 8551 | .dst_temps = .{.{ .cc = cc }}, |
| | 8552 | .clobbers = .{ .eflags = true }, |
| 5251 | .each = .{ .once = &.{ | 8553 | .each = .{ .once = &.{ |
| 5252 | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, | 8554 | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, |
| 5253 | } }, | 8555 | } }, |
| ... | @@ -5255,11 +8557,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5255,11 +8557,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5255 | .src_constraints = .{ .{ .int = .dword }, .{ .int = .dword } }, | 8557 | .src_constraints = .{ .{ .int = .dword }, .{ .int = .dword } }, |
| 5256 | .patterns = &.{ | 8558 | .patterns = &.{ |
| 5257 | .{ .src = .{ .imm32, .mem }, .commute = .{ 0, 1 } }, | 8559 | .{ .src = .{ .imm32, .mem }, .commute = .{ 0, 1 } }, |
| 5258 | .{ .src = .{ .imm32, .gpr }, .commute = .{ 0, 1 } }, | 8560 | .{ .src = .{ .imm32, .to_gpr }, .commute = .{ 0, 1 } }, |
| 5259 | .{ .src = .{ .mem, .gpr }, .commute = .{ 0, 1 } }, | 8561 | .{ .src = .{ .mem, .to_gpr }, .commute = .{ 0, 1 } }, |
| 5260 | }, | 8562 | }, |
| 5261 | .clobbers = .{ .eflags = true }, | | |
| 5262 | .dst_temps = .{.{ .cc = cc.commute() }}, | 8563 | .dst_temps = .{.{ .cc = cc.commute() }}, |
| | 8564 | .clobbers = .{ .eflags = true }, |
| 5263 | .each = .{ .once = &.{ | 8565 | .each = .{ .once = &.{ |
| 5264 | .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ }, | 8566 | .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ }, |
| 5265 | } }, | 8567 | } }, |
| ... | @@ -5267,45 +8569,50 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5267,45 +8569,50 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5267 | .src_constraints = .{ .{ .int = .dword }, .{ .int = .dword } }, | 8569 | .src_constraints = .{ .{ .int = .dword }, .{ .int = .dword } }, |
| 5268 | .patterns = &.{ | 8570 | .patterns = &.{ |
| 5269 | .{ .src = .{ .mem, .imm32 } }, | 8571 | .{ .src = .{ .mem, .imm32 } }, |
| 5270 | .{ .src = .{ .gpr, .imm32 } }, | 8572 | .{ .src = .{ .to_gpr, .imm32 } }, |
| 5271 | .{ .src = .{ .gpr, .mem } }, | 8573 | .{ .src = .{ .to_gpr, .mem } }, |
| 5272 | .{ .src = .{ .gpr, .gpr } }, | 8574 | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 5273 | }, | 8575 | }, |
| 5274 | .clobbers = .{ .eflags = true }, | | |
| 5275 | .dst_temps = .{.{ .cc = cc }}, | 8576 | .dst_temps = .{.{ .cc = cc }}, |
| | 8577 | .clobbers = .{ .eflags = true }, |
| 5276 | .each = .{ .once = &.{ | 8578 | .each = .{ .once = &.{ |
| 5277 | .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ }, | 8579 | .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ }, |
| 5278 | } }, | 8580 | } }, |
| 5279 | }, .{ | 8581 | }, .{ |
| 5280 | .required_features = .{ .@"64bit", null }, | 8582 | .required_features = .{ .@"64bit", null, null, null }, |
| 5281 | .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword } }, | 8583 | .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword } }, |
| 5282 | .patterns = &.{ | 8584 | .patterns = &.{ |
| 5283 | .{ .src = .{ .simm32, .mem }, .commute = .{ 0, 1 } }, | 8585 | .{ .src = .{ .simm32, .mem }, .commute = .{ 0, 1 } }, |
| 5284 | .{ .src = .{ .simm32, .gpr }, .commute = .{ 0, 1 } }, | 8586 | .{ .src = .{ .simm32, .to_gpr }, .commute = .{ 0, 1 } }, |
| 5285 | .{ .src = .{ .mem, .gpr }, .commute = .{ 0, 1 } }, | 8587 | .{ .src = .{ .mem, .to_gpr }, .commute = .{ 0, 1 } }, |
| 5286 | }, | 8588 | }, |
| 5287 | .clobbers = .{ .eflags = true }, | | |
| 5288 | .dst_temps = .{.{ .cc = cc.commute() }}, | 8589 | .dst_temps = .{.{ .cc = cc.commute() }}, |
| | 8590 | .clobbers = .{ .eflags = true }, |
| 5289 | .each = .{ .once = &.{ | 8591 | .each = .{ .once = &.{ |
| 5290 | .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ }, | 8592 | .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ }, |
| 5291 | } }, | 8593 | } }, |
| 5292 | }, .{ | 8594 | }, .{ |
| 5293 | .required_features = .{ .@"64bit", null }, | 8595 | .required_features = .{ .@"64bit", null, null, null }, |
| 5294 | .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword } }, | 8596 | .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword } }, |
| 5295 | .patterns = &.{ | 8597 | .patterns = &.{ |
| 5296 | .{ .src = .{ .mem, .simm32 } }, | 8598 | .{ .src = .{ .mem, .simm32 } }, |
| 5297 | .{ .src = .{ .gpr, .simm32 } }, | 8599 | .{ .src = .{ .to_gpr, .simm32 } }, |
| 5298 | .{ .src = .{ .gpr, .mem } }, | 8600 | .{ .src = .{ .to_gpr, .mem } }, |
| 5299 | .{ .src = .{ .gpr, .gpr } }, | 8601 | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 5300 | }, | 8602 | }, |
| 5301 | .clobbers = .{ .eflags = true }, | | |
| 5302 | .dst_temps = .{.{ .cc = cc }}, | 8603 | .dst_temps = .{.{ .cc = cc }}, |
| | 8604 | .clobbers = .{ .eflags = true }, |
| 5303 | .each = .{ .once = &.{ | 8605 | .each = .{ .once = &.{ |
| 5304 | .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ }, | 8606 | .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ }, |
| 5305 | } }, | 8607 | } }, |
| 5306 | }, .{ | 8608 | }, .{ |
| | 8609 | .src_constraints = .{ .any_int, .any_int }, |
| 5307 | .patterns = &.{ | 8610 | .patterns = &.{ |
| 5308 | .{ .src = .{ .to_mem, .to_mem } }, | 8611 | .{ .src = .{ .to_mem, .to_mem }, .commute = switch (cc) { |
| | 8612 | else => unreachable, |
| | 8613 | .l, .ge, .b, .ae => .{ 0, 0 }, |
| | 8614 | .le, .g, .be, .a => .{ 0, 1 }, |
| | 8615 | } }, |
| 5309 | }, | 8616 | }, |
| 5310 | .extra_temps = .{ | 8617 | .extra_temps = .{ |
| 5311 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 8618 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -5315,17 +8622,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5315,17 +8622,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5315 | .unused, | 8622 | .unused, |
| 5316 | .unused, | 8623 | .unused, |
| 5317 | }, | 8624 | }, |
| 5318 | .clobbers = .{ .eflags = true }, | | |
| 5319 | .dst_temps = .{.{ .rc = .general_purpose }}, | 8625 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 8626 | .clobbers = .{ .eflags = true }, |
| 5320 | .each = .{ .once = &.{ | 8627 | .each = .{ .once = &.{ |
| 5321 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 8628 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 5322 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | 8629 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, |
| 5323 | .{ .@"0:", ._r, .sh, .tmp1b, .i(1), ._, ._ }, | 8630 | .{ .@"0:", ._r, .sh, .tmp1b, .si(1), ._, ._ }, |
| 5324 | .{ ._, ._, .mov, .tmp1p, .memia(.src0p, .tmp0, .add_size), ._, ._ }, | 8631 | .{ ._, ._, .mov, .tmp1p, .memia(.src0p, .tmp0, .add_size), ._, ._ }, |
| 5325 | .{ ._, ._, .sbb, .tmp1p, .memia(.src1p, .tmp0, .add_size), ._, ._ }, | 8632 | .{ ._, ._, .sbb, .tmp1p, .memia(.src1p, .tmp0, .add_size), ._, ._ }, |
| 5326 | .{ ._, ._c, .set, .tmp1b, ._, ._, ._ }, | 8633 | .{ ._, ._c, .set, .tmp1b, ._, ._, ._ }, |
| 5327 | .{ ._, .fromCondition(cc), .set, .dst0b, ._, ._, ._ }, | 8634 | .{ ._, .fromCondition(switch (cc) { |
| 5328 | .{ ._, ._, .add, .tmp0p, .a(.tmp1, .add_size), ._, ._ }, | 8635 | else => unreachable, |
| | 8636 | .l, .ge, .b, .ae => cc, |
| | 8637 | .le, .g, .be, .a => cc.commute(), |
| | 8638 | }), .set, .dst0b, ._, ._, ._ }, |
| | 8639 | .{ ._, ._, .add, .tmp0p, .sa(.tmp1, .add_size), ._, ._ }, |
| 5329 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 8640 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5330 | } }, | 8641 | } }, |
| 5331 | } }, | 8642 | } }, |
| ... | @@ -5342,13 +8653,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5342,13 +8653,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5342 | if (ops[1].index != res[0].index) try ops[1].die(cg); | 8653 | if (ops[1].index != res[0].index) try ops[1].die(cg); |
| 5343 | try res[0].moveTo(inst, cg); | 8654 | try res[0].moveTo(inst, cg); |
| 5344 | }, | 8655 | }, |
| 5345 | .cmp_eq, .cmp_eq_optimized, .cmp_neq, .cmp_neq_optimized => |air_tag| if (use_old) try cg.airCmp(inst, switch (air_tag) { | 8656 | .cmp_eq, |
| | 8657 | .cmp_eq_optimized, |
| | 8658 | .cmp_neq, |
| | 8659 | .cmp_neq_optimized, |
| | 8660 | => |air_tag| if (use_old) try cg.airCmp(inst, switch (air_tag) { |
| 5346 | else => unreachable, | 8661 | else => unreachable, |
| 5347 | .cmp_eq, .cmp_eq_optimized => .eq, | 8662 | .cmp_eq, .cmp_eq_optimized => .eq, |
| 5348 | .cmp_neq, .cmp_neq_optimized => .neq, | 8663 | .cmp_neq, .cmp_neq_optimized => .neq, |
| 5349 | }) else fallback: { | 8664 | }) else fallback: { |
| 5350 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; | 8665 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; |
| 5351 | if (ip.isOptionalType(cg.typeOf(bin_op.lhs).toIntern())) break :fallback try cg.airCmp(inst, switch (air_tag) { | 8666 | const scalar_ty = cg.typeOf(bin_op.lhs).scalarType(zcu); |
| | 8667 | if (scalar_ty.isRuntimeFloat() or ip.isOptionalType(scalar_ty.toIntern())) break :fallback try cg.airCmp(inst, switch (air_tag) { |
| 5352 | else => unreachable, | 8668 | else => unreachable, |
| 5353 | .cmp_eq, .cmp_eq_optimized => .eq, | 8669 | .cmp_eq, .cmp_eq_optimized => .eq, |
| 5354 | .cmp_neq, .cmp_neq_optimized => .neq, | 8670 | .cmp_neq, .cmp_neq_optimized => .neq, |
| ... | @@ -5362,14 +8678,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5362,14 +8678,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5362 | })) { | 8678 | })) { |
| 5363 | else => unreachable, | 8679 | else => unreachable, |
| 5364 | inline .e, .ne => |cc| comptime &.{ .{ | 8680 | inline .e, .ne => |cc| comptime &.{ .{ |
| 5365 | .required_features = .{ .avx2, null }, | 8681 | .required_features = .{ .avx2, null, null, null }, |
| 5366 | .src_constraints = .{ .any_int, .any_int }, | 8682 | .src_constraints = .{ .{ .int = .yword }, .{ .int = .yword } }, |
| 5367 | .patterns = &.{ | 8683 | .patterns = &.{ |
| 5368 | .{ .src = .{ .ymm, .mem } }, | 8684 | .{ .src = .{ .to_ymm, .mem } }, |
| 5369 | .{ .src = .{ .mem, .ymm }, .commute = .{ 0, 1 } }, | 8685 | .{ .src = .{ .mem, .to_ymm }, .commute = .{ 0, 1 } }, |
| 5370 | .{ .src = .{ .ymm, .ymm } }, | 8686 | .{ .src = .{ .to_ymm, .to_ymm } }, |
| 5371 | }, | 8687 | }, |
| 5372 | .clobbers = .{ .eflags = true }, | | |
| 5373 | .extra_temps = .{ | 8688 | .extra_temps = .{ |
| 5374 | .{ .kind = .{ .rc = .sse } }, | 8689 | .{ .kind = .{ .rc = .sse } }, |
| 5375 | .unused, | 8690 | .unused, |
| ... | @@ -5379,19 +8694,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5379,19 +8694,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5379 | .unused, | 8694 | .unused, |
| 5380 | }, | 8695 | }, |
| 5381 | .dst_temps = .{.{ .cc = cc }}, | 8696 | .dst_temps = .{.{ .cc = cc }}, |
| | 8697 | .clobbers = .{ .eflags = true }, |
| 5382 | .each = .{ .once = &.{ | 8698 | .each = .{ .once = &.{ |
| 5383 | .{ ._, .vp_, .xor, .tmp0y, .src0y, .src1y, ._ }, | 8699 | .{ ._, .vp_, .xor, .tmp0y, .src0y, .src1y, ._ }, |
| 5384 | .{ ._, .vp_, .@"test", .tmp0y, .tmp0y, ._, ._ }, | 8700 | .{ ._, .vp_, .@"test", .tmp0y, .tmp0y, ._, ._ }, |
| 5385 | } }, | 8701 | } }, |
| 5386 | }, .{ | 8702 | }, .{ |
| 5387 | .required_features = .{ .avx, null }, | 8703 | .required_features = .{ .avx, null, null, null }, |
| 5388 | .src_constraints = .{ .any_int, .any_int }, | 8704 | .src_constraints = .{ .{ .int = .yword }, .{ .int = .yword } }, |
| 5389 | .patterns = &.{ | 8705 | .patterns = &.{ |
| 5390 | .{ .src = .{ .ymm, .mem } }, | 8706 | .{ .src = .{ .to_ymm, .mem } }, |
| 5391 | .{ .src = .{ .mem, .ymm }, .commute = .{ 0, 1 } }, | 8707 | .{ .src = .{ .mem, .to_ymm }, .commute = .{ 0, 1 } }, |
| 5392 | .{ .src = .{ .ymm, .ymm } }, | 8708 | .{ .src = .{ .to_ymm, .to_ymm } }, |
| 5393 | }, | 8709 | }, |
| 5394 | .clobbers = .{ .eflags = true }, | | |
| 5395 | .extra_temps = .{ | 8710 | .extra_temps = .{ |
| 5396 | .{ .kind = .{ .rc = .sse } }, | 8711 | .{ .kind = .{ .rc = .sse } }, |
| 5397 | .unused, | 8712 | .unused, |
| ... | @@ -5401,19 +8716,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5401,19 +8716,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5401 | .unused, | 8716 | .unused, |
| 5402 | }, | 8717 | }, |
| 5403 | .dst_temps = .{.{ .cc = cc }}, | 8718 | .dst_temps = .{.{ .cc = cc }}, |
| | 8719 | .clobbers = .{ .eflags = true }, |
| 5404 | .each = .{ .once = &.{ | 8720 | .each = .{ .once = &.{ |
| 5405 | .{ ._, .v_pd, .xor, .tmp0y, .src0y, .src1y, ._ }, | 8721 | .{ ._, .v_pd, .xor, .tmp0y, .src0y, .src1y, ._ }, |
| 5406 | .{ ._, .vp_, .@"test", .tmp0y, .tmp0y, ._, ._ }, | 8722 | .{ ._, .vp_, .@"test", .tmp0y, .tmp0y, ._, ._ }, |
| 5407 | } }, | 8723 | } }, |
| 5408 | }, .{ | 8724 | }, .{ |
| 5409 | .required_features = .{ .avx, null }, | 8725 | .required_features = .{ .avx, null, null, null }, |
| 5410 | .src_constraints = .{ .any_int, .any_int }, | 8726 | .src_constraints = .{ .{ .int = .xword }, .{ .int = .xword } }, |
| 5411 | .patterns = &.{ | 8727 | .patterns = &.{ |
| 5412 | .{ .src = .{ .xmm, .mem } }, | 8728 | .{ .src = .{ .to_xmm, .mem } }, |
| 5413 | .{ .src = .{ .mem, .xmm }, .commute = .{ 0, 1 } }, | 8729 | .{ .src = .{ .mem, .to_xmm }, .commute = .{ 0, 1 } }, |
| 5414 | .{ .src = .{ .xmm, .xmm } }, | 8730 | .{ .src = .{ .to_xmm, .to_xmm } }, |
| 5415 | }, | 8731 | }, |
| 5416 | .clobbers = .{ .eflags = true }, | | |
| 5417 | .extra_temps = .{ | 8732 | .extra_temps = .{ |
| 5418 | .{ .kind = .{ .rc = .sse } }, | 8733 | .{ .kind = .{ .rc = .sse } }, |
| 5419 | .unused, | 8734 | .unused, |
| ... | @@ -5423,33 +8738,33 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5423,33 +8738,33 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5423 | .unused, | 8738 | .unused, |
| 5424 | }, | 8739 | }, |
| 5425 | .dst_temps = .{.{ .cc = cc }}, | 8740 | .dst_temps = .{.{ .cc = cc }}, |
| | 8741 | .clobbers = .{ .eflags = true }, |
| 5426 | .each = .{ .once = &.{ | 8742 | .each = .{ .once = &.{ |
| 5427 | .{ ._, .vp_, .xor, .tmp0x, .src0x, .src1x, ._ }, | 8743 | .{ ._, .vp_, .xor, .tmp0x, .src0x, .src1x, ._ }, |
| 5428 | .{ ._, .vp_, .@"test", .tmp0x, .tmp0x, ._, ._ }, | 8744 | .{ ._, .vp_, .@"test", .tmp0x, .tmp0x, ._, ._ }, |
| 5429 | } }, | 8745 | } }, |
| 5430 | }, .{ | 8746 | }, .{ |
| 5431 | .required_features = .{ .sse4_1, null }, | 8747 | .required_features = .{ .sse4_1, null, null, null }, |
| 5432 | .src_constraints = .{ .any_int, .any_int }, | 8748 | .src_constraints = .{ .{ .int = .xword }, .{ .int = .xword } }, |
| 5433 | .patterns = &.{ | 8749 | .patterns = &.{ |
| 5434 | .{ .src = .{ .mut_xmm, .mem } }, | 8750 | .{ .src = .{ .to_mut_xmm, .mem } }, |
| 5435 | .{ .src = .{ .mem, .mut_xmm }, .commute = .{ 0, 1 } }, | 8751 | .{ .src = .{ .mem, .to_mut_xmm }, .commute = .{ 0, 1 } }, |
| 5436 | .{ .src = .{ .mut_xmm, .xmm } }, | 8752 | .{ .src = .{ .to_mut_xmm, .to_xmm } }, |
| 5437 | }, | 8753 | }, |
| 5438 | .clobbers = .{ .eflags = true }, | | |
| 5439 | .dst_temps = .{.{ .cc = cc }}, | 8754 | .dst_temps = .{.{ .cc = cc }}, |
| | 8755 | .clobbers = .{ .eflags = true }, |
| 5440 | .each = .{ .once = &.{ | 8756 | .each = .{ .once = &.{ |
| 5441 | .{ ._, .p_, .xor, .src0x, .src1x, ._, ._ }, | 8757 | .{ ._, .p_, .xor, .src0x, .src1x, ._, ._ }, |
| 5442 | .{ ._, .p_, .@"test", .src0x, .src0x, ._, ._ }, | 8758 | .{ ._, .p_, .@"test", .src0x, .src0x, ._, ._ }, |
| 5443 | } }, | 8759 | } }, |
| 5444 | }, .{ | 8760 | }, .{ |
| 5445 | .required_features = .{ .sse2, null }, | 8761 | .required_features = .{ .sse2, null, null, null }, |
| 5446 | .src_constraints = .{ .any_int, .any_int }, | 8762 | .src_constraints = .{ .{ .int = .xword }, .{ .int = .xword } }, |
| 5447 | .patterns = &.{ | 8763 | .patterns = &.{ |
| 5448 | .{ .src = .{ .mut_xmm, .mem } }, | 8764 | .{ .src = .{ .to_mut_xmm, .mem } }, |
| 5449 | .{ .src = .{ .mem, .mut_xmm }, .commute = .{ 0, 1 } }, | 8765 | .{ .src = .{ .mem, .to_mut_xmm }, .commute = .{ 0, 1 } }, |
| 5450 | .{ .src = .{ .mut_xmm, .xmm } }, | 8766 | .{ .src = .{ .to_mut_xmm, .to_xmm } }, |
| 5451 | }, | 8767 | }, |
| 5452 | .clobbers = .{ .eflags = true }, | | |
| 5453 | .extra_temps = .{ | 8768 | .extra_temps = .{ |
| 5454 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 8769 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 5455 | .{ .kind = .{ .rc = .sse } }, | 8770 | .{ .kind = .{ .rc = .sse } }, |
| ... | @@ -5459,22 +8774,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5459,22 +8774,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5459 | .unused, | 8774 | .unused, |
| 5460 | }, | 8775 | }, |
| 5461 | .dst_temps = .{.{ .cc = cc }}, | 8776 | .dst_temps = .{.{ .cc = cc }}, |
| | 8777 | .clobbers = .{ .eflags = true }, |
| 5462 | .each = .{ .once = &.{ | 8778 | .each = .{ .once = &.{ |
| 5463 | .{ ._, .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, | 8779 | .{ ._, .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 5464 | .{ ._, .p_, .xor, .src0x, .src1x, ._, ._ }, | 8780 | .{ ._, .p_, .xor, .src0x, .src1x, ._, ._ }, |
| 5465 | .{ ._, .p_b, .cmpeq, .tmp1x, .src0x, ._, ._ }, | 8781 | .{ ._, .p_b, .cmpeq, .tmp1x, .src0x, ._, ._ }, |
| 5466 | .{ ._, .p_b, .movmsk, .tmp0d, .tmp1x, ._, ._ }, | 8782 | .{ ._, .p_b, .movmsk, .tmp0d, .tmp1x, ._, ._ }, |
| 5467 | .{ ._, ._, .xor, .tmp0d, .i(0xffff), ._, ._ }, | 8783 | .{ ._, ._, .xor, .tmp0d, .si(0xffff), ._, ._ }, |
| 5468 | } }, | 8784 | } }, |
| 5469 | }, .{ | 8785 | }, .{ |
| 5470 | .required_features = .{ .sse2, .mmx }, | 8786 | .required_features = .{ .sse, .mmx, null, null }, |
| 5471 | .src_constraints = .{ .any_int, .any_int }, | 8787 | .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword } }, |
| 5472 | .patterns = &.{ | 8788 | .patterns = &.{ |
| 5473 | .{ .src = .{ .mut_mm, .mem } }, | 8789 | .{ .src = .{ .to_mut_mm, .mem } }, |
| 5474 | .{ .src = .{ .mem, .mut_mm }, .commute = .{ 0, 1 } }, | 8790 | .{ .src = .{ .mem, .to_mut_mm }, .commute = .{ 0, 1 } }, |
| 5475 | .{ .src = .{ .mut_mm, .mm } }, | 8791 | .{ .src = .{ .to_mut_mm, .to_mm } }, |
| 5476 | }, | 8792 | }, |
| 5477 | .clobbers = .{ .eflags = true }, | | |
| 5478 | .extra_temps = .{ | 8793 | .extra_temps = .{ |
| 5479 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 8794 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 5480 | .{ .kind = .{ .rc = .mmx } }, | 8795 | .{ .kind = .{ .rc = .mmx } }, |
| ... | @@ -5484,26 +8799,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5484,26 +8799,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5484 | .unused, | 8799 | .unused, |
| 5485 | }, | 8800 | }, |
| 5486 | .dst_temps = .{.{ .cc = cc }}, | 8801 | .dst_temps = .{.{ .cc = cc }}, |
| | 8802 | .clobbers = .{ .eflags = true }, |
| 5487 | .each = .{ .once = &.{ | 8803 | .each = .{ .once = &.{ |
| 5488 | .{ ._, .p_, .xor, .tmp1q, .tmp1q, ._, ._ }, | 8804 | .{ ._, .p_, .xor, .tmp1q, .tmp1q, ._, ._ }, |
| 5489 | .{ ._, .p_, .xor, .src0q, .src1q, ._, ._ }, | 8805 | .{ ._, .p_, .xor, .src0q, .src1q, ._, ._ }, |
| 5490 | .{ ._, .p_b, .cmpeq, .tmp1q, .src0q, ._, ._ }, | 8806 | .{ ._, .p_b, .cmpeq, .tmp1q, .src0q, ._, ._ }, |
| 5491 | .{ ._, .p_b, .movmsk, .tmp0d, .tmp1q, ._, ._ }, | 8807 | .{ ._, .p_b, .movmsk, .tmp0d, .tmp1q, ._, ._ }, |
| 5492 | .{ ._, ._, .xor, .tmp0d, .i(0xff), ._, ._ }, | 8808 | .{ ._, ._, .xor, .tmp0d, .si(0xff), ._, ._ }, |
| 5493 | } }, | 8809 | } }, |
| 5494 | }, .{ | 8810 | }, .{ |
| 5495 | .src_constraints = .{ .{ .int = .byte }, .{ .int = .byte } }, | 8811 | .src_constraints = .{ .{ .int = .byte }, .{ .int = .byte } }, |
| 5496 | .patterns = &.{ | 8812 | .patterns = &.{ |
| 5497 | .{ .src = .{ .mem, .imm8 } }, | 8813 | .{ .src = .{ .mem, .imm8 } }, |
| 5498 | .{ .src = .{ .imm8, .mem }, .commute = .{ 0, 1 } }, | 8814 | .{ .src = .{ .imm8, .mem }, .commute = .{ 0, 1 } }, |
| 5499 | .{ .src = .{ .gpr, .imm8 } }, | 8815 | .{ .src = .{ .to_gpr, .imm8 } }, |
| 5500 | .{ .src = .{ .imm8, .gpr }, .commute = .{ 0, 1 } }, | 8816 | .{ .src = .{ .imm8, .to_gpr }, .commute = .{ 0, 1 } }, |
| 5501 | .{ .src = .{ .gpr, .mem } }, | 8817 | .{ .src = .{ .to_gpr, .mem } }, |
| 5502 | .{ .src = .{ .mem, .gpr }, .commute = .{ 0, 1 } }, | 8818 | .{ .src = .{ .mem, .to_gpr }, .commute = .{ 0, 1 } }, |
| 5503 | .{ .src = .{ .gpr, .gpr } }, | 8819 | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 5504 | }, | 8820 | }, |
| 5505 | .clobbers = .{ .eflags = true }, | | |
| 5506 | .dst_temps = .{.{ .cc = cc }}, | 8821 | .dst_temps = .{.{ .cc = cc }}, |
| | 8822 | .clobbers = .{ .eflags = true }, |
| 5507 | .each = .{ .once = &.{ | 8823 | .each = .{ .once = &.{ |
| 5508 | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, | 8824 | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, |
| 5509 | } }, | 8825 | } }, |
| ... | @@ -5512,14 +8828,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5512,14 +8828,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5512 | .patterns = &.{ | 8828 | .patterns = &.{ |
| 5513 | .{ .src = .{ .mem, .imm16 } }, | 8829 | .{ .src = .{ .mem, .imm16 } }, |
| 5514 | .{ .src = .{ .imm16, .mem }, .commute = .{ 0, 1 } }, | 8830 | .{ .src = .{ .imm16, .mem }, .commute = .{ 0, 1 } }, |
| 5515 | .{ .src = .{ .gpr, .imm16 } }, | 8831 | .{ .src = .{ .to_gpr, .imm16 } }, |
| 5516 | .{ .src = .{ .imm16, .gpr }, .commute = .{ 0, 1 } }, | 8832 | .{ .src = .{ .imm16, .to_gpr }, .commute = .{ 0, 1 } }, |
| 5517 | .{ .src = .{ .gpr, .mem } }, | 8833 | .{ .src = .{ .to_gpr, .mem } }, |
| 5518 | .{ .src = .{ .mem, .gpr }, .commute = .{ 0, 1 } }, | 8834 | .{ .src = .{ .mem, .to_gpr }, .commute = .{ 0, 1 } }, |
| 5519 | .{ .src = .{ .gpr, .gpr } }, | 8835 | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 5520 | }, | 8836 | }, |
| 5521 | .clobbers = .{ .eflags = true }, | | |
| 5522 | .dst_temps = .{.{ .cc = cc }}, | 8837 | .dst_temps = .{.{ .cc = cc }}, |
| | 8838 | .clobbers = .{ .eflags = true }, |
| 5523 | .each = .{ .once = &.{ | 8839 | .each = .{ .once = &.{ |
| 5524 | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, | 8840 | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, |
| 5525 | } }, | 8841 | } }, |
| ... | @@ -5528,36 +8844,68 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5528,36 +8844,68 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5528 | .patterns = &.{ | 8844 | .patterns = &.{ |
| 5529 | .{ .src = .{ .mem, .imm32 } }, | 8845 | .{ .src = .{ .mem, .imm32 } }, |
| 5530 | .{ .src = .{ .imm32, .mem }, .commute = .{ 0, 1 } }, | 8846 | .{ .src = .{ .imm32, .mem }, .commute = .{ 0, 1 } }, |
| 5531 | .{ .src = .{ .gpr, .imm32 } }, | 8847 | .{ .src = .{ .to_gpr, .imm32 } }, |
| 5532 | .{ .src = .{ .imm32, .gpr }, .commute = .{ 0, 1 } }, | 8848 | .{ .src = .{ .imm32, .to_gpr }, .commute = .{ 0, 1 } }, |
| 5533 | .{ .src = .{ .gpr, .mem } }, | 8849 | .{ .src = .{ .to_gpr, .mem } }, |
| 5534 | .{ .src = .{ .mem, .gpr }, .commute = .{ 0, 1 } }, | 8850 | .{ .src = .{ .mem, .to_gpr }, .commute = .{ 0, 1 } }, |
| 5535 | .{ .src = .{ .gpr, .gpr } }, | 8851 | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 5536 | }, | 8852 | }, |
| 5537 | .clobbers = .{ .eflags = true }, | | |
| 5538 | .dst_temps = .{.{ .cc = cc }}, | 8853 | .dst_temps = .{.{ .cc = cc }}, |
| | 8854 | .clobbers = .{ .eflags = true }, |
| 5539 | .each = .{ .once = &.{ | 8855 | .each = .{ .once = &.{ |
| 5540 | .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ }, | 8856 | .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ }, |
| 5541 | } }, | 8857 | } }, |
| 5542 | }, .{ | 8858 | }, .{ |
| 5543 | .required_features = .{ .@"64bit", null }, | 8859 | .required_features = .{ .@"64bit", null, null, null }, |
| 5544 | .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword } }, | 8860 | .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword } }, |
| 5545 | .patterns = &.{ | 8861 | .patterns = &.{ |
| 5546 | .{ .src = .{ .mem, .simm32 } }, | 8862 | .{ .src = .{ .mem, .simm32 } }, |
| 5547 | .{ .src = .{ .simm32, .mem }, .commute = .{ 0, 1 } }, | 8863 | .{ .src = .{ .simm32, .mem }, .commute = .{ 0, 1 } }, |
| 5548 | .{ .src = .{ .gpr, .simm32 } }, | 8864 | .{ .src = .{ .to_gpr, .simm32 } }, |
| 5549 | .{ .src = .{ .simm32, .gpr }, .commute = .{ 0, 1 } }, | 8865 | .{ .src = .{ .simm32, .to_gpr }, .commute = .{ 0, 1 } }, |
| 5550 | .{ .src = .{ .gpr, .mem } }, | 8866 | .{ .src = .{ .to_gpr, .mem } }, |
| 5551 | .{ .src = .{ .mem, .gpr }, .commute = .{ 0, 1 } }, | 8867 | .{ .src = .{ .mem, .to_gpr }, .commute = .{ 0, 1 } }, |
| 5552 | .{ .src = .{ .gpr, .gpr } }, | 8868 | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 5553 | }, | 8869 | }, |
| 5554 | .clobbers = .{ .eflags = true }, | | |
| 5555 | .dst_temps = .{.{ .cc = cc }}, | 8870 | .dst_temps = .{.{ .cc = cc }}, |
| | 8871 | .clobbers = .{ .eflags = true }, |
| 5556 | .each = .{ .once = &.{ | 8872 | .each = .{ .once = &.{ |
| 5557 | .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ }, | 8873 | .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ }, |
| 5558 | } }, | 8874 | } }, |
| 5559 | }, .{ | 8875 | }, .{ |
| 5560 | .required_features = .{ .avx2, null }, | 8876 | .required_features = .{ .avx2, null, null, null }, |
| | 8877 | .src_constraints = .{ |
| | 8878 | .{ .remainder_int = .{ .of = .yword, .is = .xword } }, |
| | 8879 | .{ .remainder_int = .{ .of = .yword, .is = .xword } }, |
| | 8880 | }, |
| | 8881 | .patterns = &.{ |
| | 8882 | .{ .src = .{ .to_mem, .to_mem } }, |
| | 8883 | }, |
| | 8884 | .extra_temps = .{ |
| | 8885 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 8886 | .{ .kind = .{ .rc = .sse } }, |
| | 8887 | .{ .kind = .{ .rc = .sse } }, |
| | 8888 | .unused, |
| | 8889 | .unused, |
| | 8890 | .unused, |
| | 8891 | }, |
| | 8892 | .dst_temps = .{.{ .cc = cc }}, |
| | 8893 | .clobbers = .{ .eflags = true }, |
| | 8894 | .each = .{ .once = &.{ |
| | 8895 | .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_size), ._, ._ }, |
| | 8896 | .{ ._, .vp_, .xor, .tmp1y, .tmp1y, .tmp1y, ._ }, |
| | 8897 | .{ .@"0:", .v_dqu, .mov, .tmp2y, .memiad(.src0y, .tmp0, .add_size, -16), ._, ._ }, |
| | 8898 | .{ ._, .vp_, .xor, .tmp2y, .tmp2y, .memiad(.src1y, .tmp0, .add_size, -16), ._ }, |
| | 8899 | .{ ._, .vp_, .@"or", .tmp1y, .tmp1y, .tmp2y, ._ }, |
| | 8900 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 8901 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 8902 | .{ ._, .v_dqa, .mov, .tmp2x, .memad(.src0x, .add_size, -16), ._, ._ }, |
| | 8903 | .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .memad(.src1x, .add_size, -16), ._ }, |
| | 8904 | .{ ._, .vp_, .@"or", .tmp1y, .tmp1y, .tmp2y, ._ }, |
| | 8905 | .{ ._, .vp_, .@"test", .tmp1y, .tmp1y, ._, ._ }, |
| | 8906 | } }, |
| | 8907 | }, .{ |
| | 8908 | .required_features = .{ .avx2, null, null, null }, |
| 5561 | .patterns = &.{ | 8909 | .patterns = &.{ |
| 5562 | .{ .src = .{ .to_mem, .to_mem } }, | 8910 | .{ .src = .{ .to_mem, .to_mem } }, |
| 5563 | }, | 8911 | }, |
| ... | @@ -5570,18 +8918,51 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5570,18 +8918,51 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5570 | .unused, | 8918 | .unused, |
| 5571 | }, | 8919 | }, |
| 5572 | .dst_temps = .{.{ .cc = cc }}, | 8920 | .dst_temps = .{.{ .cc = cc }}, |
| | 8921 | .clobbers = .{ .eflags = true }, |
| 5573 | .each = .{ .once = &.{ | 8922 | .each = .{ .once = &.{ |
| 5574 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 8923 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 5575 | .{ ._, .vp_, .xor, .tmp1y, .tmp1y, .tmp1y, ._ }, | 8924 | .{ ._, .vp_, .xor, .tmp1y, .tmp1y, .tmp1y, ._ }, |
| 5576 | .{ .@"0:", .v_dqu, .mov, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, | 8925 | .{ .@"0:", .v_dqu, .mov, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 5577 | .{ ._, .vp_, .xor, .tmp2y, .tmp2y, .memia(.src1y, .tmp0, .add_size), ._ }, | 8926 | .{ ._, .vp_, .xor, .tmp2y, .tmp2y, .memia(.src1y, .tmp0, .add_size), ._ }, |
| 5578 | .{ ._, .vp_, .@"or", .tmp1y, .tmp1y, .tmp2y, ._ }, | 8927 | .{ ._, .vp_, .@"or", .tmp1y, .tmp1y, .tmp2y, ._ }, |
| 5579 | .{ ._, ._, .add, .tmp0p, .i(32), ._, ._ }, | 8928 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 8929 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 8930 | .{ ._, .vp_, .@"test", .tmp1y, .tmp1y, ._, ._ }, |
| | 8931 | } }, |
| | 8932 | }, .{ |
| | 8933 | .required_features = .{ .avx, null, null, null }, |
| | 8934 | .src_constraints = .{ |
| | 8935 | .{ .remainder_int = .{ .of = .yword, .is = .xword } }, |
| | 8936 | .{ .remainder_int = .{ .of = .yword, .is = .xword } }, |
| | 8937 | }, |
| | 8938 | .patterns = &.{ |
| | 8939 | .{ .src = .{ .to_mem, .to_mem } }, |
| | 8940 | }, |
| | 8941 | .extra_temps = .{ |
| | 8942 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 8943 | .{ .kind = .{ .rc = .sse } }, |
| | 8944 | .{ .kind = .{ .rc = .sse } }, |
| | 8945 | .unused, |
| | 8946 | .unused, |
| | 8947 | .unused, |
| | 8948 | }, |
| | 8949 | .dst_temps = .{.{ .cc = cc }}, |
| | 8950 | .clobbers = .{ .eflags = true }, |
| | 8951 | .each = .{ .once = &.{ |
| | 8952 | .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_size), ._, ._ }, |
| | 8953 | .{ ._, .v_pd, .xor, .tmp1y, .tmp1y, .tmp1y, ._ }, |
| | 8954 | .{ .@"0:", .v_pd, .movu, .tmp2y, .memiad(.src0y, .tmp0, .add_size, -16), ._, ._ }, |
| | 8955 | .{ ._, .v_pd, .xor, .tmp2y, .tmp2y, .memiad(.src1y, .tmp0, .add_size, -16), ._ }, |
| | 8956 | .{ ._, .v_pd, .@"or", .tmp1y, .tmp1y, .tmp2y, ._ }, |
| | 8957 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 5580 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 8958 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 8959 | .{ ._, .v_pd, .mova, .tmp2x, .memad(.src0x, .add_size, -16), ._, ._ }, |
| | 8960 | .{ ._, .v_pd, .xor, .tmp2x, .tmp2x, .memad(.src1x, .add_size, -16), ._ }, |
| | 8961 | .{ ._, .v_pd, .@"or", .tmp1y, .tmp1y, .tmp2y, ._ }, |
| 5581 | .{ ._, .vp_, .@"test", .tmp1y, .tmp1y, ._, ._ }, | 8962 | .{ ._, .vp_, .@"test", .tmp1y, .tmp1y, ._, ._ }, |
| 5582 | } }, | 8963 | } }, |
| 5583 | }, .{ | 8964 | }, .{ |
| 5584 | .required_features = .{ .avx, null }, | 8965 | .required_features = .{ .avx, null, null, null }, |
| 5585 | .patterns = &.{ | 8966 | .patterns = &.{ |
| 5586 | .{ .src = .{ .to_mem, .to_mem } }, | 8967 | .{ .src = .{ .to_mem, .to_mem } }, |
| 5587 | }, | 8968 | }, |
| ... | @@ -5594,18 +8975,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5594,18 +8975,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5594 | .unused, | 8975 | .unused, |
| 5595 | }, | 8976 | }, |
| 5596 | .dst_temps = .{.{ .cc = cc }}, | 8977 | .dst_temps = .{.{ .cc = cc }}, |
| | 8978 | .clobbers = .{ .eflags = true }, |
| 5597 | .each = .{ .once = &.{ | 8979 | .each = .{ .once = &.{ |
| 5598 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 8980 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 5599 | .{ ._, .v_pd, .xor, .tmp1y, .tmp1y, .tmp1y, ._ }, | 8981 | .{ ._, .v_pd, .xor, .tmp1y, .tmp1y, .tmp1y, ._ }, |
| 5600 | .{ .@"0:", .v_pd, .movu, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, | 8982 | .{ .@"0:", .v_pd, .movu, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 5601 | .{ ._, .v_pd, .xor, .tmp2y, .tmp2y, .memia(.src1y, .tmp0, .add_size), ._ }, | 8983 | .{ ._, .v_pd, .xor, .tmp2y, .tmp2y, .memia(.src1y, .tmp0, .add_size), ._ }, |
| 5602 | .{ ._, .v_pd, .@"or", .tmp1y, .tmp1y, .tmp2y, ._ }, | 8984 | .{ ._, .v_pd, .@"or", .tmp1y, .tmp1y, .tmp2y, ._ }, |
| 5603 | .{ ._, ._, .add, .tmp0p, .i(32), ._, ._ }, | 8985 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 5604 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 8986 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5605 | .{ ._, .vp_, .@"test", .tmp1y, .tmp1y, ._, ._ }, | 8987 | .{ ._, .vp_, .@"test", .tmp1y, .tmp1y, ._, ._ }, |
| 5606 | } }, | 8988 | } }, |
| 5607 | }, .{ | 8989 | }, .{ |
| 5608 | .required_features = .{ .avx, null }, | 8990 | .required_features = .{ .avx, null, null, null }, |
| 5609 | .patterns = &.{ | 8991 | .patterns = &.{ |
| 5610 | .{ .src = .{ .to_mem, .to_mem } }, | 8992 | .{ .src = .{ .to_mem, .to_mem } }, |
| 5611 | }, | 8993 | }, |
| ... | @@ -5618,18 +9000,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5618,18 +9000,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5618 | .unused, | 9000 | .unused, |
| 5619 | }, | 9001 | }, |
| 5620 | .dst_temps = .{.{ .cc = cc }}, | 9002 | .dst_temps = .{.{ .cc = cc }}, |
| | 9003 | .clobbers = .{ .eflags = true }, |
| 5621 | .each = .{ .once = &.{ | 9004 | .each = .{ .once = &.{ |
| 5622 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 9005 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 5623 | .{ ._, .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, | 9006 | .{ ._, .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 5624 | .{ .@"0:", .v_dqu, .mov, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 9007 | .{ .@"0:", .v_dqu, .mov, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 5625 | .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._ }, | 9008 | .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._ }, |
| 5626 | .{ ._, .vp_, .@"or", .tmp1x, .tmp1x, .tmp2x, ._ }, | 9009 | .{ ._, .vp_, .@"or", .tmp1x, .tmp1x, .tmp2x, ._ }, |
| 5627 | .{ ._, ._, .add, .tmp0p, .i(16), ._, ._ }, | 9010 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 5628 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 9011 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5629 | .{ ._, .vp_, .@"test", .tmp1x, .tmp1x, ._, ._ }, | 9012 | .{ ._, .vp_, .@"test", .tmp1x, .tmp1x, ._, ._ }, |
| 5630 | } }, | 9013 | } }, |
| 5631 | }, .{ | 9014 | }, .{ |
| 5632 | .required_features = .{ .sse4_1, null }, | 9015 | .required_features = .{ .sse4_1, null, null, null }, |
| 5633 | .patterns = &.{ | 9016 | .patterns = &.{ |
| 5634 | .{ .src = .{ .to_mem, .to_mem } }, | 9017 | .{ .src = .{ .to_mem, .to_mem } }, |
| 5635 | }, | 9018 | }, |
| ... | @@ -5642,18 +9025,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5642,18 +9025,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5642 | .unused, | 9025 | .unused, |
| 5643 | }, | 9026 | }, |
| 5644 | .dst_temps = .{.{ .cc = cc }}, | 9027 | .dst_temps = .{.{ .cc = cc }}, |
| | 9028 | .clobbers = .{ .eflags = true }, |
| 5645 | .each = .{ .once = &.{ | 9029 | .each = .{ .once = &.{ |
| 5646 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 9030 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 5647 | .{ ._, .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, | 9031 | .{ ._, .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 5648 | .{ .@"0:", ._dqu, .mov, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 9032 | .{ .@"0:", ._dqu, .mov, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 5649 | .{ ._, .p_, .xor, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, | 9033 | .{ ._, .p_, .xor, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 5650 | .{ ._, .p_, .@"or", .tmp1x, .tmp2x, ._, ._ }, | 9034 | .{ ._, .p_, .@"or", .tmp1x, .tmp2x, ._, ._ }, |
| 5651 | .{ ._, ._, .add, .tmp0p, .i(16), ._, ._ }, | 9035 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 5652 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 9036 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5653 | .{ ._, .p_, .@"test", .tmp1x, .tmp1x, ._, ._ }, | 9037 | .{ ._, .p_, .@"test", .tmp1x, .tmp1x, ._, ._ }, |
| 5654 | } }, | 9038 | } }, |
| 5655 | }, .{ | 9039 | }, .{ |
| 5656 | .required_features = .{ .sse2, null }, | 9040 | .required_features = .{ .sse2, null, null, null }, |
| 5657 | .patterns = &.{ | 9041 | .patterns = &.{ |
| 5658 | .{ .src = .{ .to_mem, .to_mem } }, | 9042 | .{ .src = .{ .to_mem, .to_mem } }, |
| 5659 | }, | 9043 | }, |
| ... | @@ -5666,21 +9050,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5666,21 +9050,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5666 | .unused, | 9050 | .unused, |
| 5667 | }, | 9051 | }, |
| 5668 | .dst_temps = .{.{ .cc = cc }}, | 9052 | .dst_temps = .{.{ .cc = cc }}, |
| | 9053 | .clobbers = .{ .eflags = true }, |
| 5669 | .each = .{ .once = &.{ | 9054 | .each = .{ .once = &.{ |
| 5670 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 9055 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 5671 | .{ ._, .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, | 9056 | .{ ._, .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 5672 | .{ .@"0:", ._dqu, .mov, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 9057 | .{ .@"0:", ._dqu, .mov, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 5673 | .{ ._, .p_, .xor, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, | 9058 | .{ ._, .p_, .xor, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 5674 | .{ ._, .p_, .@"or", .tmp1x, .tmp2x, ._, ._ }, | 9059 | .{ ._, .p_, .@"or", .tmp1x, .tmp2x, ._, ._ }, |
| 5675 | .{ ._, ._, .add, .tmp0p, .i(16), ._, ._ }, | 9060 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 5676 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 9061 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5677 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, | 9062 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 5678 | .{ ._, .p_b, .cmpeq, .tmp1x, .tmp2x, ._, ._ }, | 9063 | .{ ._, .p_b, .cmpeq, .tmp1x, .tmp2x, ._, ._ }, |
| 5679 | .{ ._, .p_b, .movmsk, .tmp0d, .tmp1x, ._, ._ }, | 9064 | .{ ._, .p_b, .movmsk, .tmp0d, .tmp1x, ._, ._ }, |
| 5680 | .{ ._, ._, .cmp, .tmp0d, .i(0xffff), ._, ._ }, | 9065 | .{ ._, ._, .cmp, .tmp0d, .si(0xffff), ._, ._ }, |
| 5681 | } }, | 9066 | } }, |
| 5682 | }, .{ | 9067 | }, .{ |
| 5683 | .required_features = .{ .sse, .mmx }, | 9068 | .required_features = .{ .sse, .mmx, null, null }, |
| 5684 | .patterns = &.{ | 9069 | .patterns = &.{ |
| 5685 | .{ .src = .{ .to_mem, .to_mem } }, | 9070 | .{ .src = .{ .to_mem, .to_mem } }, |
| 5686 | }, | 9071 | }, |
| ... | @@ -5693,18 +9078,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5693,18 +9078,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5693 | .unused, | 9078 | .unused, |
| 5694 | }, | 9079 | }, |
| 5695 | .dst_temps = .{.{ .cc = cc }}, | 9080 | .dst_temps = .{.{ .cc = cc }}, |
| | 9081 | .clobbers = .{ .eflags = true }, |
| 5696 | .each = .{ .once = &.{ | 9082 | .each = .{ .once = &.{ |
| 5697 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 9083 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 5698 | .{ ._, .p_, .xor, .tmp1q, .tmp1q, ._, ._ }, | 9084 | .{ ._, .p_, .xor, .tmp1q, .tmp1q, ._, ._ }, |
| 5699 | .{ .@"0:", ._q, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, | 9085 | .{ .@"0:", ._q, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 5700 | .{ ._, .p_, .xor, .tmp2q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, | 9086 | .{ ._, .p_, .xor, .tmp2q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 5701 | .{ ._, .p_, .@"or", .tmp1q, .tmp2q, ._, ._ }, | 9087 | .{ ._, .p_, .@"or", .tmp1q, .tmp2q, ._, ._ }, |
| 5702 | .{ ._, ._, .add, .tmp0p, .i(8), ._, ._ }, | 9088 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 5703 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 9089 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5704 | .{ ._, .p_, .xor, .tmp2q, .tmp2q, ._, ._ }, | 9090 | .{ ._, .p_, .xor, .tmp2q, .tmp2q, ._, ._ }, |
| 5705 | .{ ._, .p_b, .cmpeq, .tmp1q, .tmp2q, ._, ._ }, | 9091 | .{ ._, .p_b, .cmpeq, .tmp1q, .tmp2q, ._, ._ }, |
| 5706 | .{ ._, .p_b, .movmsk, .tmp0d, .tmp1q, ._, ._ }, | 9092 | .{ ._, .p_b, .movmsk, .tmp0d, .tmp1q, ._, ._ }, |
| 5707 | .{ ._, ._, .cmp, .tmp0d, .i(0xff), ._, ._ }, | 9093 | .{ ._, ._, .cmp, .tmp0d, .si(0xff), ._, ._ }, |
| 5708 | } }, | 9094 | } }, |
| 5709 | }, .{ | 9095 | }, .{ |
| 5710 | .patterns = &.{ | 9096 | .patterns = &.{ |
| ... | @@ -5719,13 +9105,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5719,13 +9105,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5719 | .unused, | 9105 | .unused, |
| 5720 | }, | 9106 | }, |
| 5721 | .dst_temps = .{.{ .cc = cc }}, | 9107 | .dst_temps = .{.{ .cc = cc }}, |
| | 9108 | .clobbers = .{ .eflags = true }, |
| 5722 | .each = .{ .once = &.{ | 9109 | .each = .{ .once = &.{ |
| 5723 | .{ ._, ._, .mov, .tmp0p, .a(.src0, .sub_size), ._, ._ }, | 9110 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 5724 | .{ ._, ._, .xor, .tmp1p, .tmp1p, ._, ._ }, | 9111 | .{ ._, ._, .xor, .tmp1p, .tmp1p, ._, ._ }, |
| 5725 | .{ .@"0:", ._, .mov, .tmp2p, .memia(.src0p, .tmp0, .add_size), ._, ._ }, | 9112 | .{ .@"0:", ._, .mov, .tmp2p, .memia(.src0p, .tmp0, .add_size), ._, ._ }, |
| 5726 | .{ ._, ._, .xor, .tmp2p, .memia(.src1p, .tmp0, .add_size), ._, ._ }, | 9113 | .{ ._, ._, .xor, .tmp2p, .memia(.src1p, .tmp0, .add_size), ._, ._ }, |
| 5727 | .{ ._, ._, .@"or", .tmp1p, .tmp2p, ._, ._ }, | 9114 | .{ ._, ._, .@"or", .tmp1p, .tmp2p, ._, ._ }, |
| 5728 | .{ ._, ._, .add, .tmp0p, .a(.tmp2, .add_size), ._, ._ }, | 9115 | .{ ._, ._, .add, .tmp0p, .sa(.tmp2, .add_size), ._, ._ }, |
| 5729 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 9116 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5730 | .{ ._, ._, .@"test", .tmp1p, .tmp1p, ._, ._ }, | 9117 | .{ ._, ._, .@"test", .tmp1p, .tmp1p, ._, ._ }, |
| 5731 | } }, | 9118 | } }, |
| ... | @@ -6453,11 +9840,8 @@ fn regClassForType(self: *CodeGen, ty: Type) Register.Class { | ... | @@ -6453,11 +9840,8 @@ fn regClassForType(self: *CodeGen, ty: Type) Register.Class { |
| 6453 | else => .sse, | 9840 | else => .sse, |
| 6454 | }, | 9841 | }, |
| 6455 | .vector => switch (ty.childType(zcu).toIntern()) { | 9842 | .vector => switch (ty.childType(zcu).toIntern()) { |
| 6456 | .bool_type, .u1_type => .general_purpose, | 9843 | .bool_type => .general_purpose, |
| 6457 | else => if (ty.isAbiInt(zcu) and ty.intInfo(zcu).bits == 1) | 9844 | else => .sse, |
| 6458 | .general_purpose | | |
| 6459 | else | | |
| 6460 | .sse, | | |
| 6461 | }, | 9845 | }, |
| 6462 | else => .general_purpose, | 9846 | else => .general_purpose, |
| 6463 | }; | 9847 | }; |
| ... | @@ -8383,32 +11767,54 @@ fn airMulWithOverflow(self: *CodeGen, inst: Air.Inst.Index) !void { | ... | @@ -8383,32 +11767,54 @@ fn airMulWithOverflow(self: *CodeGen, inst: Air.Inst.Index) !void { |
| 8383 | | 11767 | |
| 8384 | const lhs_mcv = try self.resolveInst(bin_op.lhs); | 11768 | const lhs_mcv = try self.resolveInst(bin_op.lhs); |
| 8385 | const rhs_mcv = try self.resolveInst(bin_op.rhs); | 11769 | const rhs_mcv = try self.resolveInst(bin_op.rhs); |
| 8386 | const mat_lhs_mcv = switch (lhs_mcv) { | 11770 | const mat_lhs_mcv = mat_lhs_mcv: switch (lhs_mcv) { |
| 8387 | .load_symbol => mat_lhs_mcv: { | 11771 | .register => |lhs_reg| switch (lhs_reg.class()) { |
| | 11772 | else => lhs_mcv, |
| | 11773 | .sse => { |
| | 11774 | const mat_lhs_mcv: MCValue = .{ |
| | 11775 | .register_pair = try self.register_manager.allocRegs(2, @splat(null), abi.RegisterClass.gp), |
| | 11776 | }; |
| | 11777 | try self.genCopy(dst_ty, mat_lhs_mcv, lhs_mcv, .{}); |
| | 11778 | break :mat_lhs_mcv mat_lhs_mcv; |
| | 11779 | }, |
| | 11780 | }, |
| | 11781 | .load_symbol => { |
| 8388 | // TODO clean this up! | 11782 | // TODO clean this up! |
| 8389 | const addr_reg = try self.copyToTmpRegister(.usize, lhs_mcv.address()); | 11783 | const addr_reg = try self.copyToTmpRegister(.usize, lhs_mcv.address()); |
| 8390 | break :mat_lhs_mcv MCValue{ .indirect = .{ .reg = addr_reg } }; | 11784 | break :mat_lhs_mcv MCValue{ .indirect = .{ .reg = addr_reg } }; |
| 8391 | }, | 11785 | }, |
| 8392 | else => lhs_mcv, | 11786 | else => lhs_mcv, |
| 8393 | }; | 11787 | }; |
| 8394 | const mat_lhs_lock = switch (mat_lhs_mcv) { | 11788 | const mat_lhs_locks: [2]?RegisterLock = switch (mat_lhs_mcv) { |
| 8395 | .indirect => |reg_off| self.register_manager.lockReg(reg_off.reg), | 11789 | .register_pair => |mat_lhs_regs| self.register_manager.lockRegs(2, mat_lhs_regs), |
| 8396 | else => null, | 11790 | .indirect => |reg_off| .{ self.register_manager.lockReg(reg_off.reg), null }, |
| | 11791 | else => @splat(null), |
| 8397 | }; | 11792 | }; |
| 8398 | defer if (mat_lhs_lock) |lock| self.register_manager.unlockReg(lock); | 11793 | defer for (mat_lhs_locks) |mat_lhs_lock| if (mat_lhs_lock) |lock| self.register_manager.unlockReg(lock); |
| 8399 | const mat_rhs_mcv = switch (rhs_mcv) { | 11794 | const mat_rhs_mcv = mat_rhs_mcv: switch (rhs_mcv) { |
| 8400 | .load_symbol => mat_rhs_mcv: { | 11795 | .register => |rhs_reg| switch (rhs_reg.class()) { |
| | 11796 | else => rhs_mcv, |
| | 11797 | .sse => { |
| | 11798 | const mat_rhs_mcv: MCValue = .{ |
| | 11799 | .register_pair = try self.register_manager.allocRegs(2, @splat(null), abi.RegisterClass.gp), |
| | 11800 | }; |
| | 11801 | try self.genCopy(dst_ty, mat_rhs_mcv, rhs_mcv, .{}); |
| | 11802 | break :mat_rhs_mcv mat_rhs_mcv; |
| | 11803 | }, |
| | 11804 | }, |
| | 11805 | .load_symbol => { |
| 8401 | // TODO clean this up! | 11806 | // TODO clean this up! |
| 8402 | const addr_reg = try self.copyToTmpRegister(.usize, rhs_mcv.address()); | 11807 | const addr_reg = try self.copyToTmpRegister(.usize, rhs_mcv.address()); |
| 8403 | break :mat_rhs_mcv MCValue{ .indirect = .{ .reg = addr_reg } }; | 11808 | break :mat_rhs_mcv MCValue{ .indirect = .{ .reg = addr_reg } }; |
| 8404 | }, | 11809 | }, |
| 8405 | else => rhs_mcv, | 11810 | else => rhs_mcv, |
| 8406 | }; | 11811 | }; |
| 8407 | const mat_rhs_lock = switch (mat_rhs_mcv) { | 11812 | const mat_rhs_locks: [2]?RegisterLock = switch (mat_rhs_mcv) { |
| 8408 | .indirect => |reg_off| self.register_manager.lockReg(reg_off.reg), | 11813 | .register_pair => |mat_rhs_regs| self.register_manager.lockRegs(2, mat_rhs_regs), |
| 8409 | else => null, | 11814 | .indirect => |reg_off| .{ self.register_manager.lockReg(reg_off.reg), null }, |
| | 11815 | else => @splat(null), |
| 8410 | }; | 11816 | }; |
| 8411 | defer if (mat_rhs_lock) |lock| self.register_manager.unlockReg(lock); | 11817 | defer for (mat_rhs_locks) |mat_rhs_lock| if (mat_rhs_lock) |lock| self.register_manager.unlockReg(lock); |
| 8412 | | 11818 | |
| 8413 | if (mat_lhs_mcv.isBase()) try self.asmRegisterMemory( | 11819 | if (mat_lhs_mcv.isBase()) try self.asmRegisterMemory( |
| 8414 | .{ ._, .mov }, | 11820 | .{ ._, .mov }, |
| ... | @@ -10003,7 +13409,7 @@ fn airClz(self: *CodeGen, inst: Air.Inst.Index) !void { | ... | @@ -10003,7 +13409,7 @@ fn airClz(self: *CodeGen, inst: Air.Inst.Index) !void { |
| 10003 | } }, | 13409 | } }, |
| 10004 | }, .u(0)); | 13410 | }, .u(0)); |
| 10005 | _ = try self.asmJccReloc(.e, loop); | 13411 | _ = try self.asmJccReloc(.e, loop); |
| 10006 | try self.asmRegisterMemory(.{ ._, .bsr }, dst_reg.to64(), .{ | 13412 | try self.asmRegisterMemory(.{ ._r, .bs }, dst_reg.to64(), .{ |
| 10007 | .base = .{ .frame = src_frame_addr.index }, | 13413 | .base = .{ .frame = src_frame_addr.index }, |
| 10008 | .mod = .{ .rm = .{ | 13414 | .mod = .{ .rm = .{ |
| 10009 | .size = .qword, | 13415 | .size = .qword, |
| ... | @@ -10080,8 +13486,8 @@ fn airClz(self: *CodeGen, inst: Air.Inst.Index) !void { | ... | @@ -10080,8 +13486,8 @@ fn airClz(self: *CodeGen, inst: Air.Inst.Index) !void { |
| 10080 | defer self.register_manager.unlockReg(wide_lock); | 13486 | defer self.register_manager.unlockReg(wide_lock); |
| 10081 | | 13487 | |
| 10082 | try self.truncateRegister(src_ty, wide_reg); | 13488 | try self.truncateRegister(src_ty, wide_reg); |
| 10083 | try self.genBinOpMir(.{ ._, .bsr }, .u16, dst_mcv, .{ .register = wide_reg }); | 13489 | try self.genBinOpMir(.{ ._r, .bs }, .u16, dst_mcv, .{ .register = wide_reg }); |
| 10084 | } else try self.genBinOpMir(.{ ._, .bsr }, src_ty, dst_mcv, mat_src_mcv); | 13490 | } else try self.genBinOpMir(.{ ._r, .bs }, src_ty, dst_mcv, mat_src_mcv); |
| 10085 | | 13491 | |
| 10086 | try self.asmCmovccRegisterRegister( | 13492 | try self.asmCmovccRegisterRegister( |
| 10087 | .z, | 13493 | .z, |
| ... | @@ -10103,7 +13509,7 @@ fn airClz(self: *CodeGen, inst: Air.Inst.Index) !void { | ... | @@ -10103,7 +13509,7 @@ fn airClz(self: *CodeGen, inst: Air.Inst.Index) !void { |
| 10103 | | 13509 | |
| 10104 | try self.truncateRegister(src_ty, wide_reg); | 13510 | try self.truncateRegister(src_ty, wide_reg); |
| 10105 | try self.genBinOpMir( | 13511 | try self.genBinOpMir( |
| 10106 | .{ ._, .bsr }, | 13512 | .{ ._r, .bs }, |
| 10107 | if (src_bits <= 8) .u16 else src_ty, | 13513 | if (src_bits <= 8) .u16 else src_ty, |
| 10108 | dst_mcv, | 13514 | dst_mcv, |
| 10109 | .{ .register = wide_reg }, | 13515 | .{ .register = wide_reg }, |
| ... | @@ -10200,7 +13606,7 @@ fn airCtz(self: *CodeGen, inst: Air.Inst.Index) !void { | ... | @@ -10200,7 +13606,7 @@ fn airCtz(self: *CodeGen, inst: Air.Inst.Index) !void { |
| 10200 | } }, | 13606 | } }, |
| 10201 | }, .u(0)); | 13607 | }, .u(0)); |
| 10202 | _ = try self.asmJccReloc(.e, loop); | 13608 | _ = try self.asmJccReloc(.e, loop); |
| 10203 | try self.asmRegisterMemory(.{ ._, .bsf }, dst_reg.to64(), .{ | 13609 | try self.asmRegisterMemory(.{ ._f, .bs }, dst_reg.to64(), .{ |
| 10204 | .base = .{ .frame = src_frame_addr.index }, | 13610 | .base = .{ .frame = src_frame_addr.index }, |
| 10205 | .mod = .{ .rm = .{ | 13611 | .mod = .{ .rm = .{ |
| 10206 | .size = .qword, | 13612 | .size = .qword, |
| ... | @@ -10280,8 +13686,8 @@ fn airCtz(self: *CodeGen, inst: Air.Inst.Index) !void { | ... | @@ -10280,8 +13686,8 @@ fn airCtz(self: *CodeGen, inst: Air.Inst.Index) !void { |
| 10280 | defer self.register_manager.unlockReg(wide_lock); | 13686 | defer self.register_manager.unlockReg(wide_lock); |
| 10281 | | 13687 | |
| 10282 | try self.truncateRegister(src_ty, wide_reg); | 13688 | try self.truncateRegister(src_ty, wide_reg); |
| 10283 | try self.genBinOpMir(.{ ._, .bsf }, wide_ty, dst_mcv, .{ .register = wide_reg }); | 13689 | try self.genBinOpMir(.{ ._f, .bs }, wide_ty, dst_mcv, .{ .register = wide_reg }); |
| 10284 | } else try self.genBinOpMir(.{ ._, .bsf }, src_ty, dst_mcv, mat_src_mcv); | 13690 | } else try self.genBinOpMir(.{ ._f, .bs }, src_ty, dst_mcv, mat_src_mcv); |
| 10285 | | 13691 | |
| 10286 | const cmov_abi_size = @max(@as(u32, @intCast(dst_ty.abiSize(zcu))), 2); | 13692 | const cmov_abi_size = @max(@as(u32, @intCast(dst_ty.abiSize(zcu))), 2); |
| 10287 | try self.asmCmovccRegisterRegister( | 13693 | try self.asmCmovccRegisterRegister( |
| ... | @@ -12975,7 +16381,18 @@ fn genShiftBinOp( | ... | @@ -12975,7 +16381,18 @@ fn genShiftBinOp( |
| 12975 | const rcx_lock = self.register_manager.lockReg(.rcx); | 16381 | const rcx_lock = self.register_manager.lockReg(.rcx); |
| 12976 | defer if (rcx_lock) |lock| self.register_manager.unlockReg(lock); | 16382 | defer if (rcx_lock) |lock| self.register_manager.unlockReg(lock); |
| 12977 | | 16383 | |
| 12978 | const lhs_lock = switch (lhs_mcv) { | 16384 | const mat_lhs_mcv: MCValue, const can_reuse_lhs = switch (lhs_mcv) { |
| | 16385 | .register => |lhs_reg| switch (lhs_reg.class()) { |
| | 16386 | .general_purpose => .{ lhs_mcv, true }, |
| | 16387 | else => lhs: { |
| | 16388 | const mat_lhs_mcv = try self.allocTempRegOrMem(lhs_ty, true); |
| | 16389 | try self.genCopy(lhs_ty, mat_lhs_mcv, lhs_mcv, .{}); |
| | 16390 | break :lhs .{ mat_lhs_mcv, false }; |
| | 16391 | }, |
| | 16392 | }, |
| | 16393 | else => .{ lhs_mcv, true }, |
| | 16394 | }; |
| | 16395 | const lhs_lock = switch (mat_lhs_mcv) { |
| 12979 | .register => |reg| self.register_manager.lockReg(reg), | 16396 | .register => |reg| self.register_manager.lockReg(reg), |
| 12980 | else => null, | 16397 | else => null, |
| 12981 | }; | 16398 | }; |
| ... | @@ -12988,12 +16405,12 @@ fn genShiftBinOp( | ... | @@ -12988,12 +16405,12 @@ fn genShiftBinOp( |
| 12988 | defer if (rhs_lock) |lock| self.register_manager.unlockReg(lock); | 16405 | defer if (rhs_lock) |lock| self.register_manager.unlockReg(lock); |
| 12989 | | 16406 | |
| 12990 | const dst_mcv: MCValue = dst: { | 16407 | const dst_mcv: MCValue = dst: { |
| 12991 | if (maybe_inst) |inst| { | 16408 | if (can_reuse_lhs) if (maybe_inst) |inst| { |
| 12992 | const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; | 16409 | const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; |
| 12993 | if (self.reuseOperand(inst, bin_op.lhs, 0, lhs_mcv)) break :dst lhs_mcv; | 16410 | if (self.reuseOperand(inst, bin_op.lhs, 0, mat_lhs_mcv)) break :dst mat_lhs_mcv; |
| 12994 | } | 16411 | }; |
| 12995 | const dst_mcv = try self.allocRegOrMemAdvanced(lhs_ty, maybe_inst, true); | 16412 | const dst_mcv = try self.allocRegOrMemAdvanced(lhs_ty, maybe_inst, true); |
| 12996 | try self.genCopy(lhs_ty, dst_mcv, lhs_mcv, .{}); | 16413 | try self.genCopy(lhs_ty, dst_mcv, mat_lhs_mcv, .{}); |
| 12997 | break :dst dst_mcv; | 16414 | break :dst dst_mcv; |
| 12998 | }; | 16415 | }; |
| 12999 | | 16416 | |
| ... | @@ -18337,12 +21754,28 @@ const MoveStrategy = union(enum) { | ... | @@ -18337,12 +21754,28 @@ const MoveStrategy = union(enum) { |
| 18337 | try self.asmRegister(.{ .f_, .ld }, src_reg); | 21754 | try self.asmRegister(.{ .f_, .ld }, src_reg); |
| 18338 | try self.asmMemory(.{ .f_p, .st }, dst_mem); | 21755 | try self.asmMemory(.{ .f_p, .st }, dst_mem); |
| 18339 | }, | 21756 | }, |
| 18340 | .insert_extract, .vex_insert_extract => |ie| try self.asmMemoryRegisterImmediate( | 21757 | .insert_extract, .vex_insert_extract => |ie| if (ie.extract[0] != .p_w or self.hasFeature(.sse4_1)) |
| 18341 | ie.extract, | 21758 | try self.asmMemoryRegisterImmediate(ie.extract, dst_mem, src_reg, .u(0)) |
| 18342 | dst_mem, | 21759 | else if (self.hasFeature(.sse2)) { |
| 18343 | src_reg, | 21760 | const tmp_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp); |
| 18344 | .u(0), | 21761 | try self.asmRegisterRegisterImmediate(ie.extract, tmp_reg.to32(), src_reg.to128(), .u(0)); |
| 18345 | ), | 21762 | try self.asmMemoryRegister(.{ ._, .mov }, dst_mem, tmp_reg.to16()); |
| | 21763 | } else { |
| | 21764 | const tmp_frame_index = try self.allocFrameIndex(.init(.{ |
| | 21765 | .size = 16, |
| | 21766 | .alignment = .@"16", |
| | 21767 | })); |
| | 21768 | try self.asmMemoryRegister(.{ ._ps, .mova }, .{ |
| | 21769 | .base = .{ .frame = tmp_frame_index }, |
| | 21770 | .mod = .{ .rm = .{ .size = .xword } }, |
| | 21771 | }, src_reg.to128()); |
| | 21772 | const tmp_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp); |
| | 21773 | try self.asmRegisterMemory(.{ ._, .mov }, tmp_reg.to16(), .{ |
| | 21774 | .base = .{ .frame = tmp_frame_index }, |
| | 21775 | .mod = .{ .rm = .{ .size = .word } }, |
| | 21776 | }); |
| | 21777 | try self.asmMemoryRegister(.{ ._, .mov }, dst_mem, tmp_reg.to16()); |
| | 21778 | }, |
| 18346 | } | 21779 | } |
| 18347 | } | 21780 | } |
| 18348 | }; | 21781 | }; |
| ... | @@ -18400,8 +21833,10 @@ fn moveStrategy(self: *CodeGen, ty: Type, class: Register.Class, aligned: bool) | ... | @@ -18400,8 +21833,10 @@ fn moveStrategy(self: *CodeGen, ty: Type, class: Register.Class, aligned: bool) |
| 18400 | .{ ._ss, .mov } }, | 21833 | .{ ._ss, .mov } }, |
| 18401 | 5...8 => return .{ .move = if (self.hasFeature(.avx)) | 21834 | 5...8 => return .{ .move = if (self.hasFeature(.avx)) |
| 18402 | .{ .v_sd, .mov } | 21835 | .{ .v_sd, .mov } |
| | 21836 | else if (self.hasFeature(.sse2)) |
| | 21837 | .{ ._sd, .mov } |
| 18403 | else | 21838 | else |
| 18404 | .{ ._sd, .mov } }, | 21839 | .{ ._ps, .movl } }, |
| 18405 | 9...16 => return .{ .move = if (self.hasFeature(.avx)) | 21840 | 9...16 => return .{ .move = if (self.hasFeature(.avx)) |
| 18406 | .{ .v_pd, if (aligned) .mova else .movu } | 21841 | .{ .v_pd, if (aligned) .mova else .movu } |
| 18407 | else if (self.hasFeature(.sse2)) | 21842 | else if (self.hasFeature(.sse2)) |
| ... | @@ -18427,8 +21862,10 @@ fn moveStrategy(self: *CodeGen, ty: Type, class: Register.Class, aligned: bool) | ... | @@ -18427,8 +21862,10 @@ fn moveStrategy(self: *CodeGen, ty: Type, class: Register.Class, aligned: bool) |
| 18427 | .{ ._ss, .mov } }, | 21862 | .{ ._ss, .mov } }, |
| 18428 | 64 => return .{ .move = if (self.hasFeature(.avx)) | 21863 | 64 => return .{ .move = if (self.hasFeature(.avx)) |
| 18429 | .{ .v_sd, .mov } | 21864 | .{ .v_sd, .mov } |
| | 21865 | else if (self.hasFeature(.sse2)) |
| | 21866 | .{ ._sd, .mov } |
| 18430 | else | 21867 | else |
| 18431 | .{ ._sd, .mov } }, | 21868 | .{ ._ps, .movl } }, |
| 18432 | 128 => return .{ .move = if (self.hasFeature(.avx)) | 21869 | 128 => return .{ .move = if (self.hasFeature(.avx)) |
| 18433 | .{ if (aligned) .v_dqa else .v_dqu, .mov } | 21870 | .{ if (aligned) .v_dqa else .v_dqu, .mov } |
| 18434 | else if (self.hasFeature(.sse2)) | 21871 | else if (self.hasFeature(.sse2)) |
| ... | @@ -18623,6 +22060,30 @@ fn genCopy(self: *CodeGen, ty: Type, dst_mcv: MCValue, src_mcv: MCValue, opts: C | ... | @@ -18623,6 +22060,30 @@ fn genCopy(self: *CodeGen, ty: Type, dst_mcv: MCValue, src_mcv: MCValue, opts: C |
| 18623 | }, opts), | 22060 | }, opts), |
| 18624 | inline .register_pair, .register_triple, .register_quadruple => |dst_regs| { | 22061 | inline .register_pair, .register_triple, .register_quadruple => |dst_regs| { |
| 18625 | const src_info: ?struct { addr_reg: Register, addr_lock: RegisterLock } = switch (src_mcv) { | 22062 | const src_info: ?struct { addr_reg: Register, addr_lock: RegisterLock } = switch (src_mcv) { |
| | 22063 | .register => |src_reg| switch (dst_regs[0].class()) { |
| | 22064 | .general_purpose => switch (src_reg.class()) { |
| | 22065 | else => unreachable, |
| | 22066 | .sse => if (ty.abiSize(pt.zcu) <= 16) { |
| | 22067 | if (self.hasFeature(.avx)) { |
| | 22068 | try self.asmRegisterRegister(.{ .v_q, .mov }, dst_regs[0].to64(), src_reg.to128()); |
| | 22069 | try self.asmRegisterRegisterImmediate(.{ .vp_q, .extr }, dst_regs[1].to64(), src_reg.to128(), .u(1)); |
| | 22070 | } else if (self.hasFeature(.sse4_1)) { |
| | 22071 | try self.asmRegisterRegister(.{ ._q, .mov }, dst_regs[0].to64(), src_reg.to128()); |
| | 22072 | try self.asmRegisterRegisterImmediate(.{ .p_q, .extr }, dst_regs[1].to64(), src_reg.to128(), .u(1)); |
| | 22073 | } else { |
| | 22074 | const tmp_reg = try self.register_manager.allocReg(null, abi.RegisterClass.sse); |
| | 22075 | const tmp_lock = self.register_manager.lockRegAssumeUnused(tmp_reg); |
| | 22076 | defer self.register_manager.unlockReg(tmp_lock); |
| | 22077 | |
| | 22078 | try self.asmRegisterRegister(.{ ._q, .mov }, dst_regs[0].to64(), src_reg.to128()); |
| | 22079 | try self.asmRegisterRegister(.{ ._ps, .movhl }, tmp_reg.to128(), src_reg.to128()); |
| | 22080 | try self.asmRegisterRegister(.{ ._q, .mov }, dst_regs[1].to64(), src_reg.to128()); |
| | 22081 | } |
| | 22082 | return; |
| | 22083 | } else unreachable, |
| | 22084 | }, |
| | 22085 | else => unreachable, |
| | 22086 | }, |
| 18626 | .register_pair, .memory, .indirect, .load_frame => null, | 22087 | .register_pair, .memory, .indirect, .load_frame => null, |
| 18627 | .load_symbol, .load_direct, .load_got, .load_tlv => src: { | 22088 | .load_symbol, .load_direct, .load_got, .load_tlv => src: { |
| 18628 | const src_addr_reg = | 22089 | const src_addr_reg = |
| ... | @@ -18863,7 +22324,39 @@ fn genSetReg( | ... | @@ -18863,7 +22324,39 @@ fn genSetReg( |
| 18863 | inline .register_pair, | 22324 | inline .register_pair, |
| 18864 | .register_triple, | 22325 | .register_triple, |
| 18865 | .register_quadruple, | 22326 | .register_quadruple, |
| 18866 | => |src_regs| try self.genSetReg(dst_reg, ty, .{ .register = src_regs[0] }, opts), | 22327 | => |src_regs| switch (dst_reg.class()) { |
| | 22328 | .general_purpose => switch (src_regs[0].class()) { |
| | 22329 | .general_purpose => try self.genSetReg(dst_reg, ty, .{ .register = src_regs[0] }, opts), |
| | 22330 | else => unreachable, |
| | 22331 | }, |
| | 22332 | .sse => switch (src_regs[0].class()) { |
| | 22333 | .general_purpose => if (abi_size <= 16) { |
| | 22334 | if (self.hasFeature(.avx)) { |
| | 22335 | try self.asmRegisterRegister(.{ .v_q, .mov }, dst_reg.to128(), src_regs[0].to64()); |
| | 22336 | try self.asmRegisterRegisterRegisterImmediate( |
| | 22337 | .{ .vp_q, .insr }, |
| | 22338 | dst_reg.to128(), |
| | 22339 | dst_reg.to128(), |
| | 22340 | src_regs[1].to64(), |
| | 22341 | .u(1), |
| | 22342 | ); |
| | 22343 | } else if (self.hasFeature(.sse4_1)) { |
| | 22344 | try self.asmRegisterRegister(.{ ._q, .mov }, dst_reg.to128(), src_regs[0].to64()); |
| | 22345 | try self.asmRegisterRegisterImmediate(.{ .p_q, .insr }, dst_reg.to128(), src_regs[1].to64(), .u(1)); |
| | 22346 | } else { |
| | 22347 | const tmp_reg = try self.register_manager.allocReg(null, abi.RegisterClass.sse); |
| | 22348 | const tmp_lock = self.register_manager.lockRegAssumeUnused(tmp_reg); |
| | 22349 | defer self.register_manager.unlockReg(tmp_lock); |
| | 22350 | |
| | 22351 | try self.asmRegisterRegister(.{ ._q, .mov }, dst_reg.to128(), src_regs[0].to64()); |
| | 22352 | try self.asmRegisterRegister(.{ ._q, .mov }, tmp_reg.to128(), src_regs[1].to64()); |
| | 22353 | try self.asmRegisterRegister(.{ ._ps, .movlh }, dst_reg.to128(), tmp_reg.to128()); |
| | 22354 | } |
| | 22355 | } else unreachable, |
| | 22356 | else => unreachable, |
| | 22357 | }, |
| | 22358 | else => unreachable, |
| | 22359 | }, |
| 18867 | .register_offset, | 22360 | .register_offset, |
| 18868 | .indirect, | 22361 | .indirect, |
| 18869 | .load_frame, | 22362 | .load_frame, |
| ... | @@ -23517,8 +27010,6 @@ fn promoteVarArg(self: *CodeGen, ty: Type) Type { | ... | @@ -23517,8 +27010,6 @@ fn promoteVarArg(self: *CodeGen, ty: Type) Type { |
| 23517 | } | 27010 | } |
| 23518 | } | 27011 | } |
| 23519 | | 27012 | |
| 23520 | // ====================================== rewrite starts here ====================================== | | |
| 23521 | | | |
| 23522 | const Temp = struct { | 27013 | const Temp = struct { |
| 23523 | index: Air.Inst.Index, | 27014 | index: Air.Inst.Index, |
| 23524 | | 27015 | |
| ... | @@ -24311,13 +27802,13 @@ const Select = struct { | ... | @@ -24311,13 +27802,13 @@ const Select = struct { |
| 24311 | } | 27802 | } |
| 24312 | | 27803 | |
| 24313 | const Case = struct { | 27804 | const Case = struct { |
| 24314 | required_features: [2]?std.Target.x86.Feature = @splat(null), | 27805 | required_features: [4]?std.Target.x86.Feature = @splat(null), |
| 24315 | dst_constraints: [@intFromEnum(Select.Operand.Ref.src0) - @intFromEnum(Select.Operand.Ref.dst0)]Constraint = @splat(.any), | 27806 | dst_constraints: [@intFromEnum(Select.Operand.Ref.src0) - @intFromEnum(Select.Operand.Ref.dst0)]Constraint = @splat(.any), |
| 24316 | src_constraints: [@intFromEnum(Select.Operand.Ref.none) - @intFromEnum(Select.Operand.Ref.src0)]Constraint = @splat(.any), | 27807 | src_constraints: [@intFromEnum(Select.Operand.Ref.none) - @intFromEnum(Select.Operand.Ref.src0)]Constraint = @splat(.any), |
| 24317 | patterns: []const Select.Pattern, | 27808 | patterns: []const Select.Pattern, |
| 24318 | clobbers: struct { eflags: bool = false } = .{}, | | |
| 24319 | extra_temps: [@intFromEnum(Select.Operand.Ref.dst0) - @intFromEnum(Select.Operand.Ref.tmp0)]TempSpec = @splat(.unused), | 27809 | extra_temps: [@intFromEnum(Select.Operand.Ref.dst0) - @intFromEnum(Select.Operand.Ref.tmp0)]TempSpec = @splat(.unused), |
| 24320 | dst_temps: [@intFromEnum(Select.Operand.Ref.src0) - @intFromEnum(Select.Operand.Ref.dst0)]TempSpec.Kind = @splat(.unused), | 27810 | dst_temps: [@intFromEnum(Select.Operand.Ref.src0) - @intFromEnum(Select.Operand.Ref.dst0)]TempSpec.Kind = @splat(.unused), |
| | 27811 | clobbers: struct { eflags: bool = false } = .{}, |
| 24321 | each: union(enum) { | 27812 | each: union(enum) { |
| 24322 | once: []const Instruction, | 27813 | once: []const Instruction, |
| 24323 | }, | 27814 | }, |
| ... | @@ -24327,9 +27818,32 @@ const Select = struct { | ... | @@ -24327,9 +27818,32 @@ const Select = struct { |
| 24327 | any, | 27818 | any, |
| 24328 | any_bool_vec, | 27819 | any_bool_vec, |
| 24329 | any_int, | 27820 | any_int, |
| | 27821 | any_signed_int, |
| 24330 | any_float, | 27822 | any_float, |
| 24331 | bool_vec: Memory.Size, | 27823 | bool_vec: Memory.Size, |
| | 27824 | vec: Memory.Size, |
| | 27825 | signed_int_vec: Memory.Size, |
| | 27826 | signed_int_or_full_vec: Memory.Size, |
| | 27827 | unsigned_int_vec: Memory.Size, |
| | 27828 | int_or_vec: Memory.Size, |
| | 27829 | exact_remainder_int_or_vec: struct { of: Memory.Size, is: Memory.Size }, |
| 24332 | int: Memory.Size, | 27830 | int: Memory.Size, |
| | 27831 | scalar_int: Memory.Size, |
| | 27832 | scalar_signed_int: Memory.Size, |
| | 27833 | scalar_unsigned_int: Memory.Size, |
| | 27834 | scalar_remainder_int: struct { of: Memory.Size, is: Memory.Size }, |
| | 27835 | exact_int: u16, |
| | 27836 | exact_signed_int: u16, |
| | 27837 | exact_unsigned_int: u16, |
| | 27838 | signed_or_exact_int: Memory.Size, |
| | 27839 | unsigned_or_exact_int: Memory.Size, |
| | 27840 | po2_int: Memory.Size, |
| | 27841 | signed_po2_int: Memory.Size, |
| | 27842 | unsigned_po2_or_exact_int: Memory.Size, |
| | 27843 | remainder_int: struct { of: Memory.Size, is: Memory.Size }, |
| | 27844 | exact_remainder_int: struct { of: Memory.Size, is: Memory.Size }, |
| | 27845 | signed_or_exact_remainder_int: struct { of: Memory.Size, is: Memory.Size }, |
| | 27846 | unsigned_or_exact_remainder_int: struct { of: Memory.Size, is: Memory.Size }, |
| 24333 | signed_int: Memory.Size, | 27847 | signed_int: Memory.Size, |
| 24334 | unsigned_int: Memory.Size, | 27848 | unsigned_int: Memory.Size, |
| 24335 | | 27849 | |
| ... | @@ -24338,30 +27852,183 @@ const Select = struct { | ... | @@ -24338,30 +27852,183 @@ const Select = struct { |
| 24338 | switch (constraint) { | 27852 | switch (constraint) { |
| 24339 | .any => return true, | 27853 | .any => return true, |
| 24340 | .any_bool_vec => return ty.isVector(zcu) and ty.scalarType(zcu).toIntern() == .bool_type, | 27854 | .any_bool_vec => return ty.isVector(zcu) and ty.scalarType(zcu).toIntern() == .bool_type, |
| 24341 | .any_int => { | 27855 | .any_int => return ty.toIntern() == .bool_type or ty.isPtrAtRuntime(zcu) or ty.isAbiInt(zcu), |
| | 27856 | .any_signed_int => return ty.isAbiInt(zcu) and ty.intInfo(zcu).signedness == .signed, |
| | 27857 | .any_float => return ty.scalarType(zcu).isRuntimeFloat(), |
| | 27858 | .bool_vec => |size| return ty.isVector(zcu) and ty.scalarType(zcu).toIntern() == .bool_type and |
| | 27859 | size.bitSize(cg.target) >= ty.vectorLen(zcu), |
| | 27860 | .vec => |size| return ty.isVector(zcu) and ty.scalarType(zcu).toIntern() != .bool_type and |
| | 27861 | size.bitSize(cg.target) >= ty.abiSize(zcu), |
| | 27862 | .signed_int_vec => |size| { |
| | 27863 | if (!ty.isVector(zcu) or size.bitSize(cg.target) < 8 * ty.abiSize(zcu)) return false; |
| 24342 | const scalar_ty = ty.scalarType(zcu); | 27864 | const scalar_ty = ty.scalarType(zcu); |
| 24343 | return scalar_ty.isAbiInt(zcu) or scalar_ty.isPtrAtRuntime(zcu); | 27865 | return scalar_ty.isAbiInt(zcu) and scalar_ty.intInfo(zcu).signedness == .signed; |
| | 27866 | }, |
| | 27867 | .signed_int_or_full_vec => |size| { |
| | 27868 | if (!ty.isVector(zcu) or size.bitSize(cg.target) < 8 * ty.abiSize(zcu)) return false; |
| | 27869 | const scalar_ty = ty.scalarType(zcu); |
| | 27870 | if (scalar_ty.isPtrAtRuntime(zcu)) return true; |
| | 27871 | if (!scalar_ty.isAbiInt(zcu)) return false; |
| | 27872 | const scalar_int_info = scalar_ty.intInfo(zcu); |
| | 27873 | return switch (scalar_int_info.signedness) { |
| | 27874 | .signed => true, |
| | 27875 | .unsigned => scalar_int_info.bits >= 8 and std.math.isPowerOfTwo(scalar_int_info.bits), |
| | 27876 | }; |
| | 27877 | }, |
| | 27878 | .unsigned_int_vec => |size| { |
| | 27879 | if (!ty.isVector(zcu) or size.bitSize(cg.target) < ty.bitSize(zcu)) return false; |
| | 27880 | const scalar_ty = ty.scalarType(zcu); |
| | 27881 | if (scalar_ty.isPtrAtRuntime(zcu)) return true; |
| | 27882 | return scalar_ty.isAbiInt(zcu) and scalar_ty.intInfo(zcu).signedness == .unsigned; |
| | 27883 | }, |
| | 27884 | .int_or_vec => |size| { |
| | 27885 | if (ty.isVector(zcu)) return ty.scalarType(zcu).toIntern() != .bool_type and |
| | 27886 | size.bitSize(cg.target) >= 8 * ty.abiSize(zcu); |
| | 27887 | if (ty.toIntern() == .bool_type) return true; |
| | 27888 | if (ty.isPtrAtRuntime(zcu)) return size.bitSize(cg.target) >= cg.target.ptrBitWidth(); |
| | 27889 | return ty.isAbiInt(zcu) and size.bitSize(cg.target) >= ty.intInfo(zcu).bits; |
| | 27890 | }, |
| | 27891 | .exact_remainder_int_or_vec => |of_is| { |
| | 27892 | if (ty.isVector(zcu)) return ty.scalarType(zcu).toIntern() != .bool_type and |
| | 27893 | of_is.is.bitSize(cg.target) == (8 * ty.abiSize(zcu) - 1) % of_is.of.bitSize(cg.target) + 1; |
| | 27894 | if (ty.isPtrAtRuntime(zcu)) |
| | 27895 | return of_is.is.bitSize(cg.target) == (cg.target.ptrBitWidth() - 1) % of_is.of.bitSize(cg.target) + 1; |
| | 27896 | if (!ty.isAbiInt(zcu)) return false; |
| | 27897 | return of_is.is.bitSize(cg.target) == (ty.intInfo(zcu).bits - 1) % of_is.of.bitSize(cg.target) + 1; |
| 24344 | }, | 27898 | }, |
| 24345 | .any_float => return ty.scalarType(zcu).isRuntimeFloat(), | | |
| 24346 | .bool_vec => |size| return ty.isVector(zcu) and | | |
| 24347 | ty.scalarType(zcu).toIntern() == .bool_type and ty.vectorLen(zcu) <= size.bitSize(cg.target), | | |
| 24348 | .int => |size| { | 27899 | .int => |size| { |
| | 27900 | if (ty.toIntern() == .bool_type) return true; |
| | 27901 | if (ty.isPtrAtRuntime(zcu)) return size.bitSize(cg.target) >= cg.target.ptrBitWidth(); |
| | 27902 | return ty.isAbiInt(zcu) and size.bitSize(cg.target) >= ty.intInfo(zcu).bits; |
| | 27903 | }, |
| | 27904 | .scalar_int => |size| { |
| 24349 | const scalar_ty = ty.scalarType(zcu); | 27905 | const scalar_ty = ty.scalarType(zcu); |
| 24350 | if (scalar_ty.isPtrAtRuntime(zcu)) return cg.target.ptrBitWidth() <= size.bitSize(cg.target); | 27906 | if (scalar_ty.isPtrAtRuntime(zcu)) return size.bitSize(cg.target) >= cg.target.ptrBitWidth(); |
| 24351 | return scalar_ty.isAbiInt(zcu) and scalar_ty.intInfo(zcu).bits <= size.bitSize(cg.target); | 27907 | return scalar_ty.isAbiInt(zcu) and size.bitSize(cg.target) >= scalar_ty.intInfo(zcu).bits; |
| 24352 | }, | 27908 | }, |
| 24353 | .signed_int => |size| { | 27909 | .scalar_signed_int => |size| { |
| 24354 | const scalar_ty = ty.scalarType(zcu); | 27910 | const scalar_ty = ty.scalarType(zcu); |
| 24355 | if (!scalar_ty.isAbiInt(zcu)) return false; | 27911 | if (!scalar_ty.isAbiInt(zcu)) return false; |
| 24356 | const info = scalar_ty.intInfo(zcu); | 27912 | const scalar_int_info = scalar_ty.intInfo(zcu); |
| 24357 | return info.signedness == .signed and info.bits <= size.bitSize(cg.target); | 27913 | return scalar_int_info.signedness == .signed and size.bitSize(cg.target) >= scalar_int_info.bits; |
| 24358 | }, | 27914 | }, |
| 24359 | .unsigned_int => |size| { | 27915 | .scalar_unsigned_int => |size| { |
| | 27916 | const scalar_ty = ty.scalarType(zcu); |
| | 27917 | if (scalar_ty.isPtrAtRuntime(zcu)) return size.bitSize(cg.target) >= cg.target.ptrBitWidth(); |
| | 27918 | if (!scalar_ty.isAbiInt(zcu)) return false; |
| | 27919 | const scalar_int_info = scalar_ty.intInfo(zcu); |
| | 27920 | return scalar_int_info.signedness == .unsigned and size.bitSize(cg.target) >= scalar_int_info.bits; |
| | 27921 | }, |
| | 27922 | .scalar_remainder_int => |of_is| { |
| 24360 | const scalar_ty = ty.scalarType(zcu); | 27923 | const scalar_ty = ty.scalarType(zcu); |
| 24361 | if (scalar_ty.isPtrAtRuntime(zcu)) return cg.target.ptrBitWidth() <= size.bitSize(cg.target); | 27924 | if (scalar_ty.isPtrAtRuntime(zcu)) |
| | 27925 | return of_is.is.bitSize(cg.target) >= (cg.target.ptrBitWidth() - 1) % of_is.of.bitSize(cg.target) + 1; |
| 24362 | if (!scalar_ty.isAbiInt(zcu)) return false; | 27926 | if (!scalar_ty.isAbiInt(zcu)) return false; |
| 24363 | const info = scalar_ty.intInfo(zcu); | 27927 | return of_is.is.bitSize(cg.target) >= (scalar_ty.intInfo(zcu).bits - 1) % of_is.of.bitSize(cg.target) + 1; |
| 24364 | return info.signedness == .unsigned and info.bits <= size.bitSize(cg.target); | 27928 | }, |
| | 27929 | .exact_int => |bit_size| { |
| | 27930 | if (ty.toIntern() == .bool_type) return bit_size == 1; |
| | 27931 | if (ty.isPtrAtRuntime(zcu)) return bit_size == cg.target.ptrBitWidth(); |
| | 27932 | return ty.isAbiInt(zcu) and bit_size == ty.intInfo(zcu).bits; |
| | 27933 | }, |
| | 27934 | .exact_signed_int => |bit_size| { |
| | 27935 | if (!ty.isAbiInt(zcu)) return false; |
| | 27936 | const int_info = ty.intInfo(zcu); |
| | 27937 | return int_info.signedness == .signed and bit_size == int_info.bits; |
| | 27938 | }, |
| | 27939 | .exact_unsigned_int => |bit_size| { |
| | 27940 | if (ty.toIntern() == .bool_type) return bit_size == 1; |
| | 27941 | if (ty.isPtrAtRuntime(zcu)) return bit_size == cg.target.ptrBitWidth(); |
| | 27942 | if (!ty.isAbiInt(zcu)) return false; |
| | 27943 | const int_info = ty.intInfo(zcu); |
| | 27944 | return int_info.signedness == .unsigned and bit_size == int_info.bits; |
| | 27945 | }, |
| | 27946 | .signed_or_exact_int => |size| { |
| | 27947 | if (ty.isPtrAtRuntime(zcu)) return size.bitSize(cg.target) == cg.target.ptrBitWidth(); |
| | 27948 | if (!ty.isAbiInt(zcu)) return false; |
| | 27949 | const int_info = ty.intInfo(zcu); |
| | 27950 | return switch (int_info.signedness) { |
| | 27951 | .signed => size.bitSize(cg.target) >= int_info.bits, |
| | 27952 | .unsigned => size.bitSize(cg.target) == int_info.bits, |
| | 27953 | }; |
| | 27954 | }, |
| | 27955 | .unsigned_or_exact_int => |size| { |
| | 27956 | if (ty.toIntern() == .bool_type or ty.isPtrAtRuntime(zcu)) return true; |
| | 27957 | if (!ty.isAbiInt(zcu)) return false; |
| | 27958 | const int_info = ty.intInfo(zcu); |
| | 27959 | return switch (int_info.signedness) { |
| | 27960 | .signed => size.bitSize(cg.target) == int_info.bits, |
| | 27961 | .unsigned => size.bitSize(cg.target) >= int_info.bits, |
| | 27962 | }; |
| | 27963 | }, |
| | 27964 | .po2_int => |size| { |
| | 27965 | if (ty.toIntern() == .bool_type) return true; |
| | 27966 | if (ty.isPtrAtRuntime(zcu)) return size.bitSize(cg.target) >= cg.target.ptrBitWidth(); |
| | 27967 | if (!ty.isAbiInt(zcu)) return false; |
| | 27968 | const bit_size = ty.intInfo(zcu).bits; |
| | 27969 | return std.math.isPowerOfTwo(bit_size) and size.bitSize(cg.target) >= bit_size; |
| | 27970 | }, |
| | 27971 | .signed_po2_int => |size| { |
| | 27972 | if (!ty.isAbiInt(zcu)) return false; |
| | 27973 | const int_info = ty.intInfo(zcu); |
| | 27974 | return int_info.signedness == .signed and std.math.isPowerOfTwo(int_info.bits) and |
| | 27975 | size.bitSize(cg.target) >= int_info.bits; |
| | 27976 | }, |
| | 27977 | .unsigned_po2_or_exact_int => |size| { |
| | 27978 | if (ty.toIntern() == .bool_type) return true; |
| | 27979 | if (ty.isPtrAtRuntime(zcu)) return size.bitSize(cg.target) >= cg.target.ptrBitWidth(); |
| | 27980 | if (!ty.isAbiInt(zcu)) return false; |
| | 27981 | const int_info = ty.intInfo(zcu); |
| | 27982 | return switch (int_info.signedness) { |
| | 27983 | .signed => size.bitSize(cg.target) == int_info.bits, |
| | 27984 | .unsigned => std.math.isPowerOfTwo(int_info.bits) and size.bitSize(cg.target) >= int_info.bits, |
| | 27985 | }; |
| | 27986 | }, |
| | 27987 | .remainder_int => |of_is| { |
| | 27988 | if (ty.toIntern() == .bool_type) return true; |
| | 27989 | if (ty.isPtrAtRuntime(zcu)) |
| | 27990 | return of_is.is.bitSize(cg.target) >= (cg.target.ptrBitWidth() - 1) % of_is.of.bitSize(cg.target) + 1; |
| | 27991 | if (!ty.isAbiInt(zcu)) return false; |
| | 27992 | return of_is.is.bitSize(cg.target) >= (ty.intInfo(zcu).bits - 1) % of_is.of.bitSize(cg.target) + 1; |
| | 27993 | }, |
| | 27994 | .exact_remainder_int => |of_is| { |
| | 27995 | if (ty.isPtrAtRuntime(zcu)) |
| | 27996 | return of_is.is.bitSize(cg.target) == (cg.target.ptrBitWidth() - 1) % of_is.of.bitSize(cg.target) + 1; |
| | 27997 | if (!ty.isAbiInt(zcu)) return false; |
| | 27998 | return of_is.is.bitSize(cg.target) == (ty.intInfo(zcu).bits - 1) % of_is.of.bitSize(cg.target) + 1; |
| | 27999 | }, |
| | 28000 | .signed_or_exact_remainder_int => |of_is| { |
| | 28001 | if (ty.isPtrAtRuntime(zcu)) |
| | 28002 | return of_is.is.bitSize(cg.target) == (cg.target.ptrBitWidth() - 1) % of_is.of.bitSize(cg.target) + 1; |
| | 28003 | if (!ty.isAbiInt(zcu)) return false; |
| | 28004 | const int_info = ty.intInfo(zcu); |
| | 28005 | return switch (int_info.signedness) { |
| | 28006 | .signed => of_is.is.bitSize(cg.target) >= (int_info.bits - 1) % of_is.of.bitSize(cg.target) + 1, |
| | 28007 | .unsigned => of_is.is.bitSize(cg.target) == (int_info.bits - 1) % of_is.of.bitSize(cg.target) + 1, |
| | 28008 | }; |
| | 28009 | }, |
| | 28010 | .unsigned_or_exact_remainder_int => |of_is| { |
| | 28011 | if (ty.toIntern() == .bool_type) return true; |
| | 28012 | if (ty.isPtrAtRuntime(zcu)) |
| | 28013 | return of_is.is.bitSize(cg.target) >= (cg.target.ptrBitWidth() - 1) % of_is.of.bitSize(cg.target) + 1; |
| | 28014 | if (!ty.isAbiInt(zcu)) return false; |
| | 28015 | const int_info = ty.intInfo(zcu); |
| | 28016 | return switch (int_info.signedness) { |
| | 28017 | .signed => of_is.is.bitSize(cg.target) == (int_info.bits - 1) % of_is.of.bitSize(cg.target) + 1, |
| | 28018 | .unsigned => of_is.is.bitSize(cg.target) >= (int_info.bits - 1) % of_is.of.bitSize(cg.target) + 1, |
| | 28019 | }; |
| | 28020 | }, |
| | 28021 | .signed_int => |size| { |
| | 28022 | if (!ty.isAbiInt(zcu)) return false; |
| | 28023 | const int_info = ty.intInfo(zcu); |
| | 28024 | return int_info.signedness == .signed and size.bitSize(cg.target) >= int_info.bits; |
| | 28025 | }, |
| | 28026 | .unsigned_int => |size| { |
| | 28027 | if (ty.toIntern() == .bool_type) return true; |
| | 28028 | if (ty.isPtrAtRuntime(zcu)) return size.bitSize(cg.target) >= cg.target.ptrBitWidth(); |
| | 28029 | if (!ty.isAbiInt(zcu)) return false; |
| | 28030 | const int_info = ty.intInfo(zcu); |
| | 28031 | return int_info.signedness == .unsigned and size.bitSize(cg.target) >= int_info.bits; |
| 24365 | }, | 28032 | }, |
| 24366 | } | 28033 | } |
| 24367 | } | 28034 | } |
| ... | @@ -24379,97 +28046,107 @@ const Select = struct { | ... | @@ -24379,97 +28046,107 @@ const Select = struct { |
| 24379 | imm32, | 28046 | imm32, |
| 24380 | simm32, | 28047 | simm32, |
| 24381 | mem, | 28048 | mem, |
| 24382 | mut_mem, | | |
| 24383 | to_mem, | 28049 | to_mem, |
| | 28050 | mut_mem, |
| | 28051 | to_mut_mem, |
| 24384 | gpr, | 28052 | gpr, |
| | 28053 | to_gpr, |
| 24385 | mut_gpr, | 28054 | mut_gpr, |
| | 28055 | to_mut_gpr, |
| 24386 | mm, | 28056 | mm, |
| | 28057 | to_mm, |
| 24387 | mut_mm, | 28058 | mut_mm, |
| | 28059 | to_mut_mm, |
| 24388 | xmm, | 28060 | xmm, |
| | 28061 | to_xmm, |
| 24389 | mut_xmm, | 28062 | mut_xmm, |
| | 28063 | to_mut_xmm, |
| 24390 | ymm, | 28064 | ymm, |
| | 28065 | to_ymm, |
| 24391 | mut_ymm, | 28066 | mut_ymm, |
| | 28067 | to_mut_ymm, |
| 24392 | | 28068 | |
| 24393 | fn matches(src: Src, temp: Temp, cg: *CodeGen) bool { | 28069 | fn matches(src: Src, temp: Temp, cg: *CodeGen) bool { |
| 24394 | switch (src) { | 28070 | return switch (src) { |
| 24395 | .none => unreachable, | 28071 | .none => unreachable, |
| 24396 | .any => return true, | 28072 | .any => true, |
| 24397 | .imm8 => return switch (temp.tracking(cg).short) { | 28073 | .imm8 => switch (temp.tracking(cg).short) { |
| 24398 | .immediate => |imm| std.math.cast(u8, imm) != null, | 28074 | .immediate => |imm| std.math.cast(u8, imm) != null, |
| 24399 | else => false, | 28075 | else => false, |
| 24400 | }, | 28076 | }, |
| 24401 | .imm16 => return switch (temp.tracking(cg).short) { | 28077 | .imm16 => switch (temp.tracking(cg).short) { |
| 24402 | .immediate => |imm| std.math.cast(u16, imm) != null, | 28078 | .immediate => |imm| std.math.cast(u16, imm) != null, |
| 24403 | else => false, | 28079 | else => false, |
| 24404 | }, | 28080 | }, |
| 24405 | .imm32 => return switch (temp.tracking(cg).short) { | 28081 | .imm32 => switch (temp.tracking(cg).short) { |
| 24406 | .immediate => |imm| std.math.cast(u32, imm) != null, | 28082 | .immediate => |imm| std.math.cast(u32, imm) != null, |
| 24407 | else => false, | 28083 | else => false, |
| 24408 | }, | 28084 | }, |
| 24409 | .simm32 => return switch (temp.tracking(cg).short) { | 28085 | .simm32 => switch (temp.tracking(cg).short) { |
| 24410 | .immediate => |imm| std.math.cast(i32, @as(i64, @bitCast(imm))) != null, | 28086 | .immediate => |imm| std.math.cast(i32, @as(i64, @bitCast(imm))) != null, |
| 24411 | else => false, | 28087 | else => false, |
| 24412 | }, | 28088 | }, |
| 24413 | .mem => return temp.tracking(cg).short.isMemory(), | 28089 | .mem => temp.tracking(cg).short.isMemory(), |
| 24414 | .mut_mem => return temp.isMut(cg) and temp.tracking(cg).short.isMemory(), | 28090 | .to_mem, .to_mut_mem => true, |
| 24415 | .to_mem => return true, | 28091 | .mut_mem => temp.isMut(cg) and temp.tracking(cg).short.isMemory(), |
| 24416 | .gpr, .mut_gpr => { | 28092 | .gpr => temp.typeOf(cg).abiSize(cg.pt.zcu) <= 8 and switch (temp.tracking(cg).short) { |
| 24417 | const mcv = temp.tracking(cg).short; | 28093 | .register => |reg| reg.class() == .general_purpose, |
| 24418 | const abi_size = temp.typeOf(cg).abiSize(cg.pt.zcu); | 28094 | .register_offset => |reg_off| reg_off.reg.class() == .general_purpose and reg_off.off == 0, |
| 24419 | return abi_size <= 8 and switch (mcv) { | 28095 | else => false, |
| 24420 | .register => |reg| reg.class() == .general_purpose, | | |
| 24421 | .register_offset => |reg_off| reg_off.reg.class() == .general_purpose and | | |
| 24422 | reg_off.off == 0, | | |
| 24423 | .register_pair, .register_triple, .register_quadruple => false, | | |
| 24424 | else => true, | | |
| 24425 | }; | | |
| 24426 | }, | 28096 | }, |
| 24427 | .mm, .mut_mm => { | 28097 | .mut_gpr => temp.isMut(cg) and temp.typeOf(cg).abiSize(cg.pt.zcu) <= 8 and switch (temp.tracking(cg).short) { |
| 24428 | const mcv = temp.tracking(cg).short; | 28098 | .register => |reg| reg.class() == .general_purpose, |
| 24429 | const abi_size = temp.typeOf(cg).abiSize(cg.pt.zcu); | 28099 | .register_offset => |reg_off| reg_off.reg.class() == .general_purpose and reg_off.off == 0, |
| 24430 | return abi_size <= 8 and switch (mcv) { | 28100 | else => false, |
| 24431 | .register => |reg| reg.class() == .mmx, | | |
| 24432 | .register_offset => |reg_off| reg_off.reg.class() == .mmx and | | |
| 24433 | reg_off.off == 0, | | |
| 24434 | else => false, | | |
| 24435 | }; | | |
| 24436 | }, | 28101 | }, |
| 24437 | .xmm, .mut_xmm => { | 28102 | .to_gpr, .to_mut_gpr => temp.typeOf(cg).abiSize(cg.pt.zcu) <= 8, |
| 24438 | const mcv = temp.tracking(cg).short; | 28103 | .mm => temp.typeOf(cg).abiSize(cg.pt.zcu) == 8 and switch (temp.tracking(cg).short) { |
| 24439 | const abi_size = temp.typeOf(cg).abiSize(cg.pt.zcu); | 28104 | .register => |reg| reg.class() == .mmx, |
| 24440 | return abi_size > 8 and abi_size <= 16 and switch (mcv) { | 28105 | .register_offset => |reg_off| reg_off.reg.class() == .mmx and reg_off.off == 0, |
| 24441 | .register => |reg| reg.class() == .sse, | 28106 | else => false, |
| 24442 | .register_offset => |reg_off| reg_off.reg.class() == .sse and | | |
| 24443 | reg_off.off == 0, | | |
| 24444 | .register_pair, .register_triple, .register_quadruple => false, | | |
| 24445 | else => true, | | |
| 24446 | }; | | |
| 24447 | }, | 28107 | }, |
| 24448 | .ymm, .mut_ymm => { | 28108 | .mut_mm => temp.isMut(cg) and temp.typeOf(cg).abiSize(cg.pt.zcu) == 8 and switch (temp.tracking(cg).short) { |
| 24449 | const mcv = temp.tracking(cg).short; | 28109 | .register => |reg| reg.class() == .mmx, |
| 24450 | const abi_size = temp.typeOf(cg).abiSize(cg.pt.zcu); | 28110 | .register_offset => |reg_off| reg_off.reg.class() == .mmx and reg_off.off == 0, |
| 24451 | return abi_size > 16 and abi_size <= 32 and switch (mcv) { | 28111 | else => false, |
| 24452 | .register => |reg| reg.class() == .sse, | | |
| 24453 | .register_offset => |reg_off| reg_off.reg.class() == .sse and | | |
| 24454 | reg_off.off == 0, | | |
| 24455 | .register_pair, .register_triple, .register_quadruple => false, | | |
| 24456 | else => true, | | |
| 24457 | }; | | |
| 24458 | }, | 28112 | }, |
| 24459 | } | 28113 | .to_mm, .to_mut_mm => temp.typeOf(cg).abiSize(cg.pt.zcu) == 8, |
| | 28114 | .xmm => temp.typeOf(cg).abiSize(cg.pt.zcu) == 16 and switch (temp.tracking(cg).short) { |
| | 28115 | .register => |reg| reg.class() == .sse, |
| | 28116 | .register_offset => |reg_off| reg_off.reg.class() == .sse and reg_off.off == 0, |
| | 28117 | else => false, |
| | 28118 | }, |
| | 28119 | .mut_xmm => temp.isMut(cg) and temp.typeOf(cg).abiSize(cg.pt.zcu) == 16 and switch (temp.tracking(cg).short) { |
| | 28120 | .register => |reg| reg.class() == .sse, |
| | 28121 | .register_offset => |reg_off| reg_off.reg.class() == .sse and reg_off.off == 0, |
| | 28122 | else => false, |
| | 28123 | }, |
| | 28124 | .to_xmm, .to_mut_xmm => temp.typeOf(cg).abiSize(cg.pt.zcu) == 16, |
| | 28125 | .ymm => temp.typeOf(cg).abiSize(cg.pt.zcu) == 32 and switch (temp.tracking(cg).short) { |
| | 28126 | .register => |reg| reg.class() == .sse, |
| | 28127 | .register_offset => |reg_off| reg_off.reg.class() == .sse and reg_off.off == 0, |
| | 28128 | else => false, |
| | 28129 | }, |
| | 28130 | .mut_ymm => temp.isMut(cg) and temp.typeOf(cg).abiSize(cg.pt.zcu) == 32 and switch (temp.tracking(cg).short) { |
| | 28131 | .register => |reg| reg.class() == .sse, |
| | 28132 | .register_offset => |reg_off| reg_off.reg.class() == .sse and reg_off.off == 0, |
| | 28133 | else => false, |
| | 28134 | }, |
| | 28135 | .to_ymm, .to_mut_ymm => temp.typeOf(cg).abiSize(cg.pt.zcu) == 32, |
| | 28136 | }; |
| 24460 | } | 28137 | } |
| 24461 | | 28138 | |
| 24462 | fn convert(src: Src, temp: *Temp, cg: *CodeGen) !bool { | 28139 | fn convert(src: Src, temp: *Temp, cg: *CodeGen) !bool { |
| 24463 | return switch (src) { | 28140 | return switch (src) { |
| 24464 | .none => unreachable, | 28141 | .none => unreachable, |
| 24465 | .any, .imm8, .imm16, .imm32, .simm32 => false, | 28142 | .any, .imm8, .imm16, .imm32, .simm32 => false, |
| 24466 | .mem, .mut_mem, .to_mem => try temp.toBase(cg), | 28143 | .mem, .to_mem, .mut_mem, .to_mut_mem => try temp.toBase(cg), |
| 24467 | .gpr => try temp.toRegClass(false, .general_purpose, cg), | 28144 | .gpr, .to_gpr => try temp.toRegClass(false, .general_purpose, cg), |
| 24468 | .mut_gpr => try temp.toRegClass(true, .general_purpose, cg), | 28145 | .mut_gpr, .to_mut_gpr => try temp.toRegClass(true, .general_purpose, cg), |
| 24469 | .mm => try temp.toRegClass(false, .mmx, cg), | 28146 | .mm, .to_mm => try temp.toRegClass(false, .mmx, cg), |
| 24470 | .mut_mm => try temp.toRegClass(true, .mmx, cg), | 28147 | .mut_mm, .to_mut_mm => try temp.toRegClass(true, .mmx, cg), |
| 24471 | .xmm, .ymm => try temp.toRegClass(false, .sse, cg), | 28148 | .xmm, .to_xmm, .ymm, .to_ymm => try temp.toRegClass(false, .sse, cg), |
| 24472 | .mut_xmm, .mut_ymm => try temp.toRegClass(true, .sse, cg), | 28149 | .mut_xmm, .to_mut_xmm, .mut_ymm, .to_mut_ymm => try temp.toRegClass(true, .sse, cg), |
| 24473 | }; | 28150 | }; |
| 24474 | } | 28151 | } |
| 24475 | }; | 28152 | }; |
| ... | @@ -24489,6 +28166,10 @@ const Select = struct { | ... | @@ -24489,6 +28166,10 @@ const Select = struct { |
| 24489 | rc: Register.Class, | 28166 | rc: Register.Class, |
| 24490 | rc_mask: struct { rc: Register.Class, info: MaskInfo }, | 28167 | rc_mask: struct { rc: Register.Class, info: MaskInfo }, |
| 24491 | mem, | 28168 | mem, |
| | 28169 | smin_mem: Select.Operand.Ref, |
| | 28170 | smax_mem: Select.Operand.Ref, |
| | 28171 | umin_mem: Select.Operand.Ref, |
| | 28172 | umax_mem: Select.Operand.Ref, |
| 24492 | ref: Select.Operand.Ref, | 28173 | ref: Select.Operand.Ref, |
| 24493 | ref_mask: struct { ref: Select.Operand.Ref, info: MaskInfo }, | 28174 | ref_mask: struct { ref: Select.Operand.Ref, info: MaskInfo }, |
| 24494 | | 28175 | |
| ... | @@ -24501,14 +28182,81 @@ const Select = struct { | ... | @@ -24501,14 +28182,81 @@ const Select = struct { |
| 24501 | }; | 28182 | }; |
| 24502 | | 28183 | |
| 24503 | fn create(spec: TempSpec, s: *Select) !?Temp { | 28184 | fn create(spec: TempSpec, s: *Select) !?Temp { |
| | 28185 | const cg = s.cg; |
| 24504 | return switch (spec.kind) { | 28186 | return switch (spec.kind) { |
| 24505 | .unused => null, | 28187 | .unused => null, |
| 24506 | .any => try s.cg.tempAlloc(spec.type), | 28188 | .any => try cg.tempAlloc(spec.type), |
| 24507 | .cc => |cc| try s.cg.tempFromValue(spec.type, .{ .eflags = cc }), | 28189 | .cc => |cc| try cg.tempFromValue(spec.type, .{ .eflags = cc }), |
| 24508 | .reg => |reg| try s.cg.tempFromValue(spec.type, .{ .register = reg }), | 28190 | .reg => |reg| try cg.tempFromValue(spec.type, .{ .register = reg }), |
| 24509 | .rc => |rc| try s.cg.tempAllocReg(spec.type, regSetForRegClass(rc)), | 28191 | .rc => |rc| try cg.tempAllocReg(spec.type, regSetForRegClass(rc)), |
| 24510 | .rc_mask => |rc_mask| try s.cg.tempAllocReg(spec.type, regSetForRegClass(rc_mask.rc)), | 28192 | .rc_mask => |rc_mask| try cg.tempAllocReg(spec.type, regSetForRegClass(rc_mask.rc)), |
| 24511 | .mem => try s.cg.tempAllocMem(spec.type), | 28193 | .mem => try cg.tempAllocMem(spec.type), |
| | 28194 | .smin_mem, .smax_mem, .umin_mem, .umax_mem => |ty_ref| { |
| | 28195 | const pt = cg.pt; |
| | 28196 | const zcu = pt.zcu; |
| | 28197 | const ip = &zcu.intern_pool; |
| | 28198 | const ty = ty_ref.deref(s).typeOf(s.cg); |
| | 28199 | const vector_len, const scalar_ty: Type = switch (ip.indexToKey(ty.toIntern())) { |
| | 28200 | else => .{ null, ty }, |
| | 28201 | .vector_type => |vector_type| .{ vector_type.len, .fromInterned(vector_type.child) }, |
| | 28202 | }; |
| | 28203 | const res_scalar_ty, const res_scalar_val: Value = res_scalar: switch (scalar_ty.toIntern()) { |
| | 28204 | .bool_type => .{ |
| | 28205 | scalar_ty, |
| | 28206 | .fromInterned(switch (spec.kind) { |
| | 28207 | else => unreachable, |
| | 28208 | .smin_mem, .umax_mem => .bool_true, |
| | 28209 | .smax_mem, .umin_mem => .bool_false, |
| | 28210 | }), |
| | 28211 | }, |
| | 28212 | else => { |
| | 28213 | const scalar_info: InternPool.Key.IntType = if (scalar_ty.isAbiInt(zcu)) |
| | 28214 | scalar_ty.intInfo(zcu) |
| | 28215 | else |
| | 28216 | .{ .signedness = .unsigned, .bits = @intCast(scalar_ty.bitSize(zcu)) }; |
| | 28217 | const scalar_int_ty = try pt.intType(scalar_info.signedness, scalar_info.bits); |
| | 28218 | if (scalar_info.bits <= 64) { |
| | 28219 | const int_val: i64 = switch (spec.kind) { |
| | 28220 | else => unreachable, |
| | 28221 | .smin_mem => std.math.minInt(i64), |
| | 28222 | .smax_mem => std.math.maxInt(i64), |
| | 28223 | .umin_mem => 0, |
| | 28224 | .umax_mem => -1, |
| | 28225 | }; |
| | 28226 | const shift: u6 = @intCast(64 - scalar_info.bits); |
| | 28227 | break :res_scalar .{ scalar_int_ty, switch (scalar_info.signedness) { |
| | 28228 | .signed => try pt.intValue_i64(scalar_int_ty, int_val >> shift), |
| | 28229 | .unsigned => try pt.intValue_u64(scalar_int_ty, @as(u64, @bitCast(int_val)) >> shift), |
| | 28230 | } }; |
| | 28231 | } |
| | 28232 | var big_int: std.math.big.int.Managed = try .init(cg.gpa); |
| | 28233 | defer big_int.deinit(); |
| | 28234 | try big_int.setTwosCompIntLimit(switch (spec.kind) { |
| | 28235 | else => unreachable, |
| | 28236 | .smin_mem, .umin_mem => .min, |
| | 28237 | .smax_mem, .umax_mem => .max, |
| | 28238 | }, switch (spec.kind) { |
| | 28239 | else => unreachable, |
| | 28240 | .smin_mem, .smax_mem => .signed, |
| | 28241 | .umin_mem, .umax_mem => .unsigned, |
| | 28242 | }, scalar_info.bits); |
| | 28243 | try big_int.truncate(&big_int, scalar_info.signedness, scalar_info.bits); |
| | 28244 | break :res_scalar .{ scalar_int_ty, try pt.intValue_big(scalar_int_ty, big_int.toConst()) }; |
| | 28245 | }, |
| | 28246 | }; |
| | 28247 | const res_ty, const res_val: Value = if (vector_len) |len| res: { |
| | 28248 | const vector_ty = try pt.vectorType(.{ |
| | 28249 | .len = len, |
| | 28250 | .child = res_scalar_ty.toIntern(), |
| | 28251 | }); |
| | 28252 | const vector_val = try pt.intern(.{ .aggregate = .{ |
| | 28253 | .ty = vector_ty.toIntern(), |
| | 28254 | .storage = .{ .repeated_elem = res_scalar_val.toIntern() }, |
| | 28255 | } }); |
| | 28256 | break :res .{ vector_ty, .fromInterned(vector_val) }; |
| | 28257 | } else .{ res_scalar_ty, res_scalar_val }; |
| | 28258 | return try cg.tempFromValue(res_ty, try cg.genTypedValue(res_val)); |
| | 28259 | }, |
| 24512 | .ref => |ref| ref.deref(s), | 28260 | .ref => |ref| ref.deref(s), |
| 24513 | .ref_mask => |ref_mask| ref_mask.ref.deref(s), | 28261 | .ref_mask => |ref_mask| ref_mask.ref.deref(s), |
| 24514 | }; | 28262 | }; |
| ... | @@ -24541,21 +28289,51 @@ const Select = struct { | ... | @@ -24541,21 +28289,51 @@ const Select = struct { |
| 24541 | forward_label, | 28289 | forward_label, |
| 24542 | ref, | 28290 | ref, |
| 24543 | simm, | 28291 | simm, |
| | 28292 | uimm, |
| 24544 | lea, | 28293 | lea, |
| 24545 | mem, | 28294 | mem, |
| 24546 | }; | 28295 | }; |
| 24547 | const Adjust = enum { | 28296 | const Adjust = packed struct(u8) { |
| 24548 | none, | 28297 | factor: i2, |
| 24549 | add_ptr_size, | 28298 | scale: Memory.Scale, |
| 24550 | sub_ptr_size, | 28299 | amount: enum(u4) { |
| 24551 | add_ptr_bit_size, | 28300 | none, |
| 24552 | sub_ptr_bit_size, | 28301 | ptr_size, |
| 24553 | add_size, | 28302 | ptr_bit_size, |
| 24554 | sub_size, | 28303 | size, |
| 24555 | add_len, | 28304 | src0_size, |
| 24556 | sub_len, | 28305 | bit_size, |
| 24557 | add_elem_limbs, | 28306 | src0_bit_size, |
| 24558 | sub_elem_limbs, | 28307 | len, |
| | 28308 | elem_limbs, |
| | 28309 | src0_elem_size, |
| | 28310 | smin, |
| | 28311 | smax, |
| | 28312 | umax, |
| | 28313 | }, |
| | 28314 | |
| | 28315 | const none: Adjust = .{ .factor = 0, .scale = .@"1", .amount = .none }; |
| | 28316 | const sub_ptr_size: Adjust = .{ .factor = -1, .scale = .@"1", .amount = .ptr_size }; |
| | 28317 | const add_ptr_bit_size: Adjust = .{ .factor = 1, .scale = .@"1", .amount = .ptr_bit_size }; |
| | 28318 | const add_size: Adjust = .{ .factor = 1, .scale = .@"1", .amount = .size }; |
| | 28319 | const sub_size: Adjust = .{ .factor = -1, .scale = .@"1", .amount = .size }; |
| | 28320 | const add_src0_size: Adjust = .{ .factor = 1, .scale = .@"1", .amount = .src0_size }; |
| | 28321 | const sub_src0_size: Adjust = .{ .factor = -1, .scale = .@"1", .amount = .src0_size }; |
| | 28322 | const add_2_bit_size: Adjust = .{ .factor = 1, .scale = .@"2", .amount = .bit_size }; |
| | 28323 | const add_bit_size: Adjust = .{ .factor = 1, .scale = .@"1", .amount = .bit_size }; |
| | 28324 | const sub_bit_size: Adjust = .{ .factor = -1, .scale = .@"1", .amount = .bit_size }; |
| | 28325 | const add_src0_bit_size: Adjust = .{ .factor = 1, .scale = .@"1", .amount = .src0_bit_size }; |
| | 28326 | const sub_src0_bit_size: Adjust = .{ .factor = -1, .scale = .@"1", .amount = .src0_bit_size }; |
| | 28327 | const add_8_len: Adjust = .{ .factor = 1, .scale = .@"8", .amount = .len }; |
| | 28328 | const add_4_len: Adjust = .{ .factor = 1, .scale = .@"4", .amount = .len }; |
| | 28329 | const add_3_len: Adjust = .{ .factor = 1, .scale = .@"3", .amount = .len }; |
| | 28330 | const add_2_len: Adjust = .{ .factor = 1, .scale = .@"2", .amount = .len }; |
| | 28331 | const add_len: Adjust = .{ .factor = 1, .scale = .@"1", .amount = .len }; |
| | 28332 | const sub_len: Adjust = .{ .factor = -1, .scale = .@"1", .amount = .len }; |
| | 28333 | const add_src0_elem_size: Adjust = .{ .factor = 1, .scale = .@"1", .amount = .src0_elem_size }; |
| | 28334 | const sub_src0_elem_size: Adjust = .{ .factor = -1, .scale = .@"1", .amount = .src0_elem_size }; |
| | 28335 | const add_elem_limbs: Adjust = .{ .factor = 1, .scale = .@"1", .amount = .elem_limbs }; |
| | 28336 | const add_umax: Adjust = .{ .factor = 1, .scale = .@"1", .amount = .umax }; |
| 24559 | }; | 28337 | }; |
| 24560 | const Ref = enum(u4) { | 28338 | const Ref = enum(u4) { |
| 24561 | tmp0, | 28339 | tmp0, |
| ... | @@ -24741,15 +28519,24 @@ const Select = struct { | ... | @@ -24741,15 +28519,24 @@ const Select = struct { |
| 24741 | const src1x: Select.Operand = .{ .tag = .ref, .base = .src1x }; | 28519 | const src1x: Select.Operand = .{ .tag = .ref, .base = .src1x }; |
| 24742 | const src1y: Select.Operand = .{ .tag = .ref, .base = .src1y }; | 28520 | const src1y: Select.Operand = .{ .tag = .ref, .base = .src1y }; |
| 24743 | | 28521 | |
| 24744 | fn i(imm: i32) Select.Operand { | 28522 | fn si(imm: i32) Select.Operand { |
| 24745 | return .{ .tag = .simm, .imm = imm }; | 28523 | return .{ .tag = .simm, .imm = imm }; |
| 24746 | } | 28524 | } |
| 24747 | fn a(base: Ref.Sized, adjust: Adjust) Select.Operand { | 28525 | fn sa(base: Ref.Sized, adjust: Adjust) Select.Operand { |
| 24748 | return .{ .tag = .simm, .base = base, .adjust = adjust }; | 28526 | return .{ .tag = .simm, .base = base, .adjust = adjust }; |
| 24749 | } | 28527 | } |
| 24750 | fn ia(imm: i32, base: Ref.Sized, adjust: Adjust) Select.Operand { | 28528 | fn sia(imm: i32, base: Ref.Sized, adjust: Adjust) Select.Operand { |
| 24751 | return .{ .tag = .simm, .base = base, .adjust = adjust, .imm = imm }; | 28529 | return .{ .tag = .simm, .base = base, .adjust = adjust, .imm = imm }; |
| 24752 | } | 28530 | } |
| | 28531 | fn ui(imm: i32) Select.Operand { |
| | 28532 | return .{ .tag = .uimm, .imm = imm }; |
| | 28533 | } |
| | 28534 | fn ua(base: Ref.Sized, adjust: Adjust) Select.Operand { |
| | 28535 | return .{ .tag = .uimm, .base = base, .adjust = adjust }; |
| | 28536 | } |
| | 28537 | fn uia(imm: i32, base: Ref.Sized, adjust: Adjust) Select.Operand { |
| | 28538 | return .{ .tag = .uimm, .base = base, .adjust = adjust, .imm = imm }; |
| | 28539 | } |
| 24753 | | 28540 | |
| 24754 | fn lea(size: Memory.Size, base: Ref) Select.Operand { | 28541 | fn lea(size: Memory.Size, base: Ref) Select.Operand { |
| 24755 | return .{ | 28542 | return .{ |
| ... | @@ -24757,6 +28544,13 @@ const Select = struct { | ... | @@ -24757,6 +28544,13 @@ const Select = struct { |
| 24757 | .base = .{ .ref = base, .size = size }, | 28544 | .base = .{ .ref = base, .size = size }, |
| 24758 | }; | 28545 | }; |
| 24759 | } | 28546 | } |
| | 28547 | fn leaa(size: Memory.Size, base: Ref, adjust: Adjust) Select.Operand { |
| | 28548 | return .{ |
| | 28549 | .tag = .lea, |
| | 28550 | .base = .{ .ref = base, .size = size }, |
| | 28551 | .adjust = adjust, |
| | 28552 | }; |
| | 28553 | } |
| 24760 | fn lead(size: Memory.Size, base: Ref, disp: i32) Select.Operand { | 28554 | fn lead(size: Memory.Size, base: Ref, disp: i32) Select.Operand { |
| 24761 | return .{ | 28555 | return .{ |
| 24762 | .tag = .lea, | 28556 | .tag = .lea, |
| ... | @@ -24768,14 +28562,22 @@ const Select = struct { | ... | @@ -24768,14 +28562,22 @@ const Select = struct { |
| 24768 | return .{ | 28562 | return .{ |
| 24769 | .tag = .lea, | 28563 | .tag = .lea, |
| 24770 | .base = .{ .ref = base, .size = size }, | 28564 | .base = .{ .ref = base, .size = size }, |
| 24771 | .index_ = .{ .ref = index, .scale = .@"1" }, | 28565 | .index = .{ .ref = index, .scale = .@"1" }, |
| | 28566 | }; |
| | 28567 | } |
| | 28568 | fn leaia(size: Memory.Size, base: Ref, index: Ref, adjust: Adjust) Select.Operand { |
| | 28569 | return .{ |
| | 28570 | .tag = .lea, |
| | 28571 | .base = .{ .ref = base, .size = size }, |
| | 28572 | .index = .{ .ref = index, .scale = .@"1" }, |
| | 28573 | .adjust = adjust, |
| 24772 | }; | 28574 | }; |
| 24773 | } | 28575 | } |
| 24774 | fn leaid(size: Memory.Size, base: Ref, index: Ref, disp: i32) Select.Operand { | 28576 | fn leaid(size: Memory.Size, base: Ref, index: Ref, disp: i32) Select.Operand { |
| 24775 | return .{ | 28577 | return .{ |
| 24776 | .tag = .lea, | 28578 | .tag = .lea, |
| 24777 | .base = .{ .ref = base, .size = size }, | 28579 | .base = .{ .ref = base, .size = size }, |
| 24778 | .index_ = .{ .ref = index, .scale = .@"1" }, | 28580 | .index = .{ .ref = index, .scale = .@"1" }, |
| 24779 | .imm = disp, | 28581 | .imm = disp, |
| 24780 | }; | 28582 | }; |
| 24781 | } | 28583 | } |
| ... | @@ -24783,22 +28585,22 @@ const Select = struct { | ... | @@ -24783,22 +28585,22 @@ const Select = struct { |
| 24783 | return .{ | 28585 | return .{ |
| 24784 | .tag = .lea, | 28586 | .tag = .lea, |
| 24785 | .base = .{ .ref = base, .size = size }, | 28587 | .base = .{ .ref = base, .size = size }, |
| 24786 | .index_ = .{ .ref = index, .scale = scale }, | 28588 | .index = .{ .ref = index, .scale = scale }, |
| 24787 | }; | 28589 | }; |
| 24788 | } | 28590 | } |
| 24789 | fn leasid(size: Memory.Size, base: Ref, scale: Memory.Scale, index: Ref, disp: i32) Select.Operand { | 28591 | fn leasid(size: Memory.Size, base: Ref, scale: Memory.Scale, index: Ref, disp: i32) Select.Operand { |
| 24790 | return .{ | 28592 | return .{ |
| 24791 | .tag = .lea, | 28593 | .tag = .lea, |
| 24792 | .base = .{ .ref = base, .size = size }, | 28594 | .base = .{ .ref = base, .size = size }, |
| 24793 | .index_ = .{ .ref = index, .scale = scale }, | 28595 | .index = .{ .ref = index, .scale = scale }, |
| 24794 | .imm = disp, | 28596 | .imm = disp, |
| 24795 | }; | 28597 | }; |
| 24796 | } | 28598 | } |
| 24797 | fn leasida(size: Memory.Size, base: Ref, scale: Memory.Scale, index: Ref, disp: i32, adjust: Adjust) Select.Operand { | 28599 | fn leasiad(size: Memory.Size, base: Ref, scale: Memory.Scale, index: Ref, adjust: Adjust, disp: i32) Select.Operand { |
| 24798 | return .{ | 28600 | return .{ |
| 24799 | .tag = .lea, | 28601 | .tag = .lea, |
| 24800 | .base = .{ .ref = base, .size = size }, | 28602 | .base = .{ .ref = base, .size = size }, |
| 24801 | .index_ = .{ .ref = index, .scale = scale }, | 28603 | .index = .{ .ref = index, .scale = scale }, |
| 24802 | .adjust = adjust, | 28604 | .adjust = adjust, |
| 24803 | .imm = disp, | 28605 | .imm = disp, |
| 24804 | }; | 28606 | }; |
| ... | @@ -24817,6 +28619,21 @@ const Select = struct { | ... | @@ -24817,6 +28619,21 @@ const Select = struct { |
| 24817 | .imm = disp, | 28619 | .imm = disp, |
| 24818 | }; | 28620 | }; |
| 24819 | } | 28621 | } |
| | 28622 | fn mema(base: Ref.Sized, adjust: Adjust) Select.Operand { |
| | 28623 | return .{ |
| | 28624 | .tag = .mem, |
| | 28625 | .base = base, |
| | 28626 | .adjust = adjust, |
| | 28627 | }; |
| | 28628 | } |
| | 28629 | fn memad(base: Ref.Sized, adjust: Adjust, disp: i32) Select.Operand { |
| | 28630 | return .{ |
| | 28631 | .tag = .mem, |
| | 28632 | .base = base, |
| | 28633 | .adjust = adjust, |
| | 28634 | .imm = disp, |
| | 28635 | }; |
| | 28636 | } |
| 24820 | fn memi(base: Ref.Sized, index: Ref) Select.Operand { | 28637 | fn memi(base: Ref.Sized, index: Ref) Select.Operand { |
| 24821 | return .{ | 28638 | return .{ |
| 24822 | .tag = .mem, | 28639 | .tag = .mem, |
| ... | @@ -24832,6 +28649,15 @@ const Select = struct { | ... | @@ -24832,6 +28649,15 @@ const Select = struct { |
| 24832 | .adjust = adjust, | 28649 | .adjust = adjust, |
| 24833 | }; | 28650 | }; |
| 24834 | } | 28651 | } |
| | 28652 | fn memiad(base: Ref.Sized, index: Ref, adjust: Adjust, disp: i32) Select.Operand { |
| | 28653 | return .{ |
| | 28654 | .tag = .mem, |
| | 28655 | .base = base, |
| | 28656 | .index = .{ .ref = index, .scale = .@"1" }, |
| | 28657 | .adjust = adjust, |
| | 28658 | .imm = disp, |
| | 28659 | }; |
| | 28660 | } |
| 24835 | fn memid(base: Ref.Sized, index: Ref, disp: i32) Select.Operand { | 28661 | fn memid(base: Ref.Sized, index: Ref, disp: i32) Select.Operand { |
| 24836 | return .{ | 28662 | return .{ |
| 24837 | .tag = .mem, | 28663 | .tag = .mem, |
| ... | @@ -24847,6 +28673,14 @@ const Select = struct { | ... | @@ -24847,6 +28673,14 @@ const Select = struct { |
| 24847 | .index = .{ .ref = index, .scale = scale }, | 28673 | .index = .{ .ref = index, .scale = scale }, |
| 24848 | }; | 28674 | }; |
| 24849 | } | 28675 | } |
| | 28676 | fn memsia(base: Ref.Sized, scale: Memory.Scale, index: Ref, adjust: Adjust) Select.Operand { |
| | 28677 | return .{ |
| | 28678 | .tag = .mem, |
| | 28679 | .base = base, |
| | 28680 | .index = .{ .ref = index, .scale = scale }, |
| | 28681 | .adjust = adjust, |
| | 28682 | }; |
| | 28683 | } |
| 24850 | fn memsid(base: Ref.Sized, scale: Memory.Scale, index: Ref, disp: i32) Select.Operand { | 28684 | fn memsid(base: Ref.Sized, scale: Memory.Scale, index: Ref, disp: i32) Select.Operand { |
| 24851 | return .{ | 28685 | return .{ |
| 24852 | .tag = .mem, | 28686 | .tag = .mem, |
| ... | @@ -24855,7 +28689,7 @@ const Select = struct { | ... | @@ -24855,7 +28689,7 @@ const Select = struct { |
| 24855 | .imm = disp, | 28689 | .imm = disp, |
| 24856 | }; | 28690 | }; |
| 24857 | } | 28691 | } |
| 24858 | fn memsida(base: Ref.Sized, scale: Memory.Scale, index: Ref, disp: i32, adjust: Adjust) Select.Operand { | 28692 | fn memsiad(base: Ref.Sized, scale: Memory.Scale, index: Ref, adjust: Adjust, disp: i32) Select.Operand { |
| 24859 | return .{ | 28693 | return .{ |
| 24860 | .tag = .mem, | 28694 | .tag = .mem, |
| 24861 | .base = base, | 28695 | .base = base, |
| ... | @@ -24865,26 +28699,34 @@ const Select = struct { | ... | @@ -24865,26 +28699,34 @@ const Select = struct { |
| 24865 | }; | 28699 | }; |
| 24866 | } | 28700 | } |
| 24867 | | 28701 | |
| 24868 | fn adjustedImm(op: Select.Operand, s: *const Select) i32 { | 28702 | fn adjustedImm(op: Select.Operand, comptime SignedImm: type, s: *const Select) SignedImm { |
| 24869 | return switch (op.adjust) { | 28703 | const UnsignedImm = @Type(.{ |
| 24870 | .none => op.imm, | 28704 | .int = .{ .signedness = .unsigned, .bits = @typeInfo(SignedImm).int.bits }, |
| 24871 | .add_ptr_size => op.imm + @divExact(s.cg.target.ptrBitWidth(), 8), | 28705 | }); |
| 24872 | .sub_ptr_size => op.imm - @divExact(s.cg.target.ptrBitWidth(), 8), | 28706 | return op.imm + @as(i5, op.adjust.factor) * op.adjust.scale.toFactor() * @as(SignedImm, switch (op.adjust.amount) { |
| 24873 | .add_ptr_bit_size => op.imm + s.cg.target.ptrBitWidth(), | 28707 | .none => 0, |
| 24874 | .sub_ptr_bit_size => op.imm - s.cg.target.ptrBitWidth(), | 28708 | .ptr_size => @divExact(s.cg.target.ptrBitWidth(), 8), |
| 24875 | .add_size => op.imm + @as(i32, @intCast(op.base.ref.deref(s).typeOf(s.cg).abiSize(s.cg.pt.zcu))), | 28709 | .ptr_bit_size => s.cg.target.ptrBitWidth(), |
| 24876 | .sub_size => op.imm - @as(i32, @intCast(op.base.ref.deref(s).typeOf(s.cg).abiSize(s.cg.pt.zcu))), | 28710 | .size => @intCast(op.base.ref.deref(s).typeOf(s.cg).abiSize(s.cg.pt.zcu)), |
| 24877 | .add_len => op.imm + @as(i32, @intCast(op.base.ref.deref(s).typeOf(s.cg).vectorLen(s.cg.pt.zcu))), | 28711 | .src0_size => @intCast(Select.Operand.Ref.src0.deref(s).typeOf(s.cg).abiSize(s.cg.pt.zcu)), |
| 24878 | .sub_len => op.imm - @as(i32, @intCast(op.base.ref.deref(s).typeOf(s.cg).vectorLen(s.cg.pt.zcu))), | 28712 | .bit_size => @intCast(op.base.ref.deref(s).typeOf(s.cg).scalarType(s.cg.pt.zcu).bitSize(s.cg.pt.zcu)), |
| 24879 | .add_elem_limbs => op.imm + @as(i32, @intCast(@divExact( | 28713 | .src0_bit_size => @intCast(Select.Operand.Ref.src0.deref(s).typeOf(s.cg).scalarType(s.cg.pt.zcu).bitSize(s.cg.pt.zcu)), |
| 24880 | op.base.ref.deref(s).typeOf(s.cg).scalarType(s.cg.pt.zcu).abiSize(s.cg.pt.zcu), | 28714 | .len => @intCast(op.base.ref.deref(s).typeOf(s.cg).vectorLen(s.cg.pt.zcu)), |
| 24881 | @divExact(op.base.size.bitSize(s.cg.target), 8), | 28715 | .elem_limbs => @intCast(@divExact( |
| 24882 | ))), | | |
| 24883 | .sub_elem_limbs => op.imm - @as(i32, @intCast(@divExact( | | |
| 24884 | op.base.ref.deref(s).typeOf(s.cg).scalarType(s.cg.pt.zcu).abiSize(s.cg.pt.zcu), | 28716 | op.base.ref.deref(s).typeOf(s.cg).scalarType(s.cg.pt.zcu).abiSize(s.cg.pt.zcu), |
| 24885 | @divExact(op.base.size.bitSize(s.cg.target), 8), | 28717 | @divExact(op.base.size.bitSize(s.cg.target), 8), |
| 24886 | ))), | 28718 | )), |
| 24887 | }; | 28719 | .src0_elem_size => @intCast(Select.Operand.Ref.src0.deref(s).typeOf(s.cg).scalarType(s.cg.pt.zcu).abiSize(s.cg.pt.zcu)), |
| | 28720 | .smin => @as(SignedImm, std.math.minInt(SignedImm)) >> @truncate( |
| | 28721 | -%op.base.ref.deref(s).typeOf(s.cg).scalarType(s.cg.pt.zcu).bitSize(s.cg.pt.zcu), |
| | 28722 | ), |
| | 28723 | .smax => @as(SignedImm, std.math.maxInt(SignedImm)) >> @truncate( |
| | 28724 | -%op.base.ref.deref(s).typeOf(s.cg).scalarType(s.cg.pt.zcu).bitSize(s.cg.pt.zcu), |
| | 28725 | ), |
| | 28726 | .umax => @bitCast(@as(UnsignedImm, std.math.maxInt(UnsignedImm)) >> @truncate( |
| | 28727 | -%op.base.ref.deref(s).typeOf(s.cg).scalarType(s.cg.pt.zcu).bitSize(s.cg.pt.zcu), |
| | 28728 | )), |
| | 28729 | }); |
| 24888 | } | 28730 | } |
| 24889 | | 28731 | |
| 24890 | fn lower(op: Select.Operand, s: *Select) !CodeGen.Operand { | 28732 | fn lower(op: Select.Operand, s: *Select) !CodeGen.Operand { |
| ... | @@ -24907,7 +28749,8 @@ const Select = struct { | ... | @@ -24907,7 +28749,8 @@ const Select = struct { |
| 24907 | else => |mcv| .{ .mem = try mcv.mem(s.cg, .{ .size = op.base.size }) }, | 28749 | else => |mcv| .{ .mem = try mcv.mem(s.cg, .{ .size = op.base.size }) }, |
| 24908 | .register => |reg| .{ .reg = registerAlias(reg, @intCast(@divExact(op.base.size.bitSize(s.cg.target), 8))) }, | 28750 | .register => |reg| .{ .reg = registerAlias(reg, @intCast(@divExact(op.base.size.bitSize(s.cg.target), 8))) }, |
| 24909 | }, | 28751 | }, |
| 24910 | .simm => .{ .imm = .s(op.adjustedImm(s)) }, | 28752 | .simm => .{ .imm = .s(op.adjustedImm(i32, s)) }, |
| | 28753 | .uimm => .{ .imm = .u(@bitCast(op.adjustedImm(i64, s))) }, |
| 24911 | .lea => .{ .mem = .{ | 28754 | .lea => .{ .mem = .{ |
| 24912 | .base = .{ .reg = registerAlias(op.base.ref.deref(s).tracking(s.cg).short.register, @divExact(s.cg.target.ptrBitWidth(), 8)) }, | 28755 | .base = .{ .reg = registerAlias(op.base.ref.deref(s).tracking(s.cg).short.register, @divExact(s.cg.target.ptrBitWidth(), 8)) }, |
| 24913 | .mod = .{ .rm = .{ | 28756 | .mod = .{ .rm = .{ |
| ... | @@ -24917,7 +28760,7 @@ const Select = struct { | ... | @@ -24917,7 +28760,7 @@ const Select = struct { |
| 24917 | .none => .none, | 28760 | .none => .none, |
| 24918 | }, | 28761 | }, |
| 24919 | .scale = op.index.scale, | 28762 | .scale = op.index.scale, |
| 24920 | .disp = op.adjustedImm(s), | 28763 | .disp = op.adjustedImm(i32, s), |
| 24921 | } }, | 28764 | } }, |
| 24922 | } }, | 28765 | } }, |
| 24923 | .mem => .{ .mem = try op.base.ref.deref(s).tracking(s.cg).short.mem(s.cg, .{ | 28766 | .mem => .{ .mem = try op.base.ref.deref(s).tracking(s.cg).short.mem(s.cg, .{ |
| ... | @@ -24927,7 +28770,7 @@ const Select = struct { | ... | @@ -24927,7 +28770,7 @@ const Select = struct { |
| 24927 | .none => .none, | 28770 | .none => .none, |
| 24928 | }, | 28771 | }, |
| 24929 | .scale = op.index.scale, | 28772 | .scale = op.index.scale, |
| 24930 | .disp = op.adjustedImm(s), | 28773 | .disp = op.adjustedImm(i32, s), |
| 24931 | }) }, | 28774 | }) }, |
| 24932 | }; | 28775 | }; |
| 24933 | } | 28776 | } |
| ... | @@ -24942,14 +28785,23 @@ fn select( | ... | @@ -24942,14 +28785,23 @@ fn select( |
| 24942 | ) !void { | 28785 | ) !void { |
| 24943 | cases: for (cases) |case| { | 28786 | cases: for (cases) |case| { |
| 24944 | for (case.required_features) |required_feature| if (required_feature) |feature| if (!switch (feature) { | 28787 | for (case.required_features) |required_feature| if (required_feature) |feature| if (!switch (feature) { |
| 24945 | .@"64bit" => cg.target.ptrBitWidth() == 64, | 28788 | .@"64bit" => switch (cg.target.cpu.arch) { |
| | 28789 | else => unreachable, |
| | 28790 | .x86 => false, |
| | 28791 | .x86_64 => true, |
| | 28792 | }, |
| 24946 | .mmx => false, | 28793 | .mmx => false, |
| 24947 | else => cg.hasFeature(feature), | 28794 | else => cg.hasFeature(feature), |
| 24948 | }) continue :cases; | 28795 | }) continue :cases; |
| 24949 | for (case.dst_constraints[0..dst_temps.len], dst_tys) |dst_constraint, dst_ty| if (!dst_constraint.accepts(dst_ty, cg)) continue :cases; | 28796 | for (case.dst_constraints[0..dst_temps.len], dst_tys) |dst_constraint, dst_ty| if (!dst_constraint.accepts(dst_ty, cg)) continue :cases; |
| 24950 | for (case.src_constraints[0..src_temps.len], src_temps) |src_constraint, src_temp| if (!src_constraint.accepts(src_temp.typeOf(cg), cg)) continue :cases; | 28797 | for (case.src_constraints[0..src_temps.len], src_temps) |src_constraint, src_temp| if (!src_constraint.accepts(src_temp.typeOf(cg), cg)) continue :cases; |
| | 28798 | if (std.debug.runtime_safety) { |
| | 28799 | for (case.dst_constraints[dst_temps.len..]) |dst_constraint| assert(dst_constraint == .any); |
| | 28800 | for (case.src_constraints[src_temps.len..]) |src_constraint| assert(src_constraint == .any); |
| | 28801 | } |
| 24951 | patterns: for (case.patterns) |pattern| { | 28802 | patterns: for (case.patterns) |pattern| { |
| 24952 | for (pattern.src, src_temps) |src_pattern, src_temp| if (!src_pattern.matches(src_temp, cg)) continue :patterns; | 28803 | for (pattern.src[0..src_temps.len], src_temps) |src_pattern, src_temp| if (!src_pattern.matches(src_temp, cg)) continue :patterns; |
| | 28804 | if (std.debug.runtime_safety) for (pattern.src[src_temps.len..]) |src_pattern| assert(src_pattern == .none); |
| 24953 | | 28805 | |
| 24954 | var s: Select = .{ | 28806 | var s: Select = .{ |
| 24955 | .cg = cg, | 28807 | .cg = cg, |
| ... | @@ -24960,9 +28812,11 @@ fn select( | ... | @@ -24960,9 +28812,11 @@ fn select( |
| 24960 | const dst_slots = s.temps[@intFromEnum(Select.Operand.Ref.dst0)..@intFromEnum(Select.Operand.Ref.src0)]; | 28812 | const dst_slots = s.temps[@intFromEnum(Select.Operand.Ref.dst0)..@intFromEnum(Select.Operand.Ref.src0)]; |
| 24961 | const src_slots = s.temps[@intFromEnum(Select.Operand.Ref.src0)..@intFromEnum(Select.Operand.Ref.none)]; | 28813 | const src_slots = s.temps[@intFromEnum(Select.Operand.Ref.src0)..@intFromEnum(Select.Operand.Ref.none)]; |
| 24962 | | 28814 | |
| | 28815 | @memcpy(src_slots[0..src_temps.len], src_temps); |
| | 28816 | std.mem.swap(Temp, &src_slots[pattern.commute[0]], &src_slots[pattern.commute[1]]); |
| 24963 | for (tmp_slots, case.extra_temps) |*slot, spec| slot.* = try spec.create(&s) orelse continue; | 28817 | for (tmp_slots, case.extra_temps) |*slot, spec| slot.* = try spec.create(&s) orelse continue; |
| 24964 | | 28818 | |
| 24965 | while (true) for (pattern.src, src_temps) |src_pattern, *src_temp| { | 28819 | while (true) for (pattern.src[0..src_temps.len], src_temps) |src_pattern, *src_temp| { |
| 24966 | if (try src_pattern.convert(src_temp, cg)) break; | 28820 | if (try src_pattern.convert(src_temp, cg)) break; |
| 24967 | } else break; | 28821 | } else break; |
| 24968 | @memcpy(src_slots[0..src_temps.len], src_temps); | 28822 | @memcpy(src_slots[0..src_temps.len], src_temps); |
Jacob Young <jacobly@ziglang.org> 2024-12-28 22:51:41-05:00
src