Merge pull request #24193 from jacobly0/x86_64-spring-cleaning

x86_64: increase passing test coverage on windows

11 files changed, 11909 insertions, 7482 deletions

diff --git a/src/arch/aarch64/CodeGen.zig b/src/arch/aarch64/CodeGen.zig
index a8a60e7ce7..042ee9c11e 100644
--- a/src/arch/aarch64/CodeGen.zig
+++ b/src/arch/aarch64/CodeGen.zig
@@ -6175,7 +6175,7 @@ fn genTypedValue(self: *Self, val: Value) InnerError!MCValue {
         self.pt,
         self.src_loc,
         val,
-        self.target.*,
+        self.target,
     )) {
         .mcv => |mcv| switch (mcv) {
             .none => .none,
@@ -6379,7 +6379,7 @@ fn registerAlias(self: *Self, reg: Register, ty: Type) Register {
         },
         .stack_pointer => unreachable, // we can't store/load the sp
         .floating_point => {
-            return switch (ty.floatBits(self.target.*)) {
+            return switch (ty.floatBits(self.target)) {
                 16 => reg.toH(),
                 32 => reg.toS(),
                 64 => reg.toD(),
diff --git a/src/arch/arm/CodeGen.zig b/src/arch/arm/CodeGen.zig
index 98c1420863..799a75be9a 100644
--- a/src/arch/arm/CodeGen.zig
+++ b/src/arch/arm/CodeGen.zig
@@ -6148,7 +6148,7 @@ fn genTypedValue(self: *Self, val: Value) InnerError!MCValue {
         pt,
         self.src_loc,
         val,
-        self.target.*,
+        self.target,
     )) {
         .mcv => |mcv| switch (mcv) {
             .none => .none,
diff --git a/src/arch/riscv64/CodeGen.zig b/src/arch/riscv64/CodeGen.zig
index 1743f37e84..b9a16d5a75 100644
--- a/src/arch/riscv64/CodeGen.zig
+++ b/src/arch/riscv64/CodeGen.zig
@@ -1881,7 +1881,7 @@ fn memSize(func: *Func, ty: Type) Memory.Size {
     const pt = func.pt;
     const zcu = pt.zcu;
     return switch (ty.zigTypeTag(zcu)) {
-        .float => Memory.Size.fromBitSize(ty.floatBits(func.target.*)),
+        .float => Memory.Size.fromBitSize(ty.floatBits(func.target)),
         else => Memory.Size.fromByteSize(ty.abiSize(zcu)),
     };
 }
@@ -2401,7 +2401,7 @@ fn binOp(
     const rhs_ty = func.typeOf(rhs_air);
 
     if (lhs_ty.isRuntimeFloat()) libcall: {
-        const float_bits = lhs_ty.floatBits(func.target.*);
+        const float_bits = lhs_ty.floatBits(func.target);
         const type_needs_libcall = switch (float_bits) {
             16 => true,
             32, 64 => false,
@@ -5189,7 +5189,7 @@ fn airCmp(func: *Func, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
                 }
             },
             .float => {
-                const float_bits = lhs_ty.floatBits(func.target.*);
+                const float_bits = lhs_ty.floatBits(func.target);
                 const float_reg_size: u32 = if (func.hasFeature(.d)) 64 else 32;
                 if (float_bits > float_reg_size) {
                     return func.fail("TODO: airCmp float > 64/32 bits", .{});
@@ -5962,10 +5962,14 @@ fn airBr(func: *Func, inst: Air.Inst.Index) !void {
             if (first_br) break :result src_mcv;
 
             try func.getValue(block_tracking.short, br.block_inst);
-            // .long = .none to avoid merging operand and block result stack frames.
-            const current_tracking: InstTracking = .{ .long = .none, .short = src_mcv };
-            try current_tracking.materializeUnsafe(func, br.block_inst, block_tracking.*);
-            for (current_tracking.getRegs()) |src_reg| func.register_manager.freeReg(src_reg);
+            try InstTracking.materializeUnsafe(
+                // .long = .none to avoid merging operand and block result stack frames.
+                .{ .long = .none, .short = src_mcv },
+                func,
+                br.block_inst,
+                block_tracking.*,
+            );
+            try func.freeValue(src_mcv);
             break :result block_tracking.short;
         }
 
@@ -8192,10 +8196,13 @@ fn genTypedValue(func: *Func, val: Value) InnerError!MCValue {
     const lf = func.bin_file;
     const src_loc = func.src_loc;
 
-    const result = if (val.isUndef(pt.zcu))
-        try lf.lowerUav(pt, val.toIntern(), .none, src_loc)
+    const result: codegen.GenResult = if (val.isUndef(pt.zcu))
+        switch (try lf.lowerUav(pt, val.toIntern(), .none, src_loc)) {
+            .sym_index => |sym_index| .{ .mcv = .{ .load_symbol = sym_index } },
+            .fail => |em| .{ .fail = em },
+        }
     else
-        try codegen.genTypedValue(lf, pt, src_loc, val, func.target.*);
+        try codegen.genTypedValue(lf, pt, src_loc, val, func.target);
     const mcv: MCValue = switch (result) {
         .mcv => |mcv| switch (mcv) {
             .none => .none,
@@ -8484,7 +8491,7 @@ fn promoteInt(func: *Func, ty: Type) Type {
 
 fn promoteVarArg(func: *Func, ty: Type) Type {
     if (!ty.isRuntimeFloat()) return func.promoteInt(ty);
-    switch (ty.floatBits(func.target.*)) {
+    switch (ty.floatBits(func.target)) {
         32, 64 => return Type.f64,
         else => |float_bits| {
             assert(float_bits == func.target.cTypeBitSize(.longdouble));
diff --git a/src/arch/sparc64/CodeGen.zig b/src/arch/sparc64/CodeGen.zig
index 6da576bafc..5115c432a7 100644
--- a/src/arch/sparc64/CodeGen.zig
+++ b/src/arch/sparc64/CodeGen.zig
@@ -4088,7 +4088,7 @@ fn genTypedValue(self: *Self, val: Value) InnerError!MCValue {
         pt,
         self.src_loc,
         val,
-        self.target.*,
+        self.target,
     )) {
         .mcv => |mcv| switch (mcv) {
             .none => .none,
diff --git a/src/arch/wasm/CodeGen.zig b/src/arch/wasm/CodeGen.zig
index 6719f22a73..9452066bc5 100644
--- a/src/arch/wasm/CodeGen.zig
+++ b/src/arch/wasm/CodeGen.zig
@@ -982,7 +982,7 @@ fn addExtraAssumeCapacity(cg: *CodeGen, extra: anytype) error{OutOfMemory}!u32 {
 pub fn typeToValtype(ty: Type, zcu: *const Zcu, target: *const std.Target) std.wasm.Valtype {
     const ip = &zcu.intern_pool;
     return switch (ty.zigTypeTag(zcu)) {
-        .float => switch (ty.floatBits(target.*)) {
+        .float => switch (ty.floatBits(target)) {
             16 => .i32, // stored/loaded as u16
             32 => .f32,
             64 => .f64,
@@ -1715,7 +1715,7 @@ fn isByRef(ty: Type, zcu: *const Zcu, target: *const std.Target) bool {
         .vector => return determineSimdStoreStrategy(ty, zcu, target) == .unrolled,
         .int => return ty.intInfo(zcu).bits > 64,
         .@"enum" => return ty.intInfo(zcu).bits > 64,
-        .float => return ty.floatBits(target.*) > 64,
+        .float => return ty.floatBits(target) > 64,
         .error_union => {
             const pl_ty = ty.errorUnionPayload(zcu);
             if (!pl_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
@@ -2904,7 +2904,7 @@ fn floatOp(cg: *CodeGen, float_op: FloatOp, ty: Type, args: []const WValue) Inne
         return cg.fail("TODO: Implement floatOps for vectors", .{});
     }
 
-    const float_bits = ty.floatBits(cg.target.*);
+    const float_bits = ty.floatBits(cg.target);
 
     if (float_op == .neg) {
         return cg.floatNeg(ty, args[0]);
@@ -2931,7 +2931,7 @@ fn floatOp(cg: *CodeGen, float_op: FloatOp, ty: Type, args: []const WValue) Inne
 
 /// NOTE: The result value remains on top of the stack.
 fn floatNeg(cg: *CodeGen, ty: Type, arg: WValue) InnerError!WValue {
-    const float_bits = ty.floatBits(cg.target.*);
+    const float_bits = ty.floatBits(cg.target);
     switch (float_bits) {
         16 => {
             try cg.emitWValue(arg);
@@ -3300,7 +3300,7 @@ fn emitUndefined(cg: *CodeGen, ty: Type) InnerError!WValue {
             33...64 => return .{ .imm64 = 0xaaaaaaaaaaaaaaaa },
             else => unreachable,
         },
-        .float => switch (ty.floatBits(cg.target.*)) {
+        .float => switch (ty.floatBits(cg.target)) {
             16 => return .{ .imm32 = 0xaaaaaaaa },
             32 => return .{ .float32 = @as(f32, @bitCast(@as(u32, 0xaaaaaaaa))) },
             64 => return .{ .float64 = @as(f64, @bitCast(@as(u64, 0xaaaaaaaaaaaaaaaa))) },
@@ -3507,7 +3507,7 @@ fn cmp(cg: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, op: std.math.CompareOpe
 /// Compares two floats.
 /// NOTE: Leaves the result of the comparison on top of the stack.
 fn cmpFloat(cg: *CodeGen, ty: Type, lhs: WValue, rhs: WValue, cmp_op: std.math.CompareOperator) InnerError!WValue {
-    const float_bits = ty.floatBits(cg.target.*);
+    const float_bits = ty.floatBits(cg.target);
 
     const op: Op = switch (cmp_op) {
         .lt => .lt,
@@ -4919,7 +4919,7 @@ fn airIntFromFloat(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 
     const operand = try cg.resolveInst(ty_op.operand);
     const op_ty = cg.typeOf(ty_op.operand);
-    const op_bits = op_ty.floatBits(cg.target.*);
+    const op_bits = op_ty.floatBits(cg.target);
 
     const dest_ty = cg.typeOfIndex(inst);
     const dest_info = dest_ty.intInfo(zcu);
@@ -4973,7 +4973,7 @@ fn airFloatFromInt(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const op_info = op_ty.intInfo(zcu);
 
     const dest_ty = cg.typeOfIndex(inst);
-    const dest_bits = dest_ty.floatBits(cg.target.*);
+    const dest_bits = dest_ty.floatBits(cg.target);
 
     if (op_info.bits > 128) {
         return cg.fail("TODO: floatFromInt for integers/floats with bitsize {d} bits", .{op_info.bits});
@@ -5567,8 +5567,8 @@ fn airFpext(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 /// Extends a float from a given `Type` to a larger wanted `Type`, leaving the
 /// result on the stack.
 fn fpext(cg: *CodeGen, operand: WValue, given: Type, wanted: Type) InnerError!WValue {
-    const given_bits = given.floatBits(cg.target.*);
-    const wanted_bits = wanted.floatBits(cg.target.*);
+    const given_bits = given.floatBits(cg.target);
+    const wanted_bits = wanted.floatBits(cg.target);
 
     const intrinsic: Mir.Intrinsic = switch (given_bits) {
         16 => switch (wanted_bits) {
@@ -5621,8 +5621,8 @@ fn airFptrunc(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 /// Truncates a float from a given `Type` to its wanted `Type`, leaving the
 /// result on the stack.
 fn fptrunc(cg: *CodeGen, operand: WValue, given: Type, wanted: Type) InnerError!WValue {
-    const given_bits = given.floatBits(cg.target.*);
-    const wanted_bits = wanted.floatBits(cg.target.*);
+    const given_bits = given.floatBits(cg.target);
+    const wanted_bits = wanted.floatBits(cg.target);
 
     const intrinsic: Mir.Intrinsic = switch (given_bits) {
         32 => switch (wanted_bits) {
@@ -6231,7 +6231,7 @@ fn airMaxMin(
 
     if (ty.zigTypeTag(zcu) == .float) {
         const intrinsic = switch (op) {
-            inline .fmin, .fmax => |ct_op| switch (ty.floatBits(cg.target.*)) {
+            inline .fmin, .fmax => |ct_op| switch (ty.floatBits(cg.target)) {
                 inline 16, 32, 64, 80, 128 => |bits| @field(
                     Mir.Intrinsic,
                     libcFloatPrefix(bits) ++ @tagName(ct_op) ++ libcFloatSuffix(bits),
@@ -6268,7 +6268,7 @@ fn airMulAdd(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const lhs = try cg.resolveInst(bin_op.lhs);
     const rhs = try cg.resolveInst(bin_op.rhs);
 
-    const result = if (ty.floatBits(cg.target.*) == 16) fl_result: {
+    const result = if (ty.floatBits(cg.target) == 16) fl_result: {
         const rhs_ext = try cg.fpext(rhs, ty, Type.f32);
         const lhs_ext = try cg.fpext(lhs, ty, Type.f32);
         const addend_ext = try cg.fpext(addend, ty, Type.f32);
@@ -6667,7 +6667,7 @@ fn airDivFloor(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
             _ = try cg.wrapOperand(.stack, ty);
         }
     } else {
-        const float_bits = ty.floatBits(cg.target.*);
+        const float_bits = ty.floatBits(cg.target);
         if (float_bits > 64) {
             return cg.fail("TODO: `@divFloor` for floats with bitsize: {d}", .{float_bits});
         }
diff --git a/src/arch/x86_64/CodeGen.zig b/src/arch/x86_64/CodeGen.zig
index 49e61e7067..6a6022b62d 100644
--- a/src/arch/x86_64/CodeGen.zig
+++ b/src/arch/x86_64/CodeGen.zig
@@ -32,88 +32,47 @@ const FrameIndex = bits.FrameIndex;
 
 const InnerError = codegen.CodeGenError || error{OutOfRegisters};
 
-pub fn legalizeFeatures(target: *const std.Target) *const Air.Legalize.Features {
-    @setEvalBranchQuota(1_200);
-    return switch (target.ofmt == .coff) {
-        inline false, true => |use_old| comptime &.init(.{
-            .scalarize_add = use_old,
-            .scalarize_add_sat = use_old,
-            .scalarize_sub = use_old,
-            .scalarize_sub_sat = use_old,
-            .scalarize_mul = use_old,
-            .scalarize_mul_wrap = use_old,
-            .scalarize_mul_sat = true,
-            .scalarize_div_float = use_old,
-            .scalarize_div_float_optimized = use_old,
-            .scalarize_div_trunc = use_old,
-            .scalarize_div_trunc_optimized = use_old,
-            .scalarize_div_floor = true,
-            .scalarize_div_floor_optimized = use_old,
-            .scalarize_div_exact = use_old,
-            .scalarize_div_exact_optimized = use_old,
-            .scalarize_mod = true,
-            .scalarize_max = use_old,
-            .scalarize_min = use_old,
-            .scalarize_add_with_overflow = true,
-            .scalarize_sub_with_overflow = true,
-            .scalarize_mul_with_overflow = true,
-            .scalarize_shl_with_overflow = true,
-            .scalarize_bit_and = use_old,
-            .scalarize_bit_or = use_old,
-            .scalarize_shr = true,
-            .scalarize_shr_exact = true,
-            .scalarize_shl = true,
-            .scalarize_shl_exact = true,
-            .scalarize_shl_sat = true,
-            .scalarize_xor = use_old,
-            .scalarize_not = use_old,
-            .scalarize_bitcast = true,
-            .scalarize_clz = use_old,
-            .scalarize_ctz = true,
-            .scalarize_popcount = true,
-            .scalarize_byte_swap = true,
-            .scalarize_bit_reverse = true,
-            .scalarize_sin = use_old,
-            .scalarize_cos = use_old,
-            .scalarize_tan = use_old,
-            .scalarize_exp = use_old,
-            .scalarize_exp2 = use_old,
-            .scalarize_log = use_old,
-            .scalarize_log2 = use_old,
-            .scalarize_log10 = use_old,
-            .scalarize_abs = use_old,
-            .scalarize_floor = use_old,
-            .scalarize_ceil = use_old,
-            .scalarize_trunc_float = use_old,
-            .scalarize_cmp_vector = true,
-            .scalarize_cmp_vector_optimized = true,
-            .scalarize_fptrunc = use_old,
-            .scalarize_fpext = use_old,
-            .scalarize_intcast = use_old,
-            .scalarize_int_from_float = use_old,
-            .scalarize_int_from_float_optimized = use_old,
-            .scalarize_float_from_int = use_old,
-            .scalarize_shuffle_one = true,
-            .scalarize_shuffle_two = true,
-            .scalarize_select = true,
-            .scalarize_mul_add = use_old,
-
-            .unsplat_shift_rhs = false,
-            .reduce_one_elem_to_bitcast = true,
-
-            .expand_intcast_safe = true,
-            .expand_int_from_float_safe = true,
-            .expand_int_from_float_optimized_safe = true,
-            .expand_add_safe = true,
-            .expand_sub_safe = true,
-            .expand_mul_safe = true,
-
-            .expand_packed_load = true,
-            .expand_packed_store = true,
-            .expand_packed_struct_field_val = true,
-            .expand_packed_aggregate_init = true,
-        }),
-    };
+pub fn legalizeFeatures(_: *const std.Target) *const Air.Legalize.Features {
+    return comptime &.initMany(&.{
+        .scalarize_mul_sat,
+        .scalarize_div_floor,
+        .scalarize_mod,
+        .scalarize_add_with_overflow,
+        .scalarize_sub_with_overflow,
+        .scalarize_mul_with_overflow,
+        .scalarize_shl_with_overflow,
+        .scalarize_shr,
+        .scalarize_shr_exact,
+        .scalarize_shl,
+        .scalarize_shl_exact,
+        .scalarize_shl_sat,
+        .scalarize_bitcast,
+        .scalarize_ctz,
+        .scalarize_popcount,
+        .scalarize_byte_swap,
+        .scalarize_bit_reverse,
+        .scalarize_cmp_vector,
+        .scalarize_cmp_vector_optimized,
+        .scalarize_shuffle_one,
+        .scalarize_shuffle_two,
+        .scalarize_select,
+
+        //.unsplat_shift_rhs,
+        .reduce_one_elem_to_bitcast,
+        .splat_one_elem_to_bitcast,
+
+        .expand_intcast_safe,
+        .expand_int_from_float_safe,
+        .expand_int_from_float_optimized_safe,
+        .expand_add_safe,
+        .expand_sub_safe,
+        .expand_mul_safe,
+
+        .expand_packed_load,
+        .expand_packed_store,
+        .expand_packed_struct_field_val,
+        .expand_packed_aggregate_init,
+    });
 }
 
 /// Set this to `false` to uncover Sema OPV bugs.
@@ -246,6 +205,7 @@ pub const MCValue = union(enum) {
     memory: u64,
     /// The value is in memory at a constant offset from the address in a register.
     indirect: bits.RegisterOffset,
+    indirect_load_frame: bits.FrameAddr,
     /// The value stored at an offset from a frame index
     /// Payload is a frame address.
     load_frame: bits.FrameAddr,
@@ -279,6 +239,7 @@ pub const MCValue = union(enum) {
             .register_mask,
             .eflags,
             .register_overflow,
+            .indirect_load_frame,
             .lea_frame,
             .lea_nav,
             .load_uav,
@@ -417,6 +378,7 @@ pub const MCValue = union(enum) {
                 0 => .{ .register = reg_off.reg },
                 else => .{ .register_offset = reg_off },
             },
+            .indirect_load_frame => |frame_addr| .{ .load_frame = frame_addr },
             .load_frame => |frame_addr| .{ .lea_frame = frame_addr },
             .load_nav => |nav| .{ .lea_nav = nav },
             .load_uav => |uav| .{ .lea_uav = uav },
@@ -439,7 +401,7 @@ pub const MCValue = union(enum) {
             .register_mask,
             .memory,
             .indirect,
-            .load_frame,
+            .indirect_load_frame,
             .load_nav,
             .load_uav,
             .load_lazy_sym,
@@ -451,6 +413,7 @@ pub const MCValue = union(enum) {
             .immediate => |addr| .{ .memory = addr },
             .register => |reg| .{ .indirect = .{ .reg = reg } },
             .register_offset => |reg_off| .{ .indirect = reg_off },
+            .load_frame => |frame_addr| .{ .indirect_load_frame = frame_addr },
             .lea_frame => |frame_addr| .{ .load_frame = frame_addr },
             .lea_nav => |nav| .{ .load_nav = nav },
             .lea_uav => |uav| .{ .load_uav = uav },
@@ -477,6 +440,7 @@ pub const MCValue = union(enum) {
             .register_mask,
             .memory,
             .indirect,
+            .indirect_load_frame,
             .load_frame,
             .load_nav,
             .lea_nav,
@@ -516,6 +480,7 @@ pub const MCValue = union(enum) {
             .register_offset,
             .register_overflow,
             .register_mask,
+            .indirect_load_frame,
             .lea_frame,
             .elementwise_args,
             .reserved_frame,
@@ -589,6 +554,7 @@ pub const MCValue = union(enum) {
                 @tagName(pl.reg),
             }),
             .indirect => |pl| try writer.print("[{s} + 0x{x}]", .{ @tagName(pl.reg), pl.off }),
+            .indirect_load_frame => |pl| try writer.print("[[{} + 0x{x}]]", .{ pl.index, pl.off }),
             .load_frame => |pl| try writer.print("[{} + 0x{x}]", .{ pl.index, pl.off }),
             .lea_frame => |pl| try writer.print("{} + 0x{x}", .{ pl.index, pl.off }),
             .load_nav => |pl| try writer.print("[nav:{d}]", .{@intFromEnum(pl)}),
@@ -621,6 +587,7 @@ const InstTracking = struct {
             .undef,
             .immediate,
             .memory,
+            .indirect_load_frame,
             .load_frame,
             .lea_frame,
             .load_nav,
@@ -724,6 +691,7 @@ const InstTracking = struct {
             .undef,
             .immediate,
             .memory,
+            .indirect_load_frame,
             .lea_frame,
             .load_nav,
             .lea_nav,
@@ -795,9 +763,9 @@ const InstTracking = struct {
         }
     }
 
-    fn die(self: *InstTracking, function: *CodeGen, inst: Air.Inst.Index) !void {
+    fn die(self: *InstTracking, function: *CodeGen, inst: Air.Inst.Index, comptime opts: FreeOptions) !void {
         if (self.short == .dead) return;
-        try function.freeValue(self.short);
+        try function.freeValue(self.short, opts);
         if (self.long == .none) self.long = self.short;
         self.short = .{ .dead = function.scope_generation };
         tracking_log.debug("{} => {} (death)", .{ inst, self.* });
@@ -2356,13 +2324,12 @@ fn genBodyBlock(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
 }
 
 fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
-    @setEvalBranchQuota(28_700);
+    @setEvalBranchQuota(29_400);
     const pt = cg.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     const air_tags = cg.air.instructions.items(.tag);
     const air_datas = cg.air.instructions.items(.data);
-    const use_old = cg.target.ofmt == .coff;
 
     for (body) |inst| {
         if (cg.liveness.isUnused(inst) and !cg.air.mustLower(inst, ip)) continue;
@@ -2372,17 +2339,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
         cg.reused_operands = .initEmpty();
         try cg.inst_tracking.ensureUnusedCapacity(cg.gpa, 1);
         switch (air_tags[@intFromEnum(inst)]) {
-            // zig fmt: off
-            .select           => try cg.airSelect(inst),
+            .select => try cg.airSelect(inst),
             .shuffle_one, .shuffle_two => @panic("x86_64 TODO: shuffle_one/shuffle_two"),
-            // zig fmt: on
 
             .arg => try cg.airArg(inst),
-            .add, .add_optimized, .add_wrap => |air_tag| if (use_old) try cg.airBinOp(inst, switch (air_tag) {
-                else => unreachable,
-                .add, .add_optimized => .add,
-                .add_wrap => .add_wrap,
-            }) else {
+            .add, .add_optimized, .add_wrap => |air_tag| {
                 const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                 var res: [1]Temp = undefined;
@@ -3393,7 +3354,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -3527,8 +3492,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                         .unused,
                         .unused,
@@ -3563,8 +3528,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                         .unused,
                         .unused,
@@ -3600,8 +3565,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
                         .unused,
@@ -3640,8 +3605,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
                         .{ .type = .f32, .kind = .mem },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                         .unused,
                         .unused,
@@ -4021,6 +3986,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .gnu,
                     .required_features = .{ .x87, null, null, null },
                     .src_constraints = .{
                         .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -4051,6 +4017,44 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .msvc,
+                    .required_features = .{ .x87, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .mem, .mem, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
+                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                        .{ .type = .u16, .kind = .mem },
+                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
+                        .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
+                        .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ },
+                        .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ },
+                        .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_00_11), ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
+                        .{ ._, ._, .mov, .memd(.tmp2b, 1), .tmp3b, ._, ._ },
+                        .{ ._, .f_p, .add, ._, ._, ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
+                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_abi = .gnu,
                     .required_features = .{ .x87, null, null, null },
                     .src_constraints = .{
                         .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -4082,6 +4086,45 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .msvc,
+                    .required_features = .{ .x87, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } },
+                        .{ .src = .{ .mem, .to_x87, .none } },
+                        .{ .src = .{ .to_x87, .to_x87, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                        .{ .type = .u16, .kind = .mem },
+                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
+                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
+                        .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
+                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_00_11), ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
+                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
+                        .{ ._, .f_, .add, .tmp0t, .src1t, ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
+                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_abi = .gnu,
                     .required_features = .{ .x87, null, null, null },
                     .src_constraints = .{
                         .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -4116,6 +4159,47 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .msvc,
+                    .required_features = .{ .x87, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .u16, .kind = .mem },
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
+                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, .fn_cw, .st, .tmp0w, ._, ._, ._ },
+                        .{ ._, ._, .movzx, .tmp1d, .memd(.tmp0b, 1), ._, ._ },
+                        .{ ._, ._, .@"or", .memd(.tmp0b, 1), .ui(0b000_0_00_11), ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ },
+                        .{ ._, ._, .mov, .memd(.tmp0b, 1), .tmp1b, ._, ._ },
+                        .{ ._, ._, .mov, .tmp1p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp1, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, .f_, .ld, .memia(.src1t, .tmp1, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, .f_p, .add, ._, ._, ._, ._ },
+                        .{ ._, .f_p, .st, .memia(.dst0t, .tmp1, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ },
+                    } },
+                }, .{
                     .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{
                         .{ .scalar_float = .{ .of = .xword, .is = .xword } },
@@ -4123,7 +4207,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -4157,8 +4245,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                         .unused,
                         .unused,
@@ -4192,8 +4280,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                         .unused,
                         .unused,
@@ -4227,8 +4315,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                         .unused,
                         .unused,
@@ -4273,7 +4361,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
             },
             .add_safe => unreachable,
-            .add_sat => |air_tag| if (use_old) try cg.airAddSat(inst) else {
+            .add_sat => |air_tag| {
                 const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                 var res: [1]Temp = undefined;
@@ -12838,11 +12926,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
             },
-            .sub, .sub_optimized, .sub_wrap => |air_tag| if (use_old) try cg.airBinOp(inst, switch (air_tag) {
-                else => unreachable,
-                .sub, .sub_optimized => .sub,
-                .sub_wrap => .sub_wrap,
-            }) else {
+            .sub, .sub_optimized, .sub_wrap => |air_tag| {
                 const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                 var res: [1]Temp = undefined;
@@ -13825,7 +13909,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -13959,8 +14047,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__subhf3" } },
                         .unused,
                         .unused,
@@ -13995,8 +14083,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__subhf3" } },
                         .unused,
                         .unused,
@@ -14032,8 +14120,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__subhf3" } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
                         .unused,
@@ -14072,8 +14160,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
                         .{ .type = .f32, .kind = .mem },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__subhf3" } },
                         .unused,
                         .unused,
@@ -14442,6 +14530,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .gnu,
                     .required_features = .{ .x87, null, null, null },
                     .src_constraints = .{
                         .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -14472,6 +14561,44 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .msvc,
+                    .required_features = .{ .x87, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .mem, .mem, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
+                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                        .{ .type = .u16, .kind = .mem },
+                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
+                        .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
+                        .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ },
+                        .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ },
+                        .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_00_11), ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
+                        .{ ._, ._, .mov, .memd(.tmp2b, 1), .tmp3b, ._, ._ },
+                        .{ ._, .f_p, .sub, ._, ._, ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
+                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_abi = .gnu,
                     .required_features = .{ .x87, null, null, null },
                     .src_constraints = .{
                         .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -14501,6 +14628,43 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .msvc,
+                    .required_features = .{ .x87, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                        .{ .type = .u16, .kind = .mem },
+                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
+                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
+                        .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
+                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_00_11), ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
+                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
+                        .{ ._, .f_, .subr, .tmp0t, .src1t, ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
+                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_abi = .gnu,
                     .required_features = .{ .x87, null, null, null },
                     .src_constraints = .{
                         .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -14531,6 +14695,44 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .msvc,
+                    .required_features = .{ .x87, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .mem, .to_x87, .none } },
+                        .{ .src = .{ .to_x87, .to_x87, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                        .{ .type = .u16, .kind = .mem },
+                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
+                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
+                        .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
+                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_00_11), ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
+                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
+                        .{ ._, .f_, .sub, .tmp0t, .src1t, ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
+                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_abi = .gnu,
                     .required_features = .{ .x87, null, null, null },
                     .src_constraints = .{
                         .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -14565,6 +14767,47 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .msvc,
+                    .required_features = .{ .x87, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .u16, .kind = .mem },
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
+                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, .fn_cw, .st, .tmp0w, ._, ._, ._ },
+                        .{ ._, ._, .movzx, .tmp1d, .memd(.tmp0b, 1), ._, ._ },
+                        .{ ._, ._, .@"or", .memd(.tmp0b, 1), .ui(0b000_0_00_11), ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ },
+                        .{ ._, ._, .mov, .memd(.tmp0b, 1), .tmp1b, ._, ._ },
+                        .{ ._, ._, .mov, .tmp1p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp1, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, .f_, .ld, .memia(.src1t, .tmp1, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, .f_p, .sub, ._, ._, ._, ._ },
+                        .{ ._, .f_p, .st, .memia(.dst0t, .tmp1, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ },
+                    } },
+                }, .{
                     .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{
                         .{ .scalar_float = .{ .of = .xword, .is = .xword } },
@@ -14572,7 +14815,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -14606,8 +14853,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__subtf3" } },
                         .unused,
                         .unused,
@@ -14641,8 +14888,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__subtf3" } },
                         .unused,
                         .unused,
@@ -14676,8 +14923,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__subtf3" } },
                         .unused,
                         .unused,
@@ -14722,7 +14969,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
             },
             .sub_safe => unreachable,
-            .sub_sat => |air_tag| if (use_old) try cg.airSubSat(inst) else {
+            .sub_sat => |air_tag| {
                 const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                 var res: [1]Temp = undefined;
@@ -21556,7 +21803,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
             },
-            .mul, .mul_optimized => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, .mul) else {
+            .mul, .mul_optimized => |air_tag| {
                 const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                 const ty = cg.typeOf(bin_op.lhs);
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
@@ -23355,7 +23602,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -23489,8 +23740,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } },
                         .unused,
                         .unused,
@@ -23525,8 +23776,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } },
                         .unused,
                         .unused,
@@ -23562,8 +23813,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
                         .unused,
@@ -23602,8 +23853,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
                         .{ .type = .f32, .kind = .mem },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } },
                         .unused,
                         .unused,
@@ -23983,6 +24234,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .gnu,
                     .required_features = .{ .x87, null, null, null },
                     .src_constraints = .{
                         .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -24013,6 +24265,44 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .msvc,
+                    .required_features = .{ .x87, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .mem, .mem, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
+                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                        .{ .type = .u16, .kind = .mem },
+                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
+                        .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
+                        .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ },
+                        .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ },
+                        .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_00_11), ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
+                        .{ ._, ._, .mov, .memd(.tmp2b, 1), .tmp3b, ._, ._ },
+                        .{ ._, .f_p, .mul, ._, ._, ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
+                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_abi = .gnu,
                     .required_features = .{ .x87, null, null, null },
                     .src_constraints = .{
                         .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -24044,6 +24334,45 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .msvc,
+                    .required_features = .{ .x87, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } },
+                        .{ .src = .{ .mem, .to_x87, .none } },
+                        .{ .src = .{ .to_x87, .to_x87, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                        .{ .type = .u16, .kind = .mem },
+                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
+                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
+                        .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
+                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_00_11), ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
+                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
+                        .{ ._, .f_, .mul, .tmp0t, .src1t, ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
+                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_abi = .gnu,
                     .required_features = .{ .x87, null, null, null },
                     .src_constraints = .{
                         .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -24078,6 +24407,47 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .msvc,
+                    .required_features = .{ .x87, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .u16, .kind = .mem },
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
+                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, .fn_cw, .st, .tmp0w, ._, ._, ._ },
+                        .{ ._, ._, .movzx, .tmp1d, .memd(.tmp0b, 1), ._, ._ },
+                        .{ ._, ._, .@"or", .memd(.tmp0b, 1), .ui(0b000_0_00_11), ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ },
+                        .{ ._, ._, .mov, .memd(.tmp0b, 1), .tmp1b, ._, ._ },
+                        .{ ._, ._, .mov, .tmp1p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp1, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, .f_, .ld, .memia(.src1t, .tmp1, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, .f_p, .mul, ._, ._, ._, ._ },
+                        .{ ._, .f_p, .st, .memia(.dst0t, .tmp1, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ },
+                    } },
+                }, .{
                     .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{
                         .{ .scalar_float = .{ .of = .xword, .is = .xword } },
@@ -24085,7 +24455,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -24119,8 +24493,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } },
                         .unused,
                         .unused,
@@ -24154,8 +24528,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } },
                         .unused,
                         .unused,
@@ -24189,8 +24563,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } },
                         .unused,
                         .unused,
@@ -24223,7 +24597,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
             },
             .mul_safe => unreachable,
-            .mul_wrap => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, air_tag) else {
+            .mul_wrap => |air_tag| {
                 const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                 const ty = cg.typeOf(bin_op.lhs);
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
@@ -26047,7 +26421,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -26181,8 +26559,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } },
                         .unused,
                         .unused,
@@ -26217,8 +26595,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } },
                         .unused,
                         .unused,
@@ -26254,8 +26632,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
                         .unused,
@@ -26294,8 +26672,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
                         .{ .type = .f32, .kind = .mem },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } },
                         .unused,
                         .unused,
@@ -26777,7 +27155,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -26811,8 +27193,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } },
                         .unused,
                         .unused,
@@ -26846,8 +27228,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } },
                         .unused,
                         .unused,
@@ -26881,8 +27263,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } },
                         .unused,
                         .unused,
@@ -26922,9 +27304,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
             },
-            .mul_sat => |air_tag| if (use_old) try cg.airMulSat(inst) else fallback: {
+            .mul_sat => |air_tag| {
                 const bin_op = air_datas[@intFromEnum(inst)].bin_op;
-                if (cg.typeOf(bin_op.lhs).isVector(zcu)) break :fallback try cg.airMulSat(inst);
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                 var res: [1]Temp = undefined;
                 cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{
@@ -32140,11 +32521,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
             },
-            .div_float, .div_float_optimized, .div_exact, .div_exact_optimized => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, switch (air_tag) {
-                else => unreachable,
-                .div_float, .div_float_optimized => .div_float,
-                .div_exact, .div_exact_optimized => .div_exact,
-            }) else {
+            .div_float, .div_float_optimized, .div_exact, .div_exact_optimized => |air_tag| {
                 const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                 const ty = cg.typeOf(bin_op.lhs);
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
@@ -32187,7 +32564,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -32321,8 +32702,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                         .unused,
                         .unused,
@@ -32357,8 +32738,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                         .unused,
                         .unused,
@@ -32394,8 +32775,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
                         .unused,
@@ -32434,8 +32815,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
                         .{ .type = .f32, .kind = .mem },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                         .unused,
                         .unused,
@@ -32805,6 +33186,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .gnu,
                     .required_features = .{ .x87, null, null, null },
                     .src_constraints = .{
                         .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -32835,6 +33217,44 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .msvc,
+                    .required_features = .{ .x87, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .mem, .mem, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
+                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                        .{ .type = .u16, .kind = .mem },
+                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
+                        .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
+                        .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ },
+                        .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ },
+                        .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_00_11), ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
+                        .{ ._, ._, .mov, .memd(.tmp2b, 1), .tmp3b, ._, ._ },
+                        .{ ._, .f_p, .div, ._, ._, ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
+                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_abi = .gnu,
                     .required_features = .{ .x87, null, null, null },
                     .src_constraints = .{
                         .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -32864,6 +33284,43 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .msvc,
+                    .required_features = .{ .x87, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                        .{ .type = .u16, .kind = .mem },
+                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
+                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
+                        .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
+                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_00_11), ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
+                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
+                        .{ ._, .f_, .divr, .tmp0t, .src1t, ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
+                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_abi = .gnu,
                     .required_features = .{ .x87, null, null, null },
                     .src_constraints = .{
                         .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -32894,6 +33351,44 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .msvc,
+                    .required_features = .{ .x87, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .mem, .to_x87, .none } },
+                        .{ .src = .{ .to_x87, .to_x87, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                        .{ .type = .u16, .kind = .mem },
+                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
+                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
+                        .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
+                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_00_11), ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
+                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
+                        .{ ._, .f_, .div, .tmp0t, .src1t, ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
+                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_abi = .gnu,
                     .required_features = .{ .x87, null, null, null },
                     .src_constraints = .{
                         .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -32928,6 +33423,47 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .msvc,
+                    .required_features = .{ .x87, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .u16, .kind = .mem },
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
+                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, .fn_cw, .st, .tmp0w, ._, ._, ._ },
+                        .{ ._, ._, .movzx, .tmp1d, .memd(.tmp0b, 1), ._, ._ },
+                        .{ ._, ._, .@"or", .memd(.tmp0b, 1), .ui(0b000_0_00_11), ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ },
+                        .{ ._, ._, .mov, .memd(.tmp0b, 1), .tmp1b, ._, ._ },
+                        .{ ._, ._, .mov, .tmp1p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp1, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, .f_, .ld, .memia(.src1t, .tmp1, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, .f_p, .div, ._, ._, ._, ._ },
+                        .{ ._, .f_p, .st, .memia(.dst0t, .tmp1, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ },
+                    } },
+                }, .{
                     .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{
                         .{ .scalar_float = .{ .of = .xword, .is = .xword } },
@@ -32935,7 +33471,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -32969,8 +33509,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                         .unused,
                         .unused,
@@ -33004,8 +33544,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                         .unused,
                         .unused,
@@ -33039,8 +33579,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                         .unused,
                         .unused,
@@ -33075,7 +33615,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
             },
-            .div_trunc => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, air_tag) else {
+            .div_trunc => |air_tag| {
                 const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                 const ty = cg.typeOf(bin_op.lhs);
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
@@ -33121,7 +33661,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -33265,8 +33809,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__trunch" } },
                         .unused,
@@ -33302,8 +33846,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__trunch" } },
                         .unused,
@@ -33340,8 +33884,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__trunch" } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
@@ -33381,8 +33925,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
                         .{ .type = .f32, .kind = .mem },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__trunch" } },
                         .unused,
@@ -33448,7 +33992,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .to_mem, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -33515,7 +34059,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "truncf" } },
                         .unused,
                         .unused,
@@ -33661,7 +34205,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .to_mem, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -33691,7 +34235,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -33842,7 +34390,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "trunc" } },
                         .unused,
                         .unused,
@@ -33877,8 +34425,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__divdf3" } },
                         .{ .type = .usize, .kind = .{ .extern_func = "trunc" } },
                         .unused,
@@ -33903,6 +34451,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .gnu,
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .x87, null, null, null },
                     .src_constraints = .{
                         .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -33936,6 +34486,88 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .gnu,
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .x87, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
+                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__truncx" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
+                        .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
+                        .{ ._, .f_p, .div, ._, ._, ._, ._ },
+                        .{ ._, .f_p, .st, .lea(.tmp2t), ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp3p, .tmp2p, ._, ._ },
+                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_abi = .msvc,
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .x87, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
+                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                        .{ .type = .u16, .kind = .mem },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__truncx" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
+                        .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
+                        .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ },
+                        .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ },
+                        .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_00_11), ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
+                        .{ ._, ._, .mov, .memd(.tmp2b, 1), .tmp3b, ._, ._ },
+                        .{ ._, ._, .lea, .tmp3p, .mem(.dst0), ._, ._ },
+                        .{ ._, .f_p, .div, ._, ._, ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
+                        .{ ._, .f_p, .st, .lea(.tmp3t), ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp4p, .tmp3p, ._, ._ },
+                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_abi = .gnu,
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .x87, null, null, null },
                     .src_constraints = .{
                         .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -33974,6 +34606,92 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .gnu,
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .x87, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
+                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__truncx" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, .f_p, .div, ._, ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp3p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, .f_p, .st, .lea(.tmp3t), ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp4p, .tmp3p, ._, ._ },
+                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_abi = .msvc,
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .x87, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u16, .kind = .mem },
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
+                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__truncx" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, .fn_cw, .st, .tmp0w, ._, ._, ._ },
+                        .{ ._, ._, .movzx, .tmp1d, .memd(.tmp0b, 1), ._, ._ },
+                        .{ ._, ._, .@"or", .memd(.tmp0b, 1), .ui(0b000_0_00_11), ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ },
+                        .{ ._, ._, .mov, .memd(.tmp0b, 1), .tmp1b, ._, ._ },
+                        .{ ._, ._, .mov, .tmp1p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp1, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, .f_, .ld, .memia(.src1t, .tmp1, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, .f_p, .div, ._, ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp4p, .memia(.dst0, .tmp1, .add_unaligned_size), ._, ._ },
+                        .{ ._, .f_p, .st, .lea(.tmp4t), ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp5p, .tmp4p, ._, ._ },
+                        .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
+                        .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ },
+                    } },
+                }, .{
                     .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{
                         .{ .scalar_float = .{ .of = .xword, .is = .xword } },
@@ -33981,7 +34699,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -34016,8 +34738,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                         .{ .type = .usize, .kind = .{ .extern_func = "truncq" } },
                         .unused,
@@ -34052,8 +34774,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                         .{ .type = .usize, .kind = .{ .extern_func = "truncq" } },
                         .unused,
@@ -34088,8 +34810,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                         .{ .type = .usize, .kind = .{ .extern_func = "truncq" } },
                         .unused,
@@ -34124,11 +34846,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
             },
-            .div_trunc_optimized, .div_floor_optimized => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, switch (air_tag) {
-                else => unreachable,
-                .div_trunc_optimized => .div_trunc,
-                .div_floor_optimized => .div_floor,
-            }) else {
+            .div_trunc_optimized, .div_floor_optimized => |air_tag| {
                 const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                 var res: [1]Temp = undefined;
@@ -34177,7 +34895,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .any,
                         },
                         .patterns = &.{
-                            .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                            .{ .src = .{
+                                .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                                .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                                .none,
+                            } },
                         },
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
@@ -34319,8 +35041,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                             .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                 else => unreachable,
@@ -34360,8 +35082,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                             .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                 else => unreachable,
@@ -34402,8 +35124,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                             .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                 else => unreachable,
@@ -34447,8 +35169,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                             .{ .type = .f16, .kind = .{ .reg = .ax } },
                             .{ .type = .f32, .kind = .mem },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                             .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                 else => unreachable,
@@ -34518,7 +35240,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .any,
                         },
                         .patterns = &.{
-                            .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } },
+                            .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .to_mem, .none } },
                         },
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
@@ -34589,7 +35311,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                 else => unreachable,
                                 .zero => "truncf",
@@ -34739,7 +35461,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .any,
                         },
                         .patterns = &.{
-                            .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } },
+                            .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .to_mem, .none } },
                         },
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
@@ -34773,7 +35495,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .any,
                         },
                         .patterns = &.{
-                            .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                            .{ .src = .{
+                                .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                                .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                                .none,
+                            } },
                         },
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
@@ -34928,7 +35654,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                 else => unreachable,
                                 .zero => "trunc",
@@ -34967,8 +35693,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
-                            .{ .type = .f64, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                            .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__divdf3" } },
                             .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                 else => unreachable,
@@ -34997,6 +35723,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                         } },
                     }, .{
+                        .required_abi = .gnu,
+                        .required_cc_abi = .sysv64,
                         .required_features = .{ .x87, null, null, null },
                         .src_constraints = .{
                             .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -35004,7 +35732,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .any,
                         },
                         .patterns = &.{
-                            .{ .src = .{ .mem, .mem, .none } },
+                            .{ .src = .{ .to_mem, .to_mem, .none } },
                         },
                         .call_frame = .{ .size = 16, .alignment = .@"16" },
                         .extra_temps = .{
@@ -35034,6 +35762,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                         } },
                     }, .{
+                        .required_abi = .gnu,
+                        .required_cc_abi = .win64,
                         .required_features = .{ .x87, null, null, null },
                         .src_constraints = .{
                             .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -35041,12 +35771,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .any,
                         },
                         .patterns = &.{
-                            .{ .src = .{ .to_x87, .mem, .none } },
+                            .{ .src = .{ .to_mem, .to_mem, .none } },
                         },
-                        .call_frame = .{ .size = 16, .alignment = .@"16" },
+                        .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
+                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
                             .{ .type = .f80, .kind = .{ .reg = .st7 } },
-                            .{ .type = .f80, .kind = .{ .frame = .call_frame } },
+                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                 else => unreachable,
                                 .zero => "__truncx",
@@ -35058,18 +35790,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                             .unused,
-                            .unused,
-                            .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .st0 }, .unused },
+                        .dst_temps = .{ .mem, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
-                            .{ ._, .f_, .divr, .tmp0t, .src1t, ._, ._ },
-                            .{ ._, .f_p, .st, .mem(.tmp1t), ._, ._, ._ },
-                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                            .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
+                            .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
+                            .{ ._, .f_p, .div, ._, ._, ._, ._ },
+                            .{ ._, .f_p, .st, .lea(.tmp2t), ._, ._, ._ },
+                            .{ ._, ._, .mov, .tmp3p, .tmp2p, ._, ._ },
+                            .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                         } },
                     }, .{
+                        .required_abi = .msvc,
+                        .required_cc_abi = .win64,
                         .required_features = .{ .x87, null, null, null },
                         .src_constraints = .{
                             .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -35077,13 +35812,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .any,
                         },
                         .patterns = &.{
-                            .{ .src = .{ .mem, .to_x87, .none } },
-                            .{ .src = .{ .to_x87, .to_x87, .none } },
+                            .{ .src = .{ .to_mem, .to_mem, .none } },
                         },
-                        .call_frame = .{ .size = 16, .alignment = .@"16" },
+                        .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
+                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
                             .{ .type = .f80, .kind = .{ .reg = .st7 } },
-                            .{ .type = .f80, .kind = .{ .frame = .call_frame } },
+                            .{ .type = .u16, .kind = .mem },
+                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                 else => unreachable,
                                 .zero => "__truncx",
@@ -35094,19 +35831,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                             .unused,
-                            .unused,
-                            .unused,
-                            .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .st0 }, .unused },
+                        .dst_temps = .{ .mem, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
-                            .{ ._, .f_, .div, .tmp0t, .src1t, ._, ._ },
-                            .{ ._, .f_p, .st, .mem(.tmp1t), ._, ._, ._ },
-                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                            .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
+                            .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ },
+                            .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ },
+                            .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_00_11), ._, ._ },
+                            .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
+                            .{ ._, ._, .mov, .memd(.tmp2b, 1), .tmp3b, ._, ._ },
+                            .{ ._, ._, .lea, .tmp3p, .mem(.dst0), ._, ._ },
+                            .{ ._, .f_p, .div, ._, ._, ._, ._ },
+                            .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
+                            .{ ._, .f_p, .st, .lea(.tmp3t), ._, ._, ._ },
+                            .{ ._, ._, .mov, .tmp4p, .tmp3p, ._, ._ },
+                            .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                         } },
                     }, .{
+                        .required_abi = .gnu,
+                        .required_cc_abi = .sysv64,
                         .required_features = .{ .x87, null, null, null },
                         .src_constraints = .{
                             .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -35149,6 +35894,100 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                         } },
                     }, .{
+                        .required_abi = .gnu,
+                        .required_cc_abi = .win64,
+                        .required_features = .{ .x87, null, null, null },
+                        .src_constraints = .{
+                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
+                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
+                            .any,
+                        },
+                        .patterns = &.{
+                            .{ .src = .{ .to_mem, .to_mem, .none } },
+                        },
+                        .call_frame = .{ .alignment = .@"16" },
+                        .extra_temps = .{
+                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
+                            .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
+                                else => unreachable,
+                                .zero => "__truncx",
+                                .down => "__floorx",
+                            } } },
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                        },
+                        .dst_temps = .{ .mem, .unused },
+                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                        .each = .{ .once = &.{
+                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                            .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
+                            .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ },
+                            .{ ._, .f_p, .div, ._, ._, ._, ._ },
+                            .{ ._, ._, .lea, .tmp3p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ },
+                            .{ ._, .f_p, .st, .lea(.tmp3t), ._, ._, ._ },
+                            .{ ._, ._, .mov, .tmp4p, .tmp3p, ._, ._ },
+                            .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
+                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        } },
+                    }, .{
+                        .required_abi = .msvc,
+                        .required_cc_abi = .win64,
+                        .required_features = .{ .x87, null, null, null },
+                        .src_constraints = .{
+                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
+                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
+                            .any,
+                        },
+                        .patterns = &.{
+                            .{ .src = .{ .to_mem, .to_mem, .none } },
+                        },
+                        .call_frame = .{ .alignment = .@"16" },
+                        .extra_temps = .{
+                            .{ .type = .u16, .kind = .mem },
+                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
+                            .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
+                                else => unreachable,
+                                .zero => "__truncx",
+                                .down => "__floorx",
+                            } } },
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                        },
+                        .dst_temps = .{ .mem, .unused },
+                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                        .each = .{ .once = &.{
+                            .{ ._, .fn_cw, .st, .tmp0w, ._, ._, ._ },
+                            .{ ._, ._, .movzx, .tmp1d, .memd(.tmp0b, 1), ._, ._ },
+                            .{ ._, ._, .@"or", .memd(.tmp0b, 1), .ui(0b000_0_00_11), ._, ._ },
+                            .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ },
+                            .{ ._, ._, .mov, .memd(.tmp0b, 1), .tmp1b, ._, ._ },
+                            .{ ._, ._, .mov, .tmp1p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                            .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp1, .add_unaligned_size), ._, ._, ._ },
+                            .{ ._, .f_, .ld, .memia(.src1t, .tmp1, .add_unaligned_size), ._, ._, ._ },
+                            .{ ._, .f_p, .div, ._, ._, ._, ._ },
+                            .{ ._, ._, .lea, .tmp4p, .memia(.dst0, .tmp1, .add_unaligned_size), ._, ._ },
+                            .{ ._, .f_p, .st, .lea(.tmp4t), ._, ._, ._ },
+                            .{ ._, ._, .mov, .tmp5p, .tmp4p, ._, ._ },
+                            .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
+                            .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ },
+                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                            .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ },
+                        } },
+                    }, .{
                         .required_features = .{ .sse, null, null, null },
                         .src_constraints = .{
                             .{ .scalar_float = .{ .of = .xword, .is = .xword } },
@@ -35156,7 +35995,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .any,
                         },
                         .patterns = &.{
-                            .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                            .{ .src = .{
+                                .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                                .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                                .none,
+                            } },
                         },
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
@@ -35195,8 +36038,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                             .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                 else => unreachable,
@@ -35235,8 +36078,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                             .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                 else => unreachable,
@@ -35275,8 +36118,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                             .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                 else => unreachable,
@@ -35314,7 +36157,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
             },
-            .div_floor => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, air_tag) else {
+            .div_floor => |air_tag| {
                 const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                 const ty = cg.typeOf(bin_op.lhs);
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
@@ -35460,15 +36303,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .{ ._, ._, .adc, .dst0q, .si(-1), ._, ._ },
                         } },
                     }, .{
-                        .required_features = .{ .@"64bit", null, null, null },
+                        .required_cc_abi = .sysv64,
                         .src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any },
                         .patterns = &.{
                             .{ .src = .{ .mem, .mem, .none } },
                         },
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
-                            .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .at = 0 } } },
-                            .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } },
+                            .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                            .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__modti3" } },
                             .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__divti3" } },
@@ -35479,7 +36322,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .at = 0 } }, .unused },
+                        .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, ._, .mov, .tmp0q0, .mem(.src0q), ._, ._ },
@@ -35515,10 +36358,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         },
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
-                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 0 } } },
-                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 1 } } },
-                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 2 } } },
-                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } },
+                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
+                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                             .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__divei4" } },
                             .{ .kind = .{ .mem_of_type = .dst0 } },
@@ -35597,7 +36440,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -35741,8 +36588,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floorh" } },
                         .unused,
@@ -35778,8 +36625,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floorh" } },
                         .unused,
@@ -35816,8 +36663,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floorh" } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
@@ -35857,8 +36704,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
                         .{ .type = .f32, .kind = .mem },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floorh" } },
                         .unused,
@@ -35924,7 +36771,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .to_mem, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -35991,7 +36838,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "floorf" } },
                         .unused,
                         .unused,
@@ -36137,7 +36984,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .to_mem, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -36167,7 +37014,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -36318,7 +37169,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "floor" } },
                         .unused,
                         .unused,
@@ -36353,8 +37204,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__divdf3" } },
                         .{ .type = .usize, .kind = .{ .extern_func = "floor" } },
                         .unused,
@@ -36379,6 +37230,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .gnu,
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .x87, null, null, null },
                     .src_constraints = .{
                         .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -36412,6 +37265,88 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .gnu,
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .x87, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
+                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floorx" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
+                        .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
+                        .{ ._, .f_p, .div, ._, ._, ._, ._ },
+                        .{ ._, .f_p, .st, .lea(.tmp2t), ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp3p, .tmp2p, ._, ._ },
+                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_abi = .msvc,
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .x87, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
+                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                        .{ .type = .u16, .kind = .mem },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floorx" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
+                        .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
+                        .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ },
+                        .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ },
+                        .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_00_11), ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
+                        .{ ._, ._, .mov, .memd(.tmp2b, 1), .tmp3b, ._, ._ },
+                        .{ ._, ._, .lea, .tmp3p, .mem(.dst0), ._, ._ },
+                        .{ ._, .f_p, .div, ._, ._, ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
+                        .{ ._, .f_p, .st, .lea(.tmp3t), ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp4p, .tmp3p, ._, ._ },
+                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_abi = .gnu,
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .x87, null, null, null },
                     .src_constraints = .{
                         .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -36450,6 +37385,92 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .gnu,
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .x87, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
+                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floorx" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, .f_p, .div, ._, ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp3p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, .f_p, .st, .lea(.tmp3t), ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp4p, .tmp3p, ._, ._ },
+                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_abi = .msvc,
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .x87, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u16, .kind = .mem },
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
+                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floorx" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, .fn_cw, .st, .tmp0w, ._, ._, ._ },
+                        .{ ._, ._, .movzx, .tmp1d, .memd(.tmp0b, 1), ._, ._ },
+                        .{ ._, ._, .@"or", .memd(.tmp0b, 1), .ui(0b000_0_00_11), ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ },
+                        .{ ._, ._, .mov, .memd(.tmp0b, 1), .tmp1b, ._, ._ },
+                        .{ ._, ._, .mov, .tmp1p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp1, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, .f_, .ld, .memia(.src1t, .tmp1, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, .f_p, .div, ._, ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp4p, .memia(.dst0, .tmp1, .add_unaligned_size), ._, ._ },
+                        .{ ._, .f_p, .st, .lea(.tmp4t), ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp5p, .tmp4p, ._, ._ },
+                        .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
+                        .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ },
+                    } },
+                }, .{
                     .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{
                         .{ .scalar_float = .{ .of = .xword, .is = .xword } },
@@ -36457,7 +37478,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -36492,8 +37517,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                         .{ .type = .usize, .kind = .{ .extern_func = "floorq" } },
                         .unused,
@@ -36528,8 +37553,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                         .{ .type = .usize, .kind = .{ .extern_func = "floorq" } },
                         .unused,
@@ -36564,8 +37589,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                         .{ .type = .usize, .kind = .{ .extern_func = "floorq" } },
                         .unused,
@@ -36598,7 +37623,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
             },
-            .rem, .rem_optimized => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, .rem) else {
+            .rem, .rem_optimized => |air_tag| {
                 const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                 var res: [1]Temp = undefined;
@@ -36712,12 +37737,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .div, .src1q, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", null, null, null },
+                    .required_cc_abi = .sysv64,
                     .src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any },
                     .patterns = &.{
                         .{ .src = .{
-                            .{ .to_param_gpr_pair = .{ .cc = .ccc, .at = 0 } },
-                            .{ .to_param_gpr_pair = .{ .cc = .ccc, .at = 2 } },
+                            .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 2, .at = 2 } },
                             .none,
                         } },
                     },
@@ -36735,18 +37760,46 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .at = 0 } }, .unused },
+                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", null, null, null },
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__modti3" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
                     .src_constraints = .{ .{ .unsigned_int = .xword }, .{ .unsigned_int = .xword }, .any },
                     .patterns = &.{
                         .{ .src = .{
-                            .{ .to_param_gpr_pair = .{ .cc = .ccc, .at = 0 } },
-                            .{ .to_param_gpr_pair = .{ .cc = .ccc, .at = 2 } },
+                            .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 2, .at = 2 } },
                             .none,
                         } },
                     },
@@ -36764,12 +37817,40 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .at = 0 } }, .unused },
+                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .unsigned_int = .xword }, .{ .unsigned_int = .xword }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__umodti3" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                    } },
+                }, .{
                     .required_features = .{ .@"64bit", null, null, null },
                     .src_constraints = .{
                         .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } },
@@ -36781,10 +37862,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 0 } } },
-                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 1 } } },
-                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 2 } } },
-                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__modei4" } },
                         .unused,
                         .unused,
@@ -36814,10 +37895,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 0 } } },
-                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 1 } } },
-                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 2 } } },
-                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__umodei4" } },
                         .unused,
                         .unused,
@@ -37166,7 +38247,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", null, null, null },
+                    .required_cc_abi = .sysv64,
                     .src_constraints = .{
                         .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } },
                         .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } },
@@ -37178,12 +38259,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 0 } } },
-                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 1 } } },
-                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 2 } } },
-                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } },
+                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
+                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__modti3" } },
-                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .at = 0 } } },
+                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -37204,7 +38285,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", null, null, null },
+                    .required_cc_abi = .sysv64,
                     .src_constraints = .{
                         .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } },
                         .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } },
@@ -37216,12 +38297,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 0 } } },
-                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 1 } } },
-                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 2 } } },
-                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } },
+                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
+                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__umodti3" } },
-                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .at = 0 } } },
+                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -37254,10 +38335,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 0 } } },
-                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 1 } } },
-                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 2 } } },
-                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__modei4" } },
                         .unused,
                         .unused,
@@ -37290,10 +38371,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 0 } } },
-                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 1 } } },
-                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 2 } } },
-                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__umodei4" } },
                         .unused,
                         .unused,
@@ -37321,7 +38402,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -37355,8 +38440,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                         .unused,
                         .unused,
@@ -37391,8 +38476,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                         .unused,
                         .unused,
@@ -37428,8 +38513,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
                         .unused,
@@ -37468,8 +38553,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
                         .{ .type = .f32, .kind = .mem },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                         .unused,
                         .unused,
@@ -37502,7 +38587,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -37536,8 +38625,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "fmodf" } },
                         .unused,
                         .unused,
@@ -37571,8 +38660,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "fmodf" } },
                         .unused,
                         .unused,
@@ -37601,7 +38690,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -37635,8 +38728,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "fmod" } },
                         .unused,
                         .unused,
@@ -37670,8 +38763,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "fmod" } },
                         .unused,
                         .unused,
@@ -37705,8 +38798,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "fmod" } },
                         .unused,
                         .unused,
@@ -37730,6 +38823,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .avx, .x87, null, null },
                     .src_constraints = .{
                         .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -37741,7 +38835,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                         .unused,
@@ -37763,6 +38857,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .sse2, .x87, null, null },
                     .src_constraints = .{
                         .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -37774,7 +38869,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                         .unused,
@@ -37796,6 +38891,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .sse, .x87, null, null },
                     .src_constraints = .{
                         .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -37807,7 +38903,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                         .unused,
@@ -37829,6 +38925,39 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .win64,
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .mem(.src1), ._, ._ },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .avx, .x87, null, null },
                     .src_constraints = .{
                         .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -37841,7 +38970,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                         .unused,
@@ -37867,6 +38996,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .sse2, .x87, null, null },
                     .src_constraints = .{
                         .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -37879,7 +39009,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                         .unused,
@@ -37905,6 +39035,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .sse, .x87, null, null },
                     .src_constraints = .{
                         .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -37917,7 +39048,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                         .unused,
@@ -37943,6 +39074,41 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .win64,
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp3p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
                     .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{
                         .{ .scalar_float = .{ .of = .xword, .is = .xword } },
@@ -37950,7 +39116,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -37984,8 +39154,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "fmodq" } },
                         .unused,
                         .unused,
@@ -38019,8 +39189,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "fmodq" } },
                         .unused,
                         .unused,
@@ -38054,8 +39224,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "fmodq" } },
                         .unused,
                         .unused,
@@ -38087,7 +39257,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
             },
-            .mod, .mod_optimized => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, .mod) else {
+            .mod, .mod_optimized => |air_tag| {
                 const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                 var res: [1]Temp = undefined;
@@ -38383,14 +39553,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .div, .src1q, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .cmov, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .cmov, null, null, null },
                     .src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .at = 0 } }, .to_mem, .none } },
+                        .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .to_mem, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } },
+                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__modti3" } },
                         .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                         .unused,
@@ -38402,7 +39573,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .at = 0 } }, .unused },
+                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .mov, .dst0q1, .mem(.src1q), ._, ._ },
@@ -38422,14 +39593,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .adc, .dst0q1, .src0q0, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", null, null, null },
+                    .required_cc_abi = .sysv64,
                     .src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .at = 0 } }, .to_mem, .none } },
+                        .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .to_mem, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } },
+                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__modti3" } },
                         .unused,
                         .unused,
@@ -38441,7 +39612,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .at = 0 } }, .unused },
+                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .mov, .dst0q1, .mem(.src1q), ._, ._ },
@@ -38459,12 +39630,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .adc, .dst0q1, .src0q0, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", null, null, null },
+                    .required_cc_abi = .sysv64,
                     .src_constraints = .{ .{ .unsigned_int = .xword }, .{ .unsigned_int = .xword }, .any },
                     .patterns = &.{
                         .{ .src = .{
-                            .{ .to_param_gpr_pair = .{ .cc = .ccc, .at = 0 } },
-                            .{ .to_param_gpr_pair = .{ .cc = .ccc, .at = 2 } },
+                            .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 2, .at = 2 } },
                             .none,
                         } },
                     },
@@ -38482,7 +39653,65 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .at = 0 } }, .unused },
+                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .unsigned_int = .xword }, .{ .unsigned_int = .xword }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__umodti3" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .unsigned_int = .xword }, .{ .unsigned_int = .xword }, .any },
+                    .patterns = &.{
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .extern_func = "__umodti3" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
@@ -38499,10 +39728,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 0 } } },
-                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 1 } } },
-                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 2 } } },
-                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                         .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__modei4" } },
                         .unused,
@@ -38557,10 +39786,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 0 } } },
-                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 1 } } },
-                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 2 } } },
-                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__umodei4" } },
                         .unused,
                         .unused,
@@ -38586,7 +39815,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -38627,7 +39860,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -38668,7 +39905,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -38706,7 +39947,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -38744,7 +39989,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -38782,7 +40031,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -38820,7 +40073,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -38858,7 +40115,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -38901,9 +40162,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                         .{ .type = .f16, .kind = .{ .reg = .dx } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
@@ -38949,9 +40210,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                         .{ .type = .f16, .kind = .{ .reg = .dx } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
@@ -38997,9 +40258,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                         .{ .type = .f16, .kind = .{ .reg = .dx } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
@@ -39042,9 +40303,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                         .{ .type = .f16, .kind = .{ .reg = .dx } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
@@ -39087,9 +40348,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                         .{ .type = .f16, .kind = .{ .reg = .dx } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
@@ -39132,9 +40393,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                         .{ .type = .f16, .kind = .{ .reg = .dx } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
@@ -39177,9 +40438,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                         .{ .type = .f16, .kind = .{ .reg = .dx } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
@@ -39223,9 +40484,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                         .{ .type = .f16, .kind = .{ .reg = .dx } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
@@ -39271,8 +40532,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
                         .{ .type = .f32, .kind = .mem },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                         .{ .type = .f32, .kind = .mem },
                         .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
@@ -39320,8 +40581,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
                         .{ .type = .f32, .kind = .mem },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                         .{ .type = .f32, .kind = .mem },
                         .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
@@ -39362,7 +40623,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -39400,7 +40665,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -39438,7 +40707,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -39480,8 +40753,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .f32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .extern_func = "fmodf" } },
                         .{ .type = .f32, .kind = .{ .reg = .edx } },
@@ -39524,8 +40797,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .f32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .extern_func = "fmodf" } },
                         .{ .type = .f32, .kind = .{ .reg = .edx } },
@@ -39568,8 +40841,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "fmodf" } },
                         .{ .type = .f32, .kind = .mem },
                         .{ .type = .f32, .kind = .{ .reg = .eax } },
@@ -39605,7 +40878,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -39644,7 +40921,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -39683,7 +40964,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -39730,8 +41015,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .f64, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .extern_func = "fmod" } },
                         .{ .type = .f64, .kind = .{ .reg = .rcx } },
@@ -39775,8 +41060,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .f64, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .extern_func = "fmod" } },
                         .{ .type = .f64, .kind = .{ .reg = .rcx } },
@@ -39820,8 +41105,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "fmod" } },
                         .{ .type = .f64, .kind = .{ .reg = .rdx } },
                         .{ .type = .f64, .kind = .mem },
@@ -39857,6 +41142,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .gnu,
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .@"64bit", .avx, .x87, .fast_imm16 },
                     .src_constraints = .{
                         .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -39868,7 +41155,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
@@ -39900,6 +41187,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, .f_p, .add, ._, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .gnu,
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .@"64bit", .avx, .x87, null },
                     .src_constraints = .{
                         .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -39911,7 +41200,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
@@ -39943,6 +41232,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, .f_p, .add, ._, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .gnu,
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .@"64bit", .sse2, .x87, .fast_imm16 },
                     .src_constraints = .{
                         .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -39954,7 +41245,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
@@ -39986,6 +41277,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, .f_p, .add, ._, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .gnu,
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .@"64bit", .sse2, .x87, null },
                     .src_constraints = .{
                         .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -39997,7 +41290,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
@@ -40029,6 +41322,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, .f_p, .add, ._, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .gnu,
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .@"64bit", .sse, .x87, .fast_imm16 },
                     .src_constraints = .{
                         .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -40040,7 +41335,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
@@ -40072,6 +41367,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, .f_p, .add, ._, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .gnu,
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .@"64bit", .sse, .x87, null },
                     .src_constraints = .{
                         .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -40083,7 +41380,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
@@ -40115,6 +41412,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, .f_p, .add, ._, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .gnu,
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .@"64bit", .avx, .x87, .fast_imm16 },
                     .src_constraints = .{
                         .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -40127,7 +41426,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
@@ -40163,6 +41462,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .gnu,
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .@"64bit", .avx, .x87, null },
                     .src_constraints = .{
                         .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -40175,7 +41476,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
@@ -40211,6 +41512,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .gnu,
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .@"64bit", .sse2, .x87, .fast_imm16 },
                     .src_constraints = .{
                         .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -40223,7 +41526,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
@@ -40259,6 +41562,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .gnu,
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .@"64bit", .sse2, .x87, null },
                     .src_constraints = .{
                         .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -40271,7 +41576,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
@@ -40307,6 +41612,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .gnu,
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .@"64bit", .sse, .x87, .fast_imm16 },
                     .src_constraints = .{
                         .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -40319,7 +41626,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
@@ -40355,6 +41662,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .gnu,
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .@"64bit", .sse, .x87, null },
                     .src_constraints = .{
                         .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -40367,7 +41676,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
@@ -40410,7 +41719,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -40451,7 +41764,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -40492,7 +41809,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -40534,7 +41855,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -40579,8 +41904,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "fmodq" } },
                         .{ .type = .f128, .kind = .{ .reg = .rcx } },
                         .{ .type = .f128, .kind = .{ .reg = .rdx } },
@@ -40625,8 +41950,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "fmodq" } },
                         .{ .type = .f128, .kind = .{ .reg = .rcx } },
                         .{ .type = .f128, .kind = .{ .reg = .rdx } },
@@ -40671,8 +41996,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "fmodq" } },
                         .{ .type = .f128, .kind = .{ .reg = .rcx } },
                         .{ .type = .f128, .kind = .{ .reg = .rdx } },
@@ -40718,8 +42043,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "fmodq" } },
                         .{ .type = .f128, .kind = .{ .reg = .rdx } },
                         .{ .type = .f128, .kind = .mem },
@@ -40761,7 +42086,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
             },
-            .ptr_add => |air_tag| if (use_old) try cg.airPtrArithmetic(inst, air_tag) else {
+            .ptr_add => |air_tag| {
                 const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                 const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data;
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
@@ -40817,7 +42142,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .patterns = &.{
                         .{ .src = .{ .to_gpr, .to_gpr, .none } },
                     },
-                    .dst_temps = .{ .{ .ref = .src1 }, .unused },
+                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } }, .unused },
                     .each = .{ .once = &.{
                         .{ ._, ._, .lea, .dst0p, .leasi(.src1, .@"4", .src1), ._, ._ },
                         .{ ._, ._, .lea, .dst0p, .leai(.src0, .dst0), ._, ._ },
@@ -40838,7 +42163,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .patterns = &.{
                         .{ .src = .{ .to_gpr, .to_gpr, .none } },
                     },
-                    .dst_temps = .{ .{ .ref = .src1 }, .unused },
+                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } }, .unused },
                     .each = .{ .once = &.{
                         .{ ._, ._, .lea, .dst0p, .leasi(.src1, .@"8", .src1), ._, ._ },
                         .{ ._, ._, .lea, .dst0p, .leai(.src0, .dst0), ._, ._ },
@@ -40875,7 +42200,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 } else res[0] = ops[0];
                 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
             },
-            .ptr_sub => |air_tag| if (use_old) try cg.airPtrArithmetic(inst, air_tag) else {
+            .ptr_sub => |air_tag| {
                 const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                 const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data;
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
@@ -41004,7 +42329,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 } else res[0] = ops[0];
                 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
             },
-            .max => |air_tag| if (use_old) try cg.airBinOp(inst, air_tag) else {
+            .max => |air_tag| {
                 const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                 var res: [1]Temp = undefined;
@@ -43810,7 +45135,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -43950,8 +45279,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmaxh" } },
                         .unused,
                         .unused,
@@ -43986,8 +45315,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmaxh" } },
                         .unused,
                         .unused,
@@ -44023,8 +45352,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmaxh" } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
                         .unused,
@@ -44063,8 +45392,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
                         .{ .type = .f32, .kind = .mem },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmaxh" } },
                         .unused,
                         .unused,
@@ -44476,7 +45805,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -44733,8 +46066,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "fmax" } },
                         .unused,
                         .unused,
@@ -45020,7 +46353,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -45054,8 +46391,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } },
                         .unused,
                         .unused,
@@ -45089,8 +46426,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } },
                         .unused,
                         .unused,
@@ -45124,8 +46461,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } },
                         .unused,
                         .unused,
@@ -45157,7 +46494,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
             },
-            .min => |air_tag| if (use_old) try cg.airBinOp(inst, air_tag) else {
+            .min => |air_tag| {
                 const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                 var res: [1]Temp = undefined;
@@ -47969,7 +49306,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -48109,8 +49450,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fminh" } },
                         .unused,
                         .unused,
@@ -48145,8 +49486,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fminh" } },
                         .unused,
                         .unused,
@@ -48182,8 +49523,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fminh" } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
                         .unused,
@@ -48222,8 +49563,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
                         .{ .type = .f32, .kind = .mem },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fminh" } },
                         .unused,
                         .unused,
@@ -48635,7 +49976,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -48892,8 +50237,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "fmin" } },
                         .unused,
                         .unused,
@@ -49167,7 +50512,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .any,
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .none,
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -49201,8 +50550,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "fminq" } },
                         .unused,
                         .unused,
@@ -49236,8 +50585,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "fminq" } },
                         .unused,
                         .unused,
@@ -49271,8 +50620,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "fminq" } },
                         .unused,
                         .unused,
@@ -49304,10 +50653,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
             },
-            .add_with_overflow => |air_tag| if (use_old) try cg.airAddSubWithOverflow(inst) else fallback: {
+            .add_with_overflow => |air_tag| {
                 const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                 const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data;
-                if (cg.typeOf(bin_op.lhs).isVector(zcu)) break :fallback try cg.airAddSubWithOverflow(inst);
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                 var res: [2]Temp = undefined;
                 cg.select(&res, &.{ ty_pl.ty.toType(), .u1 }, &ops, comptime &.{ .{
@@ -50155,10 +51503,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 try res[0].withOverflow(&res[1], cg);
                 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
             },
-            .sub_with_overflow => |air_tag| if (use_old) try cg.airAddSubWithOverflow(inst) else fallback: {
+            .sub_with_overflow => |air_tag| {
                 const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                 const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data;
-                if (cg.typeOf(bin_op.lhs).isVector(zcu)) break :fallback try cg.airAddSubWithOverflow(inst);
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                 var res: [2]Temp = undefined;
                 cg.select(&res, &.{ ty_pl.ty.toType(), .u1 }, &ops, comptime &.{ .{
@@ -51061,10 +52408,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 try res[0].withOverflow(&res[1], cg);
                 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
             },
-            .mul_with_overflow => |air_tag| if (use_old) try cg.airMulWithOverflow(inst) else fallback: {
+            .mul_with_overflow => |air_tag| {
                 const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                 const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data;
-                if (cg.typeOf(bin_op.lhs).isVector(zcu)) break :fallback try cg.airMulWithOverflow(inst);
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                 var res: [2]Temp = undefined;
                 cg.select(&res, &.{ ty_pl.ty.toType(), .u1 }, &ops, comptime &.{ .{
@@ -54659,10 +56005,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 try res[0].withOverflow(&res[1], cg);
                 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
             },
-            .shl_with_overflow => |air_tag| if (use_old) try cg.airShlWithOverflow(inst) else fallback: {
+            .shl_with_overflow => |air_tag| {
                 const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                 const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data;
-                if (cg.typeOf(bin_op.lhs).isVector(zcu)) break :fallback try cg.airShlWithOverflow(inst);
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                 var res: [2]Temp = undefined;
                 cg.select(&res, &.{ ty_pl.ty.toType(), .u1 }, &ops, comptime &.{ .{
@@ -55515,7 +56860,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                         .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
@@ -55579,7 +56924,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                         .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
@@ -55643,7 +56988,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                         .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
@@ -55707,7 +57052,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                         .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
@@ -55771,7 +57116,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
@@ -55827,7 +57172,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
@@ -55883,7 +57228,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
@@ -55939,7 +57284,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
@@ -55995,7 +57340,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                         .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
@@ -56059,7 +57404,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                         .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
@@ -56123,7 +57468,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                         .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
@@ -56187,7 +57532,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                         .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
@@ -56251,7 +57596,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ },
@@ -56308,7 +57653,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ },
@@ -56365,7 +57710,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ },
@@ -56422,7 +57767,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ },
@@ -56479,7 +57824,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                         .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
@@ -56549,7 +57894,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                         .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
@@ -56619,7 +57964,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                         .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
@@ -56689,7 +58034,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                         .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
@@ -56759,7 +58104,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ },
@@ -56821,7 +58166,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ },
@@ -56883,7 +58228,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ },
@@ -56945,7 +58290,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ },
@@ -57007,7 +58352,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ },
@@ -57069,7 +58414,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ },
@@ -57131,7 +58476,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ },
@@ -57193,7 +58538,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ },
@@ -57255,7 +58600,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                         .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
@@ -57325,7 +58670,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                         .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
@@ -57395,7 +58740,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                         .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
@@ -57465,7 +58810,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                         .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
@@ -57535,7 +58880,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
@@ -57596,7 +58941,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
@@ -57657,7 +59002,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
@@ -57718,7 +59063,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
@@ -57779,7 +59124,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
@@ -57840,7 +59185,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
@@ -57901,7 +59246,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
@@ -57962,7 +59307,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
@@ -58005,7 +59350,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 try res[0].withOverflow(&res[1], cg);
                 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
             },
-            .alloc => if (use_old) try cg.airAlloc(inst) else {
+            .alloc => {
                 const ty = air_datas[@intFromEnum(inst)].ty;
                 const slot = try cg.tempInit(ty, .{ .lea_frame = .{
                     .index = try cg.allocMemPtr(inst),
@@ -58013,7 +59358,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 try slot.finish(inst, &.{}, &.{}, cg);
             },
             .inferred_alloc, .inferred_alloc_comptime => unreachable,
-            .ret_ptr => if (use_old) try cg.airRetPtr(inst) else {
+            .ret_ptr => {
                 const ty = air_datas[@intFromEnum(inst)].ty;
                 var slot = switch (cg.ret_mcv.long) {
                     else => unreachable,
@@ -58029,7 +59374,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 try slot.finish(inst, &.{}, &.{}, cg);
             },
             .assembly => try cg.airAsm(inst),
-            .bit_and, .bit_or, .xor, .bool_and, .bool_or => |air_tag| if (use_old) try cg.airBinOp(inst, air_tag) else {
+            .bit_and, .bit_or, .xor, .bool_and, .bool_or => |air_tag| {
                 const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                 var res: [1]Temp = undefined;
@@ -58399,9 +59744,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
             },
-            .shr, .shr_exact => |air_tag| if (use_old) try cg.airShlShrBinOp(inst) else fallback: {
+            .shr, .shr_exact => |air_tag| {
                 const bin_op = air_datas[@intFromEnum(inst)].bin_op;
-                if (cg.typeOf(bin_op.lhs).isVector(zcu)) break :fallback try cg.airShlShrBinOp(inst);
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                 var res: [1]Temp = undefined;
                 cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{
@@ -58964,9 +60308,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
             },
-            .shl, .shl_exact => |air_tag| if (use_old) try cg.airShlShrBinOp(inst) else fallback: {
+            .shl, .shl_exact => |air_tag| {
                 const bin_op = air_datas[@intFromEnum(inst)].bin_op;
-                if (cg.typeOf(bin_op.lhs).isVector(zcu)) break :fallback try cg.airShlShrBinOp(inst);
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                 var res: [1]Temp = undefined;
                 cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{
@@ -59339,10 +60682,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 }
                 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
             },
-            .shl_sat => |air_tag| if (use_old) try cg.airShlSat(inst) else fallback: {
+            .shl_sat => |air_tag| {
                 const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                 const lhs_ty = cg.typeOf(bin_op.lhs);
-                if (lhs_ty.isVector(zcu)) break :fallback try cg.airShlSat(inst);
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                 var res: [1]Temp = undefined;
                 switch (ops[1].tracking(cg).short) {
@@ -61190,7 +62532,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                         .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
@@ -61274,7 +62616,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                         .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
@@ -61357,7 +62699,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
@@ -61427,7 +62769,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
@@ -61498,7 +62840,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                         .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
@@ -61583,7 +62925,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                         .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
@@ -61667,7 +63009,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
@@ -61738,7 +63080,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
@@ -61810,7 +63152,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                         .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
@@ -61901,7 +63243,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                         .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
@@ -61992,7 +63334,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
@@ -62070,7 +63412,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
@@ -62148,7 +63490,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
@@ -62226,7 +63568,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
@@ -62304,7 +63646,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                         .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
@@ -62394,7 +63736,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                         .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
@@ -62484,7 +63826,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
@@ -62561,7 +63903,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
@@ -62638,7 +63980,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
@@ -62715,7 +64057,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                         .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                         .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                         .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                         .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                         .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
@@ -62763,7 +64105,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
             },
-            .not => |air_tag| if (use_old) try cg.airUnOp(inst, air_tag) else {
+            .not => |air_tag| {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                 var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                 var res: [1]Temp = undefined;
@@ -64003,7 +65345,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 try cg.lowerBlock(inst, @ptrCast(cg.air.extra.items[block.end..][0..block.data.body_len]));
                 if (!cg.mod.strip) try cg.asmPseudo(.pseudo_dbg_leave_block_none);
             },
-            .loop => if (use_old) try cg.airLoop(inst) else {
+            .loop => {
                 const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                 const block = cg.air.extraData(Air.Block, ty_pl.payload);
                 try cg.loops.putNoClobber(cg.gpa, inst, .{
@@ -64027,14 +65369,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
             .br => try cg.airBr(inst),
             .trap => try cg.asmOpOnly(.{ ._2, .ud }),
             .breakpoint => try cg.asmOpOnly(.{ ._3, .int }),
-            .ret_addr => if (use_old) try cg.airRetAddr(inst) else {
+            .ret_addr => {
                 var slot = try cg.tempInit(.usize, .{ .load_frame = .{
                     .index = .ret_addr,
                 } });
                 while (try slot.toRegClass(true, .general_purpose, cg)) {}
                 try slot.finish(inst, &.{}, &.{}, cg);
             },
-            .frame_addr => if (use_old) try cg.airFrameAddress(inst) else {
+            .frame_addr => {
                 const slot = try cg.tempInit(.usize, .{ .lea_frame = .{
                     .index = .base_ptr,
                 } });
@@ -64044,7 +65386,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
             .call_always_tail => try cg.airCall(inst, .always_tail, .{ .safety = true }),
             .call_never_tail => try cg.airCall(inst, .never_tail, .{ .safety = true }),
             .call_never_inline => try cg.airCall(inst, .never_inline, .{ .safety = true }),
-            .clz => |air_tag| if (use_old) try cg.airClz(inst) else {
+            .clz => |air_tag| {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                 var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                 var res: [1]Temp = undefined;
@@ -67149,9 +68491,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{ty_op.operand}, &ops, cg);
             },
-            .ctz => |air_tag| if (use_old) try cg.airCtz(inst) else fallback: {
+            .ctz => |air_tag| {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
-                if (ty_op.ty.toType().isVector(zcu)) break :fallback try cg.airCtz(inst);
                 var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                 var res: [1]Temp = undefined;
                 cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{
@@ -67547,9 +68888,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{ty_op.operand}, &ops, cg);
             },
-            .popcount => |air_tag| if (use_old) try cg.airPopCount(inst) else fallback: {
+            .popcount => |air_tag| {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
-                if (ty_op.ty.toType().isVector(zcu)) break :fallback try cg.airPopCount(inst);
                 var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                 var res: [1]Temp = undefined;
                 cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{
@@ -68436,9 +69776,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{ty_op.operand}, &ops, cg);
             },
-            .byte_swap => |air_tag| if (use_old) try cg.airByteSwap(inst) else fallback: {
+            .byte_swap => |air_tag| {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
-                if (ty_op.ty.toType().isVector(zcu)) break :fallback try cg.airByteSwap(inst);
                 var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                 var res: [1]Temp = undefined;
                 cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{
@@ -69086,9 +70425,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{ty_op.operand}, &ops, cg);
             },
-            .bit_reverse => |air_tag| if (use_old) try cg.airBitReverse(inst) else fallback: {
+            .bit_reverse => |air_tag| {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
-                if (ty_op.ty.toType().isVector(zcu)) break :fallback try cg.airByteSwap(inst);
                 var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                 var res: [1]Temp = undefined;
                 cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{
@@ -72189,7 +73527,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{ty_op.operand}, &ops, cg);
             },
-            .sqrt => |air_tag| if (use_old) try cg.airSqrt(inst) else {
+            .sqrt => |air_tag| {
                 const un_op = air_datas[@intFromEnum(inst)].un_op;
                 var ops = try cg.tempsFromOperands(inst, .{un_op});
                 var res: [1]Temp = undefined;
@@ -72209,7 +73547,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -72294,7 +73632,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__sqrth" } },
                         .unused,
                         .unused,
@@ -72325,7 +73663,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__sqrth" } },
                         .unused,
                         .unused,
@@ -72356,7 +73694,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__sqrth" } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
                         .unused,
@@ -72390,7 +73728,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
                         .{ .type = .f32, .kind = .mem },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__sqrth" } },
                         .unused,
                         .unused,
@@ -72459,7 +73797,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -72578,7 +73916,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "sqrtf" } },
                         .unused,
                         .unused,
@@ -72608,7 +73946,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "sqrtf" } },
                         .unused,
                         .unused,
@@ -72675,7 +74013,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -72794,7 +74132,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "sqrt" } },
                         .unused,
                         .unused,
@@ -72824,7 +74162,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "sqrt" } },
                         .unused,
                         .unused,
@@ -72854,7 +74192,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "sqrt" } },
                         .unused,
                         .unused,
@@ -72877,6 +74215,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .gnu,
                     .required_features = .{ .x87, null, null, null },
                     .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                     .patterns = &.{
@@ -72903,6 +74242,40 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .msvc,
+                    .required_features = .{ .x87, null, null, null },
+                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .mem, .none, .none } },
+                        .{ .src = .{ .to_x87, .none, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                        .{ .type = .u16, .kind = .mem },
+                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .x87 } }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
+                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
+                        .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
+                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_00_11), ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
+                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
+                        .{ ._, .f_, .sqrt, ._, ._, ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
+                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_abi = .gnu,
                     .required_features = .{ .x87, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                     .patterns = &.{
@@ -72932,10 +74305,46 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .msvc,
+                    .required_features = .{ .x87, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .u16, .kind = .mem },
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, .fn_cw, .st, .tmp0w, ._, ._, ._ },
+                        .{ ._, ._, .movzx, .tmp1d, .memd(.tmp0b, 1), ._, ._ },
+                        .{ ._, ._, .@"or", .memd(.tmp0b, 1), .ui(0b000_0_00_11), ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ },
+                        .{ ._, ._, .mov, .memd(.tmp0b, 1), .tmp1b, ._, ._ },
+                        .{ ._, ._, .mov, .tmp1p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp1, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, .f_, .sqrt, ._, ._, ._, ._ },
+                        .{ ._, .f_p, .st, .memia(.dst0t, .tmp1, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ },
+                    } },
+                }, .{
                     .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -72965,7 +74374,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "sqrtq" } },
                         .unused,
                         .unused,
@@ -72995,7 +74404,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "sqrtq" } },
                         .unused,
                         .unused,
@@ -73025,7 +74434,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "sqrtq" } },
                         .unused,
                         .unused,
@@ -73056,7 +74465,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{un_op}, &ops, cg);
             },
-            .sin, .cos, .tan, .exp, .exp2, .log, .log2, .log10, .round => |air_tag| if (use_old) try cg.airUnaryMath(inst, air_tag) else {
+            .sin, .cos, .tan, .exp, .exp2, .log, .log2, .log10, .round => |air_tag| {
                 const un_op = air_datas[@intFromEnum(inst)].un_op;
                 var ops = try cg.tempsFromOperands(inst, .{un_op});
                 var res: [1]Temp = undefined;
@@ -73066,7 +74475,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .required_features = .{ .sse, null, null, null },
                         .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                         .patterns = &.{
-                            .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                            .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                         },
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
@@ -73095,8 +74504,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         },
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
-                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "h" } },
                             .unused,
                             .unused,
@@ -73110,13 +74519,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .dst_temps = .{ .mem, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
-                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                            .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                             .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
-                            .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
+                            .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                             .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                            .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
-                            .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                            .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ },
+                            .{ ._, ._, .sub, .tmp0p, .si(2), ._, ._ },
+                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                         } },
                     }, .{
                         .required_features = .{ .sse4_1, null, null, null },
@@ -73126,8 +74535,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         },
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
-                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "h" } },
                             .unused,
                             .unused,
@@ -73141,13 +74550,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .dst_temps = .{ .mem, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
-                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                            .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                             .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
-                            .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+                            .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                             .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                            .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
-                            .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                            .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ },
+                            .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                         } },
                     }, .{
                         .required_features = .{ .sse2, null, null, null },
@@ -73157,8 +74566,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         },
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
-                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "h" } },
                             .{ .type = .f16, .kind = .{ .reg = .ax } },
                             .unused,
@@ -73172,14 +74581,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .dst_temps = .{ .mem, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
-                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                            .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                             .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
-                            .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+                            .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                             .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                             .{ ._, .p_w, .extr, .tmp3d, .tmp1x, .ui(0), ._ },
-                            .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ },
-                            .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                            .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ },
+                            .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                         } },
                     }, .{
                         .required_features = .{ .sse, null, null, null },
@@ -73189,10 +74598,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         },
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
-                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                             .{ .type = .f16, .kind = .{ .reg = .ax } },
                             .{ .type = .f32, .kind = .mem },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "h" } },
                             .unused,
                             .unused,
@@ -73204,22 +74613,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .dst_temps = .{ .mem, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
-                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                            .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                            .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                            .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                             .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                             .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
                             .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                             .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ },
                             .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ },
-                            .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
-                            .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                            .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
+                            .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                         } },
                     }, .{
                         .required_features = .{ .sse, null, null, null },
                         .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                         .patterns = &.{
-                            .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                            .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                         },
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
@@ -73248,8 +74657,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         },
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
-                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                            .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = @tagName(name) ++ "f" } },
                             .unused,
                             .unused,
@@ -73263,12 +74672,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .dst_temps = .{ .mem, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
-                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                            .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                            .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                            .{ .@"0:", .v_ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                             .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                            .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                            .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                            .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ },
+                            .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                         } },
                     }, .{
                         .required_features = .{ .sse, null, null, null },
@@ -73278,8 +74687,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         },
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
-                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                            .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = @tagName(name) ++ "f" } },
                             .unused,
                             .unused,
@@ -73293,18 +74702,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .dst_temps = .{ .mem, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
-                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                            .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                            .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                            .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                             .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                            .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                            .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                            .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ },
+                            .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                         } },
                     }, .{
                         .required_features = .{ .sse, null, null, null },
                         .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                         .patterns = &.{
-                            .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                            .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                         },
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
@@ -73333,8 +74742,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         },
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
-                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                            .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = @tagName(name) } },
                             .unused,
                             .unused,
@@ -73348,12 +74757,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .dst_temps = .{ .mem, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
-                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                            .{ .@"0:", .v_sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                            .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                            .{ .@"0:", .v_sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                             .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                            .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                            .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                            .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
+                            .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                         } },
                     }, .{
                         .required_features = .{ .sse2, null, null, null },
@@ -73363,8 +74772,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         },
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
-                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                            .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = @tagName(name) } },
                             .unused,
                             .unused,
@@ -73378,12 +74787,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .dst_temps = .{ .mem, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
-                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                            .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                            .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                            .{ .@"0:", ._sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                             .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                            .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                            .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                            .{ ._, ._sd, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
+                            .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                         } },
                     }, .{
                         .required_features = .{ .sse, null, null, null },
@@ -73393,8 +74802,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         },
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
-                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                            .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = @tagName(name) } },
                             .unused,
                             .unused,
@@ -73408,15 +74817,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .dst_temps = .{ .mem, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
-                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                            .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                             .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
-                            .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                            .{ ._, ._ps, .movl, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                             .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                            .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                            .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                            .{ ._, ._ps, .movl, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
+                            .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                         } },
                     }, .{
+                        .required_cc_abi = .sysv64,
                         .required_features = .{ .avx, .x87, null, null },
                         .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                         .patterns = &.{
@@ -73424,7 +74834,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         },
                         .call_frame = .{ .size = 16, .alignment = .@"16" },
                         .extra_temps = .{
-                            .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "x" } },
                             .unused,
@@ -73444,6 +74854,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         } },
                     }, .{
+                        .required_cc_abi = .sysv64,
                         .required_features = .{ .sse2, .x87, null, null },
                         .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                         .patterns = &.{
@@ -73451,7 +74862,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         },
                         .call_frame = .{ .size = 16, .alignment = .@"16" },
                         .extra_temps = .{
-                            .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "x" } },
                             .unused,
@@ -73471,6 +74882,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         } },
                     }, .{
+                        .required_cc_abi = .sysv64,
                         .required_features = .{ .sse, .x87, null, null },
                         .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                         .patterns = &.{
@@ -73478,7 +74890,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         },
                         .call_frame = .{ .size = 16, .alignment = .@"16" },
                         .extra_temps = .{
-                            .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "x" } },
                             .unused,
@@ -73498,6 +74910,34 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         } },
                     }, .{
+                        .required_cc_abi = .win64,
+                        .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
+                        .patterns = &.{
+                            .{ .src = .{ .to_mem, .none, .none } },
+                        },
+                        .call_frame = .{ .alignment = .@"16" },
+                        .extra_temps = .{
+                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                            .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "x" } },
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                        },
+                        .dst_temps = .{ .mem, .unused },
+                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                        .each = .{ .once = &.{
+                            .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
+                            .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
+                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        } },
+                    }, .{
+                        .required_cc_abi = .sysv64,
                         .required_features = .{ .avx, .x87, null, null },
                         .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                         .patterns = &.{
@@ -73505,8 +74945,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         },
                         .call_frame = .{ .size = 16, .alignment = .@"16" },
                         .extra_temps = .{
-                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                            .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "x" } },
                             .unused,
@@ -73520,16 +74960,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .dst_temps = .{ .mem, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
-                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                            .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                            .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                             .{ ._, .v_dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ },
                             .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                             .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
-                            .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
-                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                            .{ ._, .f_p, .st, .memi(.dst0t, .tmp0), ._, ._, ._ },
+                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                         } },
                     }, .{
+                        .required_cc_abi = .sysv64,
                         .required_features = .{ .sse2, .x87, null, null },
                         .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                         .patterns = &.{
@@ -73537,8 +74978,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         },
                         .call_frame = .{ .size = 16, .alignment = .@"16" },
                         .extra_temps = .{
-                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                            .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "x" } },
                             .unused,
@@ -73552,16 +74993,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .dst_temps = .{ .mem, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
-                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                            .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                            .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                             .{ ._, ._dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ },
                             .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                             .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
-                            .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
-                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                            .{ ._, .f_p, .st, .memi(.dst0t, .tmp0), ._, ._, ._ },
+                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                         } },
                     }, .{
+                        .required_cc_abi = .sysv64,
                         .required_features = .{ .sse, .x87, null, null },
                         .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                         .patterns = &.{
@@ -73569,8 +75011,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         },
                         .call_frame = .{ .size = 16, .alignment = .@"16" },
                         .extra_temps = .{
-                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                            .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "x" } },
                             .unused,
@@ -73584,20 +75026,50 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .dst_temps = .{ .mem, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
-                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                            .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                            .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                             .{ ._, ._ps, .mova, .mem(.tmp2x), .tmp1x, ._, ._ },
                             .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                             .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
-                            .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
-                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                            .{ ._, .f_p, .st, .memi(.dst0t, .tmp0), ._, ._, ._ },
+                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                        } },
+                    }, .{
+                        .required_cc_abi = .win64,
+                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
+                        .patterns = &.{
+                            .{ .src = .{ .to_mem, .none, .none } },
+                        },
+                        .call_frame = .{ .alignment = .@"16" },
+                        .extra_temps = .{
+                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                            .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "x" } },
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                        },
+                        .dst_temps = .{ .mem, .unused },
+                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                        .each = .{ .once = &.{
+                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                            .{ .@"0:", ._, .lea, .tmp1p, .memi(.dst0, .tmp0), ._, ._ },
+                            .{ ._, ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ },
+                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                         } },
                     }, .{
                         .required_features = .{ .sse, null, null, null },
                         .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                         .patterns = &.{
-                            .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                            .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                         },
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
@@ -73626,8 +75098,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         },
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
-                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = @tagName(name) ++ "q" } },
                             .unused,
                             .unused,
@@ -73641,12 +75113,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .dst_temps = .{ .mem, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
-                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                            .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                            .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                             .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                            .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                            .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
+                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                         } },
                     }, .{
                         .required_features = .{ .sse2, null, null, null },
@@ -73656,8 +75128,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         },
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
-                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = @tagName(name) ++ "q" } },
                             .unused,
                             .unused,
@@ -73671,12 +75143,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .dst_temps = .{ .mem, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
-                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                            .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                            .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                             .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                            .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                            .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
+                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                         } },
                     }, .{
                         .required_features = .{ .sse, null, null, null },
@@ -73686,8 +75158,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         },
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
-                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = @tagName(name) ++ "q" } },
                             .unused,
                             .unused,
@@ -73701,12 +75173,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .dst_temps = .{ .mem, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
-                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                            .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                            .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                             .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                            .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                            .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
+                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                         } },
                     } },
                 }) catch |err| switch (err) {
@@ -73719,7 +75191,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{un_op}, &ops, cg);
             },
-            .abs => |air_tag| if (use_old) try cg.airAbs(inst) else {
+            .abs => |air_tag| {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                 var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                 var res: [1]Temp = undefined;
@@ -75270,12 +76742,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{ty_op.operand}, &ops, cg);
             },
-            .floor, .ceil, .trunc_float => |air_tag| if (use_old) try cg.airRound(inst, .{ .direction = switch (air_tag) {
-                else => unreachable,
-                .floor => .down,
-                .ceil => .up,
-                .trunc_float => .zero,
-            }, .precision = .inexact }) else {
+            .floor, .ceil, .trunc_float => |air_tag| {
                 const un_op = air_datas[@intFromEnum(inst)].un_op;
                 var ops = try cg.tempsFromOperands(inst, .{un_op});
                 var res: [1]Temp = undefined;
@@ -75302,7 +76769,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .required_features = .{ .sse, null, null, null },
                         .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                         .patterns = &.{
-                            .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                            .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                         },
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
@@ -75392,7 +76859,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                 else => unreachable,
                                 .down => "__floorh",
@@ -75428,7 +76895,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                 else => unreachable,
                                 .down => "__floorh",
@@ -75464,7 +76931,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                 else => unreachable,
                                 .down => "__floorh",
@@ -75503,7 +76970,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                             .{ .type = .f16, .kind = .{ .reg = .ax } },
                             .{ .type = .f32, .kind = .mem },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                 else => unreachable,
                                 .down => "__floorh",
@@ -75577,7 +77044,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .required_features = .{ .sse, null, null, null },
                         .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                         .patterns = &.{
-                            .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                            .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                         },
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
@@ -75707,7 +77174,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                 else => unreachable,
                                 .down => "floorf",
@@ -75742,7 +77209,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                 else => unreachable,
                                 .down => "floorf",
@@ -75814,7 +77281,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .required_features = .{ .sse, null, null, null },
                         .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                         .patterns = &.{
-                            .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                            .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                         },
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
@@ -75944,7 +77411,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                 else => unreachable,
                                 .down => "floor",
@@ -75979,7 +77446,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                 else => unreachable,
                                 .down => "floor",
@@ -76014,7 +77481,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                 else => unreachable,
                                 .down => "floor",
@@ -76042,6 +77509,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                         } },
                     }, .{
+                        .required_cc_abi = .sysv64,
                         .required_features = .{ .avx, .x87, null, null },
                         .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                         .patterns = &.{
@@ -76049,7 +77517,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         },
                         .call_frame = .{ .size = 16, .alignment = .@"16" },
                         .extra_temps = .{
-                            .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                             .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                 else => unreachable,
@@ -76074,6 +77542,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         } },
                     }, .{
+                        .required_cc_abi = .sysv64,
                         .required_features = .{ .sse2, .x87, null, null },
                         .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                         .patterns = &.{
@@ -76081,7 +77550,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         },
                         .call_frame = .{ .size = 16, .alignment = .@"16" },
                         .extra_temps = .{
-                            .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                             .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                 else => unreachable,
@@ -76106,6 +77575,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         } },
                     }, .{
+                        .required_cc_abi = .sysv64,
                         .required_features = .{ .sse, .x87, null, null },
                         .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                         .patterns = &.{
@@ -76113,7 +77583,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         },
                         .call_frame = .{ .size = 16, .alignment = .@"16" },
                         .extra_temps = .{
-                            .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                             .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                 else => unreachable,
@@ -76138,6 +77608,39 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         } },
                     }, .{
+                        .required_cc_abi = .win64,
+                        .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
+                        .patterns = &.{
+                            .{ .src = .{ .to_mem, .none, .none } },
+                        },
+                        .call_frame = .{ .alignment = .@"16" },
+                        .extra_temps = .{
+                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
+                                else => unreachable,
+                                .down => "__floorx",
+                                .up => "__ceilx",
+                                .zero => "__truncx",
+                            } } },
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                        },
+                        .dst_temps = .{ .mem, .unused },
+                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                        .each = .{ .once = &.{
+                            .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
+                            .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
+                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        } },
+                    }, .{
+                        .required_cc_abi = .sysv64,
                         .required_features = .{ .avx, .x87, null, null },
                         .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                         .patterns = &.{
@@ -76146,7 +77649,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .size = 16, .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                             .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                 else => unreachable,
@@ -76175,6 +77678,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                         } },
                     }, .{
+                        .required_cc_abi = .sysv64,
                         .required_features = .{ .sse2, .x87, null, null },
                         .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                         .patterns = &.{
@@ -76183,7 +77687,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .size = 16, .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                             .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                 else => unreachable,
@@ -76212,6 +77716,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                         } },
                     }, .{
+                        .required_cc_abi = .sysv64,
                         .required_features = .{ .sse, .x87, null, null },
                         .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                         .patterns = &.{
@@ -76220,7 +77725,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .size = 16, .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                             .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                 else => unreachable,
@@ -76249,10 +77754,45 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                         } },
                     }, .{
+                        .required_cc_abi = .win64,
+                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
+                        .patterns = &.{
+                            .{ .src = .{ .to_mem, .none, .none } },
+                        },
+                        .call_frame = .{ .alignment = .@"16" },
+                        .extra_temps = .{
+                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
+                                else => unreachable,
+                                .down => "__floorx",
+                                .up => "__ceilx",
+                                .zero => "__truncx",
+                            } } },
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                        },
+                        .dst_temps = .{ .mem, .unused },
+                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                        .each = .{ .once = &.{
+                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                            .{ .@"0:", ._, .lea, .tmp1p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ },
+                            .{ ._, ._, .lea, .tmp2p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
+                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        } },
+                    }, .{
                         .required_features = .{ .sse, null, null, null },
                         .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                         .patterns = &.{
-                            .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                            .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                         },
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
@@ -76287,7 +77827,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                 else => unreachable,
                                 .down => "floorq",
@@ -76322,7 +77862,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                 else => unreachable,
                                 .down => "floorq",
@@ -76357,7 +77897,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                 else => unreachable,
                                 .down => "floorq",
@@ -76394,7 +77934,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{un_op}, &ops, cg);
             },
-            .neg, .neg_optimized => |air_tag| if (use_old) try cg.airFloatSign(inst, .neg) else {
+            .neg, .neg_optimized => |air_tag| {
                 const un_op = air_datas[@intFromEnum(inst)].un_op;
                 var ops = try cg.tempsFromOperands(inst, .{un_op});
                 var res: [1]Temp = undefined;
@@ -76942,7 +78482,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
             .cmp_gte_optimized,
             .cmp_gt,
             .cmp_gt_optimized,
-            => |air_tag| if (use_old) try cg.airCmp(inst, air_tag.toCmpOp().?) else {
+            => |air_tag| {
                 const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                 const cmp_op = air_tag.toCmpOp().?;
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
@@ -76991,7 +78531,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .required_features = .{ .sse, null, null, null },
                             .src_constraints = .{ .{ .float = .word }, .{ .float = .word }, .any },
                             .patterns = &.{
-                                .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                                .{ .src = .{
+                                    .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                                    .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                                    .none,
+                                } },
                             },
                             .call_frame = .{ .alignment = .@"16" },
                             .extra_temps = .{
@@ -77334,7 +78878,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .required_features = .{ .sse, null, null, null },
                             .src_constraints = .{ .{ .float = .xword }, .{ .float = .xword }, .any },
                             .patterns = &.{
-                                .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                                .{ .src = .{
+                                    .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                                    .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                                    .none,
+                                } },
                             },
                             .call_frame = .{ .alignment = .@"16" },
                             .extra_temps = .{
@@ -77378,7 +78926,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
             .cmp_eq_optimized,
             .cmp_neq,
             .cmp_neq_optimized,
-            => |air_tag| if (use_old) try cg.airCmp(inst, air_tag.toCmpOp().?) else {
+            => |air_tag| {
                 const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                 const cmp_op = air_tag.toCmpOp().?;
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
@@ -77495,7 +79043,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                                 .required_features = .{ .sse, null, null, null },
                                 .src_constraints = .{ .{ .float = .word }, .{ .float = .word }, .any },
                                 .patterns = &.{
-                                    .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                                    .{ .src = .{
+                                        .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                                        .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                                        .none,
+                                    } },
                                 },
                                 .call_frame = .{ .alignment = .@"16" },
                                 .extra_temps = .{
@@ -77862,7 +79414,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                                 .required_features = .{ .sse, null, null, null },
                                 .src_constraints = .{ .{ .float = .xword }, .{ .float = .xword }, .any },
                                 .patterns = &.{
-                                    .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                                    .{ .src = .{
+                                        .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                                        .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                                        .none,
+                                    } },
                                 },
                                 .call_frame = .{ .alignment = .@"16" },
                                 .extra_temps = .{
@@ -77939,7 +79495,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 }
                 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
             },
-            .cmp_vector, .cmp_vector_optimized => |air_tag| if (use_old) try cg.airCmpVector(inst) else fallback: {
+            .cmp_vector, .cmp_vector_optimized => |air_tag| fallback: {
                 const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                 const vector_cmp = cg.air.extraData(Air.VectorCmp, ty_pl.payload).data;
                 switch (vector_cmp.compareOperator()) {
@@ -78533,8 +80089,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                                 .call_frame = .{ .alignment = .@"16" },
                                 .extra_temps = .{
                                     .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                                    .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                                    .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                     .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                     .{ .type = .i32, .kind = .{ .reg = .eax } },
                                     .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -78577,8 +80133,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                                 .call_frame = .{ .alignment = .@"16" },
                                 .extra_temps = .{
                                     .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                                    .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                                    .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                     .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                     .{ .type = .i32, .kind = .{ .reg = .eax } },
                                     .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -78621,8 +80177,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                                 .call_frame = .{ .alignment = .@"16" },
                                 .extra_temps = .{
                                     .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                                    .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                                    .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                     .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                     .{ .type = .i32, .kind = .{ .reg = .eax } },
                                     .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -78666,8 +80222,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                                 .call_frame = .{ .alignment = .@"16" },
                                 .extra_temps = .{
                                     .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                                    .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                                    .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                     .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                     .{ .type = .i32, .kind = .{ .reg = .eax } },
                                     .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -78711,8 +80267,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                                 .call_frame = .{ .alignment = .@"16" },
                                 .extra_temps = .{
                                     .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                                    .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                                    .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                     .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                     .{ .type = .i32, .kind = .{ .reg = .eax } },
                                     .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -78758,8 +80314,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                                 .call_frame = .{ .alignment = .@"16" },
                                 .extra_temps = .{
                                     .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                                    .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                                    .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                     .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                     .{ .type = .i32, .kind = .{ .reg = .eax } },
                                     .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -78805,8 +80361,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                                 .extra_temps = .{
                                     .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                     .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
-                                    .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                                    .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                     .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                     .{ .type = .i32, .kind = .{ .reg = .eax } },
                                     .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -78858,8 +80414,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                                 .extra_temps = .{
                                     .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                     .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
-                                    .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                                    .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                     .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                     .{ .type = .i32, .kind = .{ .reg = .eax } },
                                     .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -78911,8 +80467,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                                 .extra_temps = .{
                                     .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                     .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
-                                    .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                                    .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                     .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                     .{ .type = .i32, .kind = .{ .reg = .eax } },
                                     .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -78965,8 +80521,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                                 .extra_temps = .{
                                     .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                     .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
-                                    .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                                    .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                     .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                     .{ .type = .i32, .kind = .{ .reg = .eax } },
                                     .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -79019,8 +80575,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                                 .extra_temps = .{
                                     .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                     .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
-                                    .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                                    .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                     .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                     .{ .type = .i32, .kind = .{ .reg = .eax } },
                                     .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -79075,8 +80631,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                                 .extra_temps = .{
                                     .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                     .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
-                                    .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                                    .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                     .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                     .{ .type = .i32, .kind = .{ .reg = .eax } },
                                     .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -79902,8 +81458,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                                 .extra_temps = .{
                                     .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                     .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                                    .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                                    .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                     .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                     .{ .type = .i32, .kind = .{ .reg = .eax } },
                                     .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -79946,8 +81502,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                                 .extra_temps = .{
                                     .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                     .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                                    .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                                    .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                     .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                     .{ .type = .i32, .kind = .{ .reg = .eax } },
                                     .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -79990,8 +81546,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                                 .extra_temps = .{
                                     .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                     .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                                    .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                                    .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                     .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                     .{ .type = .i32, .kind = .{ .reg = .eax } },
                                     .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -80034,8 +81590,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                                 .extra_temps = .{
                                     .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                     .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                                    .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                                    .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                     .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                     .{ .type = .i32, .kind = .{ .reg = .eax } },
                                     .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -80078,8 +81634,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                                 .extra_temps = .{
                                     .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                     .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                                    .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                                    .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                     .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                     .{ .type = .i32, .kind = .{ .reg = .eax } },
                                     .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -80122,8 +81678,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                                 .extra_temps = .{
                                     .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                     .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                                    .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                                    .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                     .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                     .{ .type = .i32, .kind = .{ .reg = .eax } },
                                     .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -80166,8 +81722,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                                     .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                     .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                     .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
-                                    .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                                    .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                     .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                     .{ .type = .i32, .kind = .{ .reg = .eax } },
                                     .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -80219,8 +81775,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                                     .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                     .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                     .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
-                                    .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                                    .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                     .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                     .{ .type = .i32, .kind = .{ .reg = .eax } },
                                     .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -80272,8 +81828,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                                     .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                     .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                     .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
-                                    .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                                    .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                     .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                     .{ .type = .i32, .kind = .{ .reg = .eax } },
                                     .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -80325,8 +81881,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                                     .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                     .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                     .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
-                                    .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                                    .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                     .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                     .{ .type = .i32, .kind = .{ .reg = .eax } },
                                     .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -80378,8 +81934,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                                     .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                     .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                     .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
-                                    .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                                    .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                     .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                     .{ .type = .i32, .kind = .{ .reg = .eax } },
                                     .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -80431,8 +81987,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                                     .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                     .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                     .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
-                                    .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                                    .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                     .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                     .{ .type = .i32, .kind = .{ .reg = .eax } },
                                     .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -83041,8 +84597,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .call_frame = .{ .alignment = .@"16" },
                             .extra_temps = .{
                                 .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                                .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                                .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                 .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                 .{ .type = .i32, .kind = .{ .reg = .eax } },
                                 .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -83085,8 +84641,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .call_frame = .{ .alignment = .@"16" },
                             .extra_temps = .{
                                 .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                                .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                                .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                 .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                 .{ .type = .i32, .kind = .{ .reg = .eax } },
                                 .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -83129,8 +84685,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .call_frame = .{ .alignment = .@"16" },
                             .extra_temps = .{
                                 .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                                .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                                .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                 .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                 .{ .type = .i32, .kind = .{ .reg = .eax } },
                                 .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -83174,8 +84730,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .call_frame = .{ .alignment = .@"16" },
                             .extra_temps = .{
                                 .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                                .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                                .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                 .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                 .{ .type = .i32, .kind = .{ .reg = .eax } },
                                 .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -83219,8 +84775,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .call_frame = .{ .alignment = .@"16" },
                             .extra_temps = .{
                                 .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                                .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                                .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                 .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                 .{ .type = .i32, .kind = .{ .reg = .eax } },
                                 .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -83266,8 +84822,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .call_frame = .{ .alignment = .@"16" },
                             .extra_temps = .{
                                 .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                                .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                                .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                 .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                 .{ .type = .i32, .kind = .{ .reg = .eax } },
                                 .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -83313,8 +84869,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .extra_temps = .{
                                 .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                 .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
-                                .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                                .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                 .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                 .{ .type = .i32, .kind = .{ .reg = .eax } },
                                 .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -83366,8 +84922,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .extra_temps = .{
                                 .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                 .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
-                                .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                                .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                 .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                 .{ .type = .i32, .kind = .{ .reg = .eax } },
                                 .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -83419,8 +84975,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .extra_temps = .{
                                 .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                 .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
-                                .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                                .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                 .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                 .{ .type = .i32, .kind = .{ .reg = .eax } },
                                 .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -83473,8 +85029,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .extra_temps = .{
                                 .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                 .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
-                                .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                                .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                 .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                 .{ .type = .i32, .kind = .{ .reg = .eax } },
                                 .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -83527,8 +85083,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .extra_temps = .{
                                 .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                 .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
-                                .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                                .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                 .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                 .{ .type = .i32, .kind = .{ .reg = .eax } },
                                 .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -83583,8 +85139,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .extra_temps = .{
                                 .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                 .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
-                                .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                                .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                 .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                 .{ .type = .i32, .kind = .{ .reg = .eax } },
                                 .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -84424,8 +85980,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .extra_temps = .{
                                 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                 .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                                .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                                .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                 .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                 .{ .type = .i32, .kind = .{ .reg = .eax } },
                                 .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -84468,8 +86024,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .extra_temps = .{
                                 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                 .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                                .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                                .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                 .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                 .{ .type = .i32, .kind = .{ .reg = .eax } },
                                 .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -84512,8 +86068,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .extra_temps = .{
                                 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                 .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                                .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                                .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                 .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                 .{ .type = .i32, .kind = .{ .reg = .eax } },
                                 .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -84556,8 +86112,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .extra_temps = .{
                                 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                 .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                                .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                                .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                 .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                 .{ .type = .i32, .kind = .{ .reg = .eax } },
                                 .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -84600,8 +86156,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .extra_temps = .{
                                 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                 .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                                .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                                .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                 .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                 .{ .type = .i32, .kind = .{ .reg = .eax } },
                                 .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -84644,8 +86200,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .extra_temps = .{
                                 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                 .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                                .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                                .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                 .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                 .{ .type = .i32, .kind = .{ .reg = .eax } },
                                 .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -84688,8 +86244,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                                 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                 .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                 .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
-                                .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                                .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                 .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                 .{ .type = .i32, .kind = .{ .reg = .eax } },
                                 .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -84741,8 +86297,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                                 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                 .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                 .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
-                                .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                                .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                 .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                 .{ .type = .i32, .kind = .{ .reg = .eax } },
                                 .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -84794,8 +86350,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                                 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                 .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                 .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
-                                .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                                .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                 .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                 .{ .type = .i32, .kind = .{ .reg = .eax } },
                                 .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -84847,8 +86403,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                                 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                 .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                 .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
-                                .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                                .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                 .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                 .{ .type = .i32, .kind = .{ .reg = .eax } },
                                 .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -84900,8 +86456,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                                 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                 .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                 .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
-                                .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                                .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                 .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                 .{ .type = .i32, .kind = .{ .reg = .eax } },
                                 .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -84953,8 +86509,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                                 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                 .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                 .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
-                                .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                                .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                 .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                 .{ .type = .i32, .kind = .{ .reg = .eax } },
                                 .{ .type = .u8, .kind = .{ .reg = .cl } },
@@ -85048,7 +86604,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .data = .{ .ip_index = old_inline_func },
                 });
             },
-            .dbg_var_ptr, .dbg_var_val, .dbg_arg_inline => |air_tag| if (use_old) try cg.airDbgVar(inst) else if (!cg.mod.strip) {
+            .dbg_var_ptr, .dbg_var_val, .dbg_arg_inline => |air_tag| if (!cg.mod.strip) {
                 const pl_op = air_datas[@intFromEnum(inst)].pl_op;
                 const air_name: Air.NullTerminatedString = @enumFromInt(pl_op.payload);
                 const op_ty = cg.typeOf(pl_op.operand);
@@ -85086,7 +86642,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 try cg.genLocalDebugInfo(air_tag, local_ty, ops[0].tracking(cg).short);
                 try ops[0].die(cg);
             },
-            .is_null => if (use_old) try cg.airIsNull(inst) else {
+            .is_null => {
                 const un_op = air_datas[@intFromEnum(inst)].un_op;
                 const opt_ty = cg.typeOf(un_op);
                 const opt_repr_is_pl = opt_ty.optionalReprIsPayload(zcu);
@@ -85111,7 +86667,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 const is_null = try cg.tempInit(.bool, .{ .eflags = .e });
                 try is_null.finish(inst, &.{un_op}, &ops, cg);
             },
-            .is_non_null => if (use_old) try cg.airIsNonNull(inst) else {
+            .is_non_null => {
                 const un_op = air_datas[@intFromEnum(inst)].un_op;
                 const opt_ty = cg.typeOf(un_op);
                 const opt_repr_is_pl = opt_ty.optionalReprIsPayload(zcu);
@@ -85136,7 +86692,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 const is_non_null = try cg.tempInit(.bool, .{ .eflags = .ne });
                 try is_non_null.finish(inst, &.{un_op}, &ops, cg);
             },
-            .is_null_ptr => if (use_old) try cg.airIsNullPtr(inst) else {
+            .is_null_ptr => {
                 const un_op = air_datas[@intFromEnum(inst)].un_op;
                 const opt_ty = cg.typeOf(un_op).childType(zcu);
                 const opt_repr_is_pl = opt_ty.optionalReprIsPayload(zcu);
@@ -85159,7 +86715,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 const is_null = try cg.tempInit(.bool, .{ .eflags = .e });
                 try is_null.finish(inst, &.{un_op}, &ops, cg);
             },
-            .is_non_null_ptr => if (use_old) try cg.airIsNonNullPtr(inst) else {
+            .is_non_null_ptr => {
                 const un_op = air_datas[@intFromEnum(inst)].un_op;
                 const opt_ty = cg.typeOf(un_op).childType(zcu);
                 const opt_repr_is_pl = opt_ty.optionalReprIsPayload(zcu);
@@ -85182,7 +86738,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 const is_non_null = try cg.tempInit(.bool, .{ .eflags = .ne });
                 try is_non_null.finish(inst, &.{un_op}, &ops, cg);
             },
-            .is_err => if (use_old) try cg.airIsErr(inst) else {
+            .is_err => {
                 const un_op = air_datas[@intFromEnum(inst)].un_op;
                 const eu_ty = cg.typeOf(un_op);
                 const eu_err_ty = eu_ty.errorUnionSet(zcu);
@@ -85198,7 +86754,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 const is_err = try cg.tempInit(.bool, .{ .eflags = .ne });
                 try is_err.finish(inst, &.{un_op}, &ops, cg);
             },
-            .is_non_err => if (use_old) try cg.airIsNonErr(inst) else {
+            .is_non_err => {
                 const un_op = air_datas[@intFromEnum(inst)].un_op;
                 const eu_ty = cg.typeOf(un_op);
                 const eu_err_ty = eu_ty.errorUnionSet(zcu);
@@ -85214,7 +86770,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 const is_non_err = try cg.tempInit(.bool, .{ .eflags = .e });
                 try is_non_err.finish(inst, &.{un_op}, &ops, cg);
             },
-            .is_err_ptr => if (use_old) try cg.airIsErrPtr(inst) else {
+            .is_err_ptr => {
                 const un_op = air_datas[@intFromEnum(inst)].un_op;
                 const eu_ty = cg.typeOf(un_op).childType(zcu);
                 const eu_err_ty = eu_ty.errorUnionSet(zcu);
@@ -85232,7 +86788,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 const is_err = try cg.tempInit(.bool, .{ .eflags = .ne });
                 try is_err.finish(inst, &.{un_op}, &ops, cg);
             },
-            .is_non_err_ptr => if (use_old) try cg.airIsNonErrPtr(inst) else {
+            .is_non_err_ptr => {
                 const un_op = air_datas[@intFromEnum(inst)].un_op;
                 const eu_ty = cg.typeOf(un_op).childType(zcu);
                 const eu_err_ty = eu_ty.errorUnionSet(zcu);
@@ -85250,7 +86806,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 const is_non_err = try cg.tempInit(.bool, .{ .eflags = .e });
                 try is_non_err.finish(inst, &.{un_op}, &ops, cg);
             },
-            .load => if (use_old) try cg.airLoad(inst) else fallback: {
+            .load => fallback: {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                 const val_ty = ty_op.ty.toType();
                 const ptr_ty = cg.typeOf(ty_op.operand);
@@ -85299,7 +86855,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 for (ops) |op| try op.die(cg);
             },
             .unreach => {},
-            .fptrunc => |air_tag| if (use_old) try cg.airFptrunc(inst) else {
+            .fptrunc => |air_tag| {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                 var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                 var res: [1]Temp = undefined;
@@ -85341,7 +86897,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                     .dst_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -85370,7 +86926,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -85385,11 +86941,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_ps, .mova, .tmp1y, .memsia(.src0y, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
+                        .{ .@"0:", .v_ps, .mova, .tmp1y, .memsi(.src0y, .@"2", .tmp0), ._, ._ },
+                        .{ ._, .v_, .cvtps2ph, .memi(.dst0x, .tmp0), .tmp1y, .rm(.{}), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -85400,8 +86956,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__truncsfhf2" } },
                         .unused,
                         .unused,
@@ -85415,12 +86971,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memsi(.src0d, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse4_1, null, null, null },
@@ -85431,8 +86987,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__truncsfhf2" } },
                         .unused,
                         .unused,
@@ -85446,12 +87002,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ss, .mov, .tmp1x, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ss, .mov, .tmp1x, .memsi(.src0d, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -85462,8 +87018,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__truncsfhf2" } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
                         .unused,
@@ -85477,13 +87033,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ss, .mov, .tmp1x, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ss, .mov, .tmp1x, .memsi(.src0d, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ ._, .p_w, .extr, .tmp3d, .tmp1x, .ui(0), ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -85494,8 +87050,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__truncsfhf2" } },
                         .{ .type = .f32, .kind = .mem },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
@@ -85509,21 +87065,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ss, .mov, .tmp1x, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ss, .mov, .tmp1x, .memsi(.src0d, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ ._, ._ss, .mov, .mem(.tmp3d), .tmp1x, ._, ._ },
                         .{ ._, ._, .mov, .tmp4d, .mem(.tmp3d), ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp4w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                     .dst_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -85553,8 +87109,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__truncdfhf2" } },
                         .unused,
                         .unused,
@@ -85568,12 +87124,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse4_1, null, null, null },
@@ -85584,8 +87140,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__truncdfhf2" } },
                         .unused,
                         .unused,
@@ -85599,12 +87155,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._sd, .mov, .tmp1x, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._sd, .mov, .tmp1x, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -85615,8 +87171,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__truncdfhf2" } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
                         .unused,
@@ -85630,13 +87186,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._sd, .mov, .tmp1x, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._sd, .mov, .tmp1x, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ ._, .p_w, .extr, .tmp3d, .tmp1x, .ui(0), ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -85647,8 +87203,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__truncdfhf2" } },
                         .{ .type = .f32, .kind = .mem },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
@@ -85662,15 +87218,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, ._ps, .movl, .tmp1x, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._ps, .movl, .tmp1x, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ ._, ._ss, .mov, .mem(.tmp3d), .tmp1x, ._, ._ },
                         .{ ._, ._, .mov, .tmp4d, .mem(.tmp3d), ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp4w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -85777,7 +87333,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -85792,11 +87348,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_ps, .cvtpd2, .tmp1x, .memsia(.src0y, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, .v_ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
+                        .{ .@"0:", .v_ps, .cvtpd2, .tmp1x, .memsi(.src0y, .@"2", .tmp0), ._, ._ },
+                        .{ ._, .v_ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -85806,7 +87362,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_2_f32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -85821,11 +87377,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ps, .cvtpd2, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ps, .cvtpd2, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
+                        .{ ._, ._ps, .movl, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .x87, null, null, null },
@@ -85835,7 +87391,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f64, .kind = .{ .reg = .st7 } },
                         .unused,
                         .unused,
@@ -85850,13 +87406,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .f_, .ld, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, .f_p, .st, .memia(.dst0d, .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .f_, .ld, .memsi(.src0q, .@"2", .tmp0), ._, ._, ._ },
+                        .{ ._, .f_p, .st, .memi(.dst0d, .tmp0), ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                     .dst_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any },
@@ -85877,7 +87434,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, .v_dqa, .mov, .dst0x, .mem(.src0x), ._, ._ },
@@ -85885,6 +87442,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .sse2, null, null, null },
                     .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                     .dst_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any },
@@ -85905,7 +87463,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._dqa, .mov, .dst0x, .mem(.src0x), ._, ._ },
@@ -85913,6 +87471,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                     .dst_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any },
@@ -85933,7 +87492,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._ps, .mova, .dst0x, .mem(.src0x), ._, ._ },
@@ -85941,6 +87500,35 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
+                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__truncxfhf2" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
+                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
@@ -85949,8 +87537,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__truncxfhf2" } },
                         .unused,
@@ -85964,15 +87552,48 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsi(.src0x, .@"8", .tmp0), ._, ._ },
                         .{ ._, .v_dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .avx, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__truncxfhf2" } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .sse4_1, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
@@ -85981,8 +87602,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__truncxfhf2" } },
                         .unused,
@@ -85996,15 +87617,48 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"8", .tmp0), ._, ._ },
                         .{ ._, ._dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse4_1, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__truncxfhf2" } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .sse2, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
@@ -86013,8 +87667,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__truncxfhf2" } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
@@ -86028,16 +87682,50 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"8", .tmp0), ._, ._ },
                         .{ ._, ._dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                         .{ ._, .p_w, .extr, .tmp4d, .tmp1x, .ui(0), ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp4w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse2, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__truncxfhf2" } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .reg = .ax } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .p_w, .extr, .tmp4d, .tmp3x, .ui(0), ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp4w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
@@ -86046,8 +87734,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__truncxfhf2" } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
@@ -86061,15 +87749,49 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ps, .mova, .tmp1x, .memsi(.src0x, .@"8", .tmp0), ._, ._ },
                         .{ ._, ._ps, .mova, .mem(.tmp2x), .tmp1x, ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                         .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp1x, ._, ._ },
                         .{ ._, ._, .mov, .tmp4d, .mem(.tmp2d), ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp4w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__truncxfhf2" } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f32, .kind = .mem },
+                        .{ .type = .f16, .kind = .{ .reg = .ax } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._ss, .mov, .mem(.tmp4d), .tmp3x, ._, ._ },
+                        .{ ._, ._, .mov, .tmp5d, .mem(.tmp4d), ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp5w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .x87, null, null, null },
@@ -86105,7 +87827,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
                         .unused,
                         .unused,
@@ -86120,11 +87842,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, .f_p, .st, .memia(.dst0d, .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"4", .tmp0), ._, ._, ._ },
+                        .{ ._, .f_p, .st, .memi(.dst0d, .tmp0), ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .x87, null, null, null },
@@ -86160,7 +87882,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
                         .unused,
                         .unused,
@@ -86175,18 +87897,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, .f_p, .st, .memia(.dst0q, .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"2", .tmp0), ._, ._, ._ },
+                        .{ ._, .f_p, .st, .memi(.dst0q, .tmp0), ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -86216,8 +87938,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__trunctfhf2" } },
                         .unused,
                         .unused,
@@ -86231,12 +87953,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsi(.src0x, .@"8", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse4_1, null, null, null },
@@ -86247,8 +87969,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__trunctfhf2" } },
                         .unused,
                         .unused,
@@ -86262,12 +87984,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"8", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -86278,8 +88000,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__trunctfhf2" } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
                         .unused,
@@ -86293,13 +88015,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"8", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ ._, .p_w, .extr, .tmp3d, .tmp1x, .ui(0), ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -86310,8 +88032,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__trunctfhf2" } },
                         .{ .type = .f32, .kind = .mem },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
@@ -86325,21 +88047,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ps, .mova, .tmp1x, .memsi(.src0x, .@"8", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ ._, ._ss, .mov, .mem(.tmp3d), .tmp1x, ._, ._ },
                         .{ ._, ._, .mov, .tmp4d, .mem(.tmp3d), ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp4w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -86369,8 +88091,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__trunctfsf2" } },
                         .unused,
                         .unused,
@@ -86384,12 +88106,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsi(.src0x, .@"4", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -86400,8 +88122,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__trunctfsf2" } },
                         .unused,
                         .unused,
@@ -86415,12 +88137,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"4", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -86431,8 +88153,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__trunctfsf2" } },
                         .unused,
                         .unused,
@@ -86446,19 +88168,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ps, .mova, .tmp1x, .memsi(.src0x, .@"4", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -86488,8 +88210,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__trunctfdf2" } },
                         .unused,
                         .unused,
@@ -86503,12 +88225,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -86519,8 +88241,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__trunctfdf2" } },
                         .unused,
                         .unused,
@@ -86534,12 +88256,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._sd, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -86550,8 +88272,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__trunctfdf2" } },
                         .unused,
                         .unused,
@@ -86565,19 +88287,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ps, .mova, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ps, .movl, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .sse, .x87, null, null },
                     .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -86599,6 +88322,35 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .{ .to_reg = .xmm1 }, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfxf2" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
+                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
@@ -86607,8 +88359,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__trunctfxf2" } },
                         .unused,
                         .unused,
@@ -86622,15 +88374,48 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
-                        .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .f_p, .st, .memi(.dst0t, .tmp0), ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .avx, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfxf2" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.dst0, .tmp0), ._, ._ },
+                        .{ ._, .v_dqa, .mov, .tmp2x, .memi(.src0x, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .sse2, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
@@ -86639,8 +88424,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__trunctfxf2" } },
                         .unused,
                         .unused,
@@ -86654,15 +88439,48 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
-                        .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .f_p, .st, .memi(.dst0t, .tmp0), ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse2, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfxf2" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.dst0, .tmp0), ._, ._ },
+                        .{ ._, ._dqa, .mov, .tmp2x, .memi(.src0x, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
@@ -86671,8 +88489,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__trunctfxf2" } },
                         .unused,
                         .unused,
@@ -86686,13 +88504,45 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sa(.dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
-                        .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .f_p, .st, .memi(.dst0t, .tmp0), ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfxf2" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sa(.dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.dst0, .tmp0), ._, ._ },
+                        .{ ._, ._ps, .mova, .tmp2x, .memi(.src0x, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 } }) catch |err| switch (err) {
                     error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{
@@ -86705,7 +88555,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{ty_op.operand}, &ops, cg);
             },
-            .fpext => |air_tag| if (use_old) try cg.airFpext(inst) else {
+            .fpext => |air_tag| {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                 var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                 var res: [1]Temp = undefined;
@@ -86749,7 +88599,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                     .dst_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -86778,7 +88628,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -86793,11 +88643,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, .v_ps, .mova, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memi(.src0x, .tmp0), ._, ._ },
+                        .{ ._, .v_ps, .mova, .memsi(.dst0y, .@"2", .tmp0), .tmp1y, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -86808,8 +88658,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__extendhfsf2" } },
                         .unused,
                         .unused,
@@ -86823,13 +88673,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
-                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
+                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .v_ss, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_ss, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -86840,8 +88690,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__extendhfsf2" } },
                         .unused,
                         .unused,
@@ -86855,13 +88705,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+                        .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._ss, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ss, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -86872,10 +88722,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
                         .{ .type = .f32, .kind = .mem },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__extendhfsf2" } },
                         .unused,
                         .unused,
@@ -86887,14 +88737,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                         .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, ._ss, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ss, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .f16c, null, null, null },
@@ -86969,7 +88819,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                     .dst_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -86998,7 +88848,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                         .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                         .unused,
@@ -87013,15 +88863,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, .v_pd, .cvtps2, .tmp2y, .tmp1x, ._, ._ },
                         .{ ._, .v_f128, .extract, .tmp1x, .tmp1y, .ui(1), ._ },
-                        .{ ._, .v_pd, .mova, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp2y, ._, ._ },
+                        .{ ._, .v_pd, .mova, .memsi(.dst0y, .@"4", .tmp0), .tmp2y, ._, ._ },
                         .{ ._, .v_pd, .cvtps2, .tmp2y, .tmp1x, ._, ._ },
-                        .{ ._, .v_pd, .mova, .memsiad(.dst0y, .@"4", .tmp0, .add_unaligned_size, 32), .tmp2y, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_pd, .mova, .memsid(.dst0y, .@"4", .tmp0, 32), .tmp2y, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -87032,8 +88882,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__extendhfdf2" } },
                         .unused,
                         .unused,
@@ -87047,13 +88897,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
-                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
+                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .v_sd, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_sd, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -87064,8 +88914,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__extendhfdf2" } },
                         .unused,
                         .unused,
@@ -87079,13 +88929,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+                        .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._sd, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._sd, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -87096,10 +88946,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
                         .{ .type = .f32, .kind = .mem },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__extendhfdf2" } },
                         .unused,
                         .unused,
@@ -87111,14 +88961,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                         .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, ._ps, .movl, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ps, .movl, .memsi(.dst0q, .@"4", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .f16c, .x87, null, null },
@@ -87148,11 +88998,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .sse, .x87, null, null },
                     .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                     .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -87174,6 +89025,35 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
+                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .{ .to_reg = .xmm1 }, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__extendhfxf2" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
+                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
@@ -87182,8 +89062,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__extendhfxf2" } },
                         .unused,
                         .unused,
@@ -87197,16 +89077,50 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
-                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
+                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
-                        .{ ._, .f_p, .st, .memsia(.dst0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .f_p, .st, .memsi(.dst0t, .@"8", .tmp0), ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .avx, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__extendhfxf2" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.dst0, .@"8", .tmp0), ._, ._ },
+                        .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
+                        .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memi(.src0w, .tmp0), .ui(0) },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .sse2, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
@@ -87215,8 +89129,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__extendhfxf2" } },
                         .unused,
                         .unused,
@@ -87230,16 +89144,50 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+                        .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
-                        .{ ._, .f_p, .st, .memsia(.dst0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .f_p, .st, .memsi(.dst0t, .@"8", .tmp0), ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse2, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__extendhfxf2" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.dst0, .@"8", .tmp0), ._, ._ },
+                        .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
+                        .{ ._, .p_w, .insr, .tmp2x, .memi(.src0w, .tmp0), .ui(0), ._ },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
@@ -87248,10 +89196,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
                         .{ .type = .f32, .kind = .mem },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__extendhfxf2" } },
                         .unused,
                         .unused,
@@ -87263,22 +89211,56 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                         .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                         .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
-                        .{ ._, .f_p, .st, .memsia(.dst0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .f_p, .st, .memsi(.dst0t, .@"8", .tmp0), ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .reg = .ax } },
+                        .{ .type = .f32, .kind = .mem },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__extendhfxf2" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.dst0, .@"8", .tmp0), ._, ._ },
+                        .{ ._, ._, .movzx, .tmp2d, .memi(.src0w, .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .mem(.tmp3d), .tmp2d, ._, ._ },
+                        .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp3d), ._, ._ },
+                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                     .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -87308,8 +89290,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__extendhftf2" } },
                         .unused,
                         .unused,
@@ -87323,13 +89305,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
-                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
+                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"8", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -87340,8 +89322,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__extendhftf2" } },
                         .unused,
                         .unused,
@@ -87355,13 +89337,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+                        .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"8", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -87372,10 +89354,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
                         .{ .type = .f32, .kind = .mem },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__extendhftf2" } },
                         .unused,
                         .unused,
@@ -87387,14 +89369,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                         .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, ._ps, .mova, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"8", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -87501,7 +89483,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -87516,11 +89498,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_pd, .cvtps2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, .v_pd, .mova, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .v_pd, .cvtps2, .tmp1y, .memi(.src0x, .tmp0), ._, ._ },
+                        .{ ._, .v_pd, .mova, .memsi(.dst0y, .@"2", .tmp0), .tmp1y, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -87530,7 +89512,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -87545,11 +89527,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._pd, .cvtps2, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._pd, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", ._pd, .cvtps2, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
+                        .{ ._, ._pd, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .x87, null, null, null },
@@ -87559,7 +89541,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f32, .kind = .{ .reg = .st7 } },
                         .unused,
                         .unused,
@@ -87574,11 +89556,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .f_, .ld, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, .f_p, .st, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .f_, .ld, .memi(.src0d, .tmp0), ._, ._, ._ },
+                        .{ ._, .f_p, .st, .memsi(.dst0q, .@"2", .tmp0), ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .x87, null, null, null },
@@ -87613,7 +89595,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f32, .kind = .{ .reg = .st7 } },
                         .unused,
                         .unused,
@@ -87628,18 +89610,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .f_, .ld, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, .f_p, .st, .memsia(.dst0t, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .f_, .ld, .memi(.src0d, .tmp0), ._, ._, ._ },
+                        .{ ._, .f_p, .st, .memsi(.dst0t, .@"4", .tmp0), ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                     .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -87669,8 +89651,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__extendsftf2" } },
                         .unused,
                         .unused,
@@ -87684,12 +89666,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -87700,8 +89682,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__extendsftf2" } },
                         .unused,
                         .unused,
@@ -87715,12 +89697,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -87731,8 +89713,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__extendsftf2" } },
                         .unused,
                         .unused,
@@ -87746,12 +89728,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .x87, null, null, null },
@@ -87786,7 +89768,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f64, .kind = .{ .reg = .st7 } },
                         .unused,
                         .unused,
@@ -87801,18 +89783,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .f_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, .f_p, .st, .memsia(.dst0t, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .f_, .ld, .memi(.src0q, .tmp0), ._, ._, ._ },
+                        .{ ._, .f_p, .st, .memsi(.dst0t, .@"2", .tmp0), ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                     .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -87842,8 +89824,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__extenddftf2" } },
                         .unused,
                         .unused,
@@ -87857,12 +89839,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -87873,8 +89855,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__extenddftf2" } },
                         .unused,
                         .unused,
@@ -87888,12 +89870,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -87904,8 +89886,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__extenddftf2" } },
                         .unused,
                         .unused,
@@ -87919,15 +89901,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._ps, .movl, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._ps, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                     .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any },
@@ -87948,7 +89931,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, .v_dqa, .mov, .dst0x, .mem(.src0x), ._, ._ },
@@ -87956,6 +89939,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .sse2, null, null, null },
                     .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                     .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any },
@@ -87976,7 +89960,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._dqa, .mov, .dst0x, .mem(.src0x), ._, ._ },
@@ -87984,6 +89968,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                     .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any },
@@ -88004,7 +89989,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._ps, .mova, .dst0x, .mem(.src0x), ._, ._ },
@@ -88012,6 +89997,35 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
+                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__extendxftf2" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
+                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
@@ -88020,8 +90034,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__extendxftf2" } },
                         .unused,
@@ -88035,15 +90049,80 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, .v_dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .avx, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__extendxftf2" } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse2, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__extendxftf2" } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .sse2, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
@@ -88052,8 +90131,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__extendxftf2" } },
                         .unused,
@@ -88067,15 +90146,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, ._dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
@@ -88084,8 +90164,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__extendxftf2" } },
                         .unused,
@@ -88099,13 +90179,45 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, ._ps, .mova, .mem(.tmp2x), .tmp1x, ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__extendxftf2" } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 } }) catch |err| switch (err) {
                     error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{
@@ -88118,7 +90230,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{ty_op.operand}, &ops, cg);
             },
-            .intcast => |air_tag| if (use_old) try cg.airIntCast(inst) else {
+            .intcast => |air_tag| {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                 const dst_ty = ty_op.ty.toType();
                 const src_ty = cg.typeOf(ty_op.operand);
@@ -92797,7 +94909,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 try res[0].finish(inst, &.{ty_op.operand}, &ops, cg);
             },
             .intcast_safe => unreachable,
-            .trunc => |air_tag| if (use_old) try cg.airTrunc(inst) else {
+            .trunc => |air_tag| {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                 var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                 var res: [1]Temp = undefined;
@@ -98462,7 +100574,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{ty_op.operand}, &ops, cg);
             },
-            .optional_payload => if (use_old) try cg.airOptionalPayload(inst) else {
+            .optional_payload => {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                 var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                 const pl = if (!hack_around_sema_opv_bugs or ty_op.ty.toType().hasRuntimeBitsIgnoreComptime(zcu))
@@ -98471,12 +100583,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     try cg.tempInit(ty_op.ty.toType(), .none);
                 try pl.finish(inst, &.{ty_op.operand}, &ops, cg);
             },
-            .optional_payload_ptr => if (use_old) try cg.airOptionalPayloadPtr(inst) else {
+            .optional_payload_ptr => {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                 const ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                 try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg);
             },
-            .optional_payload_ptr_set => if (use_old) try cg.airOptionalPayloadPtrSet(inst) else {
+            .optional_payload_ptr_set => {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                 const opt_ty = cg.typeOf(ty_op.operand).childType(zcu);
                 var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
@@ -98491,7 +100603,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 }
                 try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg);
             },
-            .wrap_optional => if (use_old) try cg.airWrapOptional(inst) else {
+            .wrap_optional => {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                 const opt_ty = ty_op.ty.toType();
                 const opt_pl_ty = cg.typeOf(ty_op.operand);
@@ -98506,7 +100618,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 }
                 try opt.finish(inst, &.{ty_op.operand}, &ops, cg);
             },
-            .unwrap_errunion_payload => if (use_old) try cg.airUnwrapErrUnionPayload(inst) else {
+            .unwrap_errunion_payload => {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                 const eu_pl_ty = ty_op.ty.toType();
                 const eu_pl_off: i32 = @intCast(codegen.errUnionPayloadOffset(eu_pl_ty, zcu));
@@ -98517,7 +100629,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     try cg.tempInit(eu_pl_ty, .none);
                 try pl.finish(inst, &.{ty_op.operand}, &ops, cg);
             },
-            .unwrap_errunion_err => if (use_old) try cg.airUnwrapErrUnionErr(inst) else {
+            .unwrap_errunion_err => {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                 const eu_ty = cg.typeOf(ty_op.operand);
                 const eu_err_ty = ty_op.ty.toType();
@@ -98527,7 +100639,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 const err = try ops[0].read(eu_err_ty, .{ .disp = eu_err_off }, cg);
                 try err.finish(inst, &.{ty_op.operand}, &ops, cg);
             },
-            .unwrap_errunion_payload_ptr => if (use_old) try cg.airUnwrapErrUnionPayloadPtr(inst) else {
+            .unwrap_errunion_payload_ptr => {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                 const eu_ty = cg.typeOf(ty_op.operand).childType(zcu);
                 const eu_pl_ty = eu_ty.errorUnionPayload(zcu);
@@ -98536,7 +100648,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 try ops[0].toOffset(eu_pl_off, cg);
                 try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg);
             },
-            .unwrap_errunion_err_ptr => if (use_old) try cg.airUnwrapErrUnionErrPtr(inst) else {
+            .unwrap_errunion_err_ptr => {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                 const eu_ty = cg.typeOf(ty_op.operand).childType(zcu);
                 const eu_err_ty = ty_op.ty.toType();
@@ -98547,7 +100659,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 const err = try ops[0].load(eu_err_ty, .{}, cg);
                 try err.finish(inst, &.{ty_op.operand}, &ops, cg);
             },
-            .errunion_payload_ptr_set => if (use_old) try cg.airErrUnionPayloadPtrSet(inst) else {
+            .errunion_payload_ptr_set => {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                 const eu_ty = cg.typeOf(ty_op.operand).childType(zcu);
                 const eu_err_ty = eu_ty.errorUnionSet(zcu);
@@ -98562,7 +100674,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 try ops[0].toOffset(eu_pl_off - eu_err_off, cg);
                 try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg);
             },
-            .wrap_errunion_payload => if (use_old) try cg.airWrapErrUnionPayload(inst) else {
+            .wrap_errunion_payload => {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                 const eu_ty = ty_op.ty.toType();
                 const eu_err_ty = eu_ty.errorUnionSet(zcu);
@@ -98577,7 +100689,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 try err.die(cg);
                 try eu.finish(inst, &.{ty_op.operand}, &ops, cg);
             },
-            .wrap_errunion_err => if (use_old) try cg.airWrapErrUnionErr(inst) else {
+            .wrap_errunion_err => {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                 const eu_ty = ty_op.ty.toType();
                 const eu_pl_ty = eu_ty.errorUnionPayload(zcu);
@@ -98587,7 +100699,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 try eu.write(&ops[0], .{ .disp = eu_err_off }, cg);
                 try eu.finish(inst, &.{ty_op.operand}, &ops, cg);
             },
-            .struct_field_ptr => if (use_old) try cg.airStructFieldPtr(inst) else {
+            .struct_field_ptr => {
                 const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                 const struct_field = cg.air.extraData(Air.StructField, ty_pl.payload).data;
                 var ops = try cg.tempsFromOperands(inst, .{struct_field.struct_operand});
@@ -98602,13 +100714,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
             .struct_field_ptr_index_1,
             .struct_field_ptr_index_2,
             .struct_field_ptr_index_3,
-            => |air_tag| if (use_old) try cg.airStructFieldPtrIndex(inst, switch (air_tag) {
-                else => unreachable,
-                .struct_field_ptr_index_0 => 0,
-                .struct_field_ptr_index_1 => 1,
-                .struct_field_ptr_index_2 => 2,
-                .struct_field_ptr_index_3 => 3,
-            }) else {
+            => |air_tag| {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                 var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                 try ops[0].toOffset(cg.fieldOffset(
@@ -98624,14 +100730,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 ), cg);
                 try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg);
             },
-            .struct_field_val => if (use_old) try cg.airStructFieldVal(inst) else fallback: {
+            .struct_field_val => {
                 const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                 const struct_field = cg.air.extraData(Air.StructField, ty_pl.payload).data;
                 const agg_ty = cg.typeOf(struct_field.struct_operand);
                 const field_ty = ty_pl.ty.toType();
                 const field_off: u31 = switch (agg_ty.containerLayout(zcu)) {
                     .auto, .@"extern" => @intCast(agg_ty.structFieldOffset(struct_field.field_index, zcu)),
-                    .@"packed" => break :fallback try cg.airStructFieldVal(inst),
+                    .@"packed" => unreachable,
                 };
                 var ops = try cg.tempsFromOperands(inst, .{struct_field.struct_operand});
                 var res = if (!hack_around_sema_opv_bugs or field_ty.hasRuntimeBitsIgnoreComptime(zcu))
@@ -98640,7 +100746,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     try cg.tempInit(field_ty, .none);
                 try res.finish(inst, &.{struct_field.struct_operand}, &ops, cg);
             },
-            .set_union_tag => if (use_old) try cg.airSetUnionTag(inst) else {
+            .set_union_tag => {
                 const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                 const union_ty = cg.typeOf(bin_op.lhs).childType(zcu);
                 const union_layout = union_ty.unionGetLayout(zcu);
@@ -98651,7 +100757,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 const res = try cg.tempInit(.void, .none);
                 try res.finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
             },
-            .get_union_tag => if (use_old) try cg.airGetUnionTag(inst) else {
+            .get_union_tag => {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                 const union_ty = cg.typeOf(ty_op.operand);
                 var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
@@ -98662,38 +100768,38 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 }, cg);
                 try res.finish(inst, &.{ty_op.operand}, &ops, cg);
             },
-            .slice => if (use_old) try cg.airSlice(inst) else {
+            .slice => {
                 const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                 const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data;
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                 try ops[0].toPair(&ops[1], cg);
                 try ops[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
             },
-            .slice_len => if (use_old) try cg.airSliceLen(inst) else {
+            .slice_len => {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                 var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                 try ops[0].toSliceLen(cg);
                 try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg);
             },
-            .slice_ptr => if (use_old) try cg.airSlicePtr(inst) else {
+            .slice_ptr => {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                 var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                 try ops[0].toSlicePtr(cg);
                 try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg);
             },
-            .ptr_slice_len_ptr => if (use_old) try cg.airPtrSliceLenPtr(inst) else {
+            .ptr_slice_len_ptr => {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                 var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                 try ops[0].toOffset(8, cg);
                 try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg);
             },
-            .ptr_slice_ptr_ptr => if (use_old) try cg.airPtrSlicePtrPtr(inst) else {
+            .ptr_slice_ptr_ptr => {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                 var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                 try ops[0].toOffset(0, cg);
                 try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg);
             },
-            .array_elem_val => if (use_old) try cg.airArrayElemVal(inst) else {
+            .array_elem_val => {
                 const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                 const array_ty = cg.typeOf(bin_op.lhs);
                 const res_ty = array_ty.elemType2(zcu);
@@ -98889,11 +100995,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
             },
-            .slice_elem_val, .ptr_elem_val => |air_tag| if (use_old) switch (air_tag) {
-                else => unreachable,
-                .slice_elem_val => try cg.airSliceElemVal(inst),
-                .ptr_elem_val => try cg.airPtrElemVal(inst),
-            } else {
+            .slice_elem_val, .ptr_elem_val => {
                 const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                 const res_ty = cg.typeOf(bin_op.lhs).elemType2(zcu);
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
@@ -99016,11 +101118,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 } else res[0] = try cg.tempInit(res_ty, .none);
                 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
             },
-            .slice_elem_ptr, .ptr_elem_ptr => |air_tag| if (use_old) switch (air_tag) {
-                else => unreachable,
-                .slice_elem_ptr => try cg.airSliceElemPtr(inst),
-                .ptr_elem_ptr => try cg.airPtrElemPtr(inst),
-            } else {
+            .slice_elem_ptr, .ptr_elem_ptr => {
                 const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                 const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data;
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
@@ -99067,7 +101165,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 }
                 try ops[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
             },
-            .array_to_slice => if (use_old) try cg.airArrayToSlice(inst) else {
+            .array_to_slice => {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                 var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                 var len = try cg.tempInit(.usize, .{
@@ -99076,7 +101174,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 try ops[0].toPair(&len, cg);
                 try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg);
             },
-            .int_from_float, .int_from_float_optimized => |air_tag| if (use_old) try cg.airIntFromFloat(inst) else {
+            .int_from_float, .int_from_float_optimized => |air_tag| {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                 var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                 var res: [1]Temp = undefined;
@@ -99278,7 +101376,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .src_constraints = .{ .{ .float = .word }, .any, .any },
                     .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -99294,7 +101392,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .eax }, .unused },
+                    .dst_temps = .{ .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
@@ -99304,7 +101402,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .src_constraints = .{ .{ .float = .word }, .any, .any },
                     .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -99320,7 +101418,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .eax }, .unused },
+                    .dst_temps = .{ .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
@@ -99330,7 +101428,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .src_constraints = .{ .{ .float = .word }, .any, .any },
                     .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -99346,7 +101444,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .rax }, .unused },
+                    .dst_temps = .{ .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
@@ -99356,7 +101454,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .src_constraints = .{ .{ .float = .word }, .any, .any },
                     .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -99372,17 +101470,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .rax }, .unused },
+                    .dst_temps = .{ .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .float = .word }, .any, .any },
                     .dst_constraints = .{ .{ .signed_int = .xword }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -99398,17 +101497,72 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg_pair = .{ .rax, .rdx } }, .unused },
+                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .float = .word }, .any, .any },
+                    .dst_constraints = .{ .{ .signed_int = .xword }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixhfti" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .float = .word }, .any, .any },
+                    .dst_constraints = .{ .{ .unsigned_int = .xword }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfti" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .float = .word }, .any, .any },
                     .dst_constraints = .{ .{ .unsigned_int = .xword }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -99424,7 +101578,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg_pair = .{ .rax, .rdx } }, .unused },
+                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
@@ -99434,7 +101588,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .src_constraints = .{ .{ .float = .word }, .any, .any },
                     .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -99465,7 +101619,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .src_constraints = .{ .{ .float = .word }, .any, .any },
                     .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -99527,7 +101681,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } },
                         .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                         .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
@@ -99544,13 +101698,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .each = .{ .once = &.{
                         .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                         .{ ._, .v_ps, .mova, .tmp2x, .lea(.tmp0x), ._, ._ },
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_ps, .cvtph2, .tmp3x, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_size), ._, ._ },
+                        .{ .@"0:", .v_ps, .cvtph2, .tmp3x, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
                         .{ ._, .v_, .cvttps2dq, .tmp3x, .tmp3x, ._, ._ },
                         .{ ._, .vp_b, .shuf, .tmp3x, .tmp3x, .tmp2x, ._ },
-                        .{ ._, .v_d, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_d, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, .slow_incdec, null, null },
@@ -99561,10 +101715,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -99576,13 +101730,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
-                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memsia(.src0w, .@"2", .tmp0, .add_unaligned_size), .ui(0) },
+                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memsi(.src0w, .@"2", .tmp0), .ui(0) },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -99593,10 +101747,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -99608,13 +101762,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
-                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memsia(.src0w, .@"2", .tmp0, .add_unaligned_size), .ui(0) },
+                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memsi(.src0w, .@"2", .tmp0), .ui(0) },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, .slow_incdec, null, null },
@@ -99625,10 +101779,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -99640,13 +101794,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, .p_w, .insr, .tmp1x, .memsia(.src0w, .@"2", .tmp0, .add_unaligned_size), .ui(0), ._ },
+                        .{ ._, .p_w, .insr, .tmp1x, .memsi(.src0w, .@"2", .tmp0), .ui(0), ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -99657,10 +101811,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -99672,13 +101826,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, .p_w, .insr, .tmp1x, .memsia(.src0w, .@"2", .tmp0, .add_unaligned_size), .ui(0), ._ },
+                        .{ ._, .p_w, .insr, .tmp1x, .memsi(.src0w, .@"2", .tmp0), .ui(0), ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, .slow_incdec, null, null },
@@ -99689,10 +101843,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f32, .kind = .mem },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } },
                         .unused,
                         .unused,
@@ -99704,14 +101858,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0w, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memsi(.src0w, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                         .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp1b, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -99722,10 +101876,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f32, .kind = .mem },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } },
                         .unused,
                         .unused,
@@ -99737,14 +101891,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0w, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memsi(.src0w, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                         .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp1b, ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .f16c, null, null, null },
@@ -99782,7 +101936,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -99797,13 +101951,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_ps, .cvtph2, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .v_ps, .cvtph2, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, .v_, .cvttps2dq, .tmp1x, .tmp1x, ._, ._ },
                         .{ ._, .vp_w, .ackssd, .tmp1x, .tmp1x, .tmp1x, ._ },
-                        .{ ._, .v_q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_q, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .f16c, null, null, null },
@@ -99813,7 +101967,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -99828,13 +101982,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_ps, .cvtph2, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .v_ps, .cvtph2, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, .v_, .cvttps2dq, .tmp1x, .tmp1x, ._, ._ },
                         .{ ._, .vp_w, .ackusd, .tmp1x, .tmp1x, .tmp1x, ._ },
-                        .{ ._, .v_q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_q, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -99845,10 +101999,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -99860,13 +102014,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
-                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
+                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -99877,10 +102031,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -99892,13 +102046,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+                        .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -99909,10 +102063,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f32, .kind = .mem },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } },
                         .unused,
                         .unused,
@@ -99924,14 +102078,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                         .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .f16c, null, null, null },
@@ -99941,7 +102095,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -99956,12 +102110,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_ps, .cvtph2, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .v_ps, .cvtph2, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, .v_, .cvttps2dq, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .f16c, null, null, null },
@@ -99971,7 +102125,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f32, .kind = .{ .rc = .sse } },
                         .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .unused,
@@ -99986,14 +102140,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
-                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
+                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                         .{ ._, .v_ps, .cvtph2, .tmp1x, .tmp1q, ._, ._ },
                         .{ ._, .v_, .cvttss2si, .tmp2q, .tmp1x, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp2d, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp2d, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -100004,10 +102158,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -100019,13 +102173,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
-                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
+                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp3d, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp3d, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -100036,10 +102190,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfsi" } },
-                        .{ .type = .u32, .kind = .{ .reg = .eax } },
+                        .{ .type = .u32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -100051,13 +102205,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
-                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
+                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp3d, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp3d, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -100068,10 +102222,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -100083,13 +102237,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+                        .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp3d, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp3d, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -100100,10 +102254,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfsi" } },
-                        .{ .type = .u32, .kind = .{ .reg = .eax } },
+                        .{ .type = .u32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -100115,13 +102269,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+                        .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp3d, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp3d, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -100132,10 +102286,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f32, .kind = .mem },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } },
                         .unused,
                         .unused,
@@ -100147,14 +102301,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                         .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp1d, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -100165,10 +102319,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .eax } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f32, .kind = .mem },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfsi" } },
                         .unused,
                         .unused,
@@ -100180,14 +102334,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                         .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp1d, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .f16c, null, null },
@@ -100197,7 +102351,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f32, .kind = .{ .rc = .sse } },
                         .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                         .unused,
@@ -100212,14 +102366,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
-                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
+                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                         .{ ._, .v_ps, .cvtph2, .tmp1x, .tmp1q, ._, ._ },
                         .{ ._, .v_, .cvttss2si, .tmp2q, .tmp1x, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp2q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp2q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -100230,10 +102384,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixhfdi" } },
-                        .{ .type = .i64, .kind = .{ .reg = .rax } },
+                        .{ .type = .i64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -100245,13 +102399,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
-                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
+                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -100262,10 +102416,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfdi" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
+                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -100277,13 +102431,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
-                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
+                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -100294,10 +102448,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixhfdi" } },
-                        .{ .type = .i64, .kind = .{ .reg = .rax } },
+                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -100309,13 +102463,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+                        .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -100326,10 +102480,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfdi" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
+                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -100341,13 +102495,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+                        .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -100358,10 +102512,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i64, .kind = .{ .reg = .rax } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f32, .kind = .mem },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixhfdi" } },
                         .unused,
                         .unused,
@@ -100373,14 +102527,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                         .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp1q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -100391,10 +102545,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f32, .kind = .mem },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfdi" } },
                         .unused,
                         .unused,
@@ -100406,16 +102560,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                         .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp1q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
@@ -100424,11 +102579,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixhfti" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
-                        .{ .type = .i64, .kind = .{ .reg = .rdx } },
+                        .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -100439,16 +102594,50 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
-                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
+                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q0, ._, ._ },
+                        .{ ._, ._, .mov, .memsid(.dst0q, .@"8", .tmp0, 8), .tmp3q1, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .avx, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixhfti" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
+                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"8", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
@@ -100457,11 +102646,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfti" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
+                        .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -100472,16 +102661,50 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
-                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
+                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q0, ._, ._ },
+                        .{ ._, ._, .mov, .memsid(.dst0q, .@"8", .tmp0, 8), .tmp3q1, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .avx, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfti" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
+                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"8", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .sse2, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
@@ -100490,11 +102713,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixhfti" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
-                        .{ .type = .i64, .kind = .{ .reg = .rdx } },
+                        .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -100505,16 +102728,50 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+                        .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q0, ._, ._ },
+                        .{ ._, ._, .mov, .memsid(.dst0q, .@"8", .tmp0, 8), .tmp3q1, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse2, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixhfti" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
+                        .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"8", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .sse2, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
@@ -100523,11 +102780,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfti" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
+                        .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -100538,16 +102795,50 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+                        .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q0, ._, ._ },
+                        .{ ._, ._, .mov, .memsid(.dst0q, .@"8", .tmp0, 8), .tmp3q1, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse2, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfti" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
+                        .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"8", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
@@ -100556,12 +102847,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f32, .kind = .mem },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixhfti" } },
-                        .{ .type = .i64, .kind = .{ .reg = .rdx } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -100571,17 +102862,52 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d0, .memi(.src0w, .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp2d, .tmp1d0, ._, ._ },
+                        .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ },
+                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp1q0, ._, ._ },
+                        .{ ._, ._, .mov, .memsid(.dst0q, .@"8", .tmp0, 8), .tmp1q1, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f32, .kind = .mem },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixhfti" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                         .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
-                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_unaligned_size, 8), .tmp5q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"8", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
@@ -100590,12 +102916,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f32, .kind = .mem },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfti" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -100605,15 +102931,49 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d0, .memi(.src0w, .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp2d, .tmp1d0, ._, ._ },
+                        .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ },
+                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp1q0, ._, ._ },
+                        .{ ._, ._, .mov, .memsid(.dst0q, .@"8", .tmp0, 8), .tmp1q1, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f32, .kind = .mem },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfti" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                         .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
-                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_unaligned_size, 8), .tmp5q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"8", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .avx, null, null },
@@ -100624,11 +102984,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixhfei" } },
                         .unused,
                         .unused,
@@ -100639,16 +102999,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                         .{ .@"0:", .v_ps, .xor, .tmp4x, .tmp4x, .tmp4x, ._ },
                         .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
-                        .{ ._, .vp_w, .insr, .tmp4x, .tmp4x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
+                        .{ ._, .vp_w, .insr, .tmp4x, .tmp4x, .memi(.src0w, .tmp0), .ui(0) },
                         .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .avx, null, null },
@@ -100659,11 +103019,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfei" } },
                         .unused,
                         .unused,
@@ -100674,16 +103034,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                         .{ .@"0:", .v_ps, .xor, .tmp4x, .tmp4x, .tmp4x, ._ },
                         .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
-                        .{ ._, .vp_w, .insr, .tmp4x, .tmp4x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
+                        .{ ._, .vp_w, .insr, .tmp4x, .tmp4x, .memi(.src0w, .tmp0), .ui(0) },
                         .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse2, null, null },
@@ -100694,11 +103054,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixhfei" } },
                         .unused,
                         .unused,
@@ -100709,16 +103069,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                         .{ .@"0:", ._ps, .xor, .tmp4x, .tmp4x, ._, ._ },
                         .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
-                        .{ ._, .p_w, .insr, .tmp4x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+                        .{ ._, .p_w, .insr, .tmp4x, .memi(.src0w, .tmp0), .ui(0), ._ },
                         .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse2, null, null },
@@ -100729,11 +103089,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfei" } },
                         .unused,
                         .unused,
@@ -100744,16 +103104,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                         .{ .@"0:", ._ps, .xor, .tmp4x, .tmp4x, ._, ._ },
                         .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
-                        .{ ._, .p_w, .insr, .tmp4x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+                        .{ ._, .p_w, .insr, .tmp4x, .memi(.src0w, .tmp0), .ui(0), ._ },
                         .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse, null, null },
@@ -100764,12 +103124,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .f32, .kind = .mem },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixhfei" } },
                         .unused,
                         .unused,
@@ -100779,17 +103139,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp3d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp3d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                         .{ ._, ._, .mov, .tmp4d, .tmp3d, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                         .{ ._, ._ss, .mov, .tmp5x, .tmp4d, ._, ._ },
                         .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse, null, null },
@@ -100800,12 +103160,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .f32, .kind = .mem },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfei" } },
                         .unused,
                         .unused,
@@ -100815,17 +103175,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp3d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp3d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                         .{ ._, ._, .mov, .tmp4d, .tmp3d, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                         .{ ._, ._ss, .mov, .tmp5x, .tmp4d, ._, ._ },
                         .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -100940,11 +103300,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .float = .dword }, .any, .any },
                     .dst_constraints = .{ .{ .signed_int = .xword }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -100960,17 +103321,45 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg_pair = .{ .rax, .rdx } }, .unused },
+                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
+                    .dst_constraints = .{ .{ .signed_int = .xword }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixsfti" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .float = .dword }, .any, .any },
                     .dst_constraints = .{ .{ .unsigned_int = .xword }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -100986,17 +103375,45 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg_pair = .{ .rax, .rdx } }, .unused },
+                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .avx, null, null },
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
+                    .dst_constraints = .{ .{ .unsigned_int = .xword }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .float = .dword }, .any, .any },
                     .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -101024,7 +103441,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ },
                         .{ ._, ._, .xor, .tmp4q, .tmp0q, ._, ._ },
                         .{ ._, ._, .sub, .tmp1q, .tmp0q, ._, ._ },
-                        .{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ },
+                        .{ ._, ._, .mov, .mem(.dst0q), .tmp1q, ._, ._ },
                         .{ ._, ._, .sbb, .tmp4q, .tmp0q, ._, ._ },
                         .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp4q, ._, ._ },
                         .{ ._, ._, .sbb, .tmp1q, .tmp1q, ._, ._ },
@@ -101033,11 +103450,56 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse2, null, null },
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .float = .dword }, .any, .any },
                     .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i64, .kind = .{ .reg = .rax } },
+                        .{ .type = .vector_4_f32, .kind = .{ .smax_mem = .{} } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } },
+                        .{ .type = .i64, .kind = .{ .reg = .rdx } },
+                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
+                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, .v_d, .mov, .tmp0d, .src0x, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ },
+                        .{ ._, ._d, .movsx, .tmp0q, .tmp0d, ._, ._ },
+                        .{ ._, .v_ps, .@"and", .src0x, .src0x, .lea(.tmp1x), ._ },
+                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                        .{ ._, .v_q, .mov, .tmp1q, .src0x, ._, ._ },
+                        .{ ._, .vp_q, .extr, .tmp4q, .src0x, .ui(1), ._ },
+                        .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ },
+                        .{ ._, ._, .xor, .tmp4q, .tmp0q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp1q, .tmp0q, ._, ._ },
+                        .{ ._, ._, .mov, .mem(.dst0q), .tmp1q, ._, ._ },
+                        .{ ._, ._, .sbb, .tmp4q, .tmp0q, ._, ._ },
+                        .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp4q, ._, ._ },
+                        .{ ._, ._, .sbb, .tmp1q, .tmp1q, ._, ._ },
+                        .{ ._, ._, .lea, .tmp5p, .memd(.dst0, 16), ._, ._ },
+                        .{ ._, ._, .mov, .tmp6d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
+                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse2, null, null, null },
+                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
+                    .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -101065,7 +103527,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ },
                         .{ ._, ._, .xor, .tmp4q, .tmp0q, ._, ._ },
                         .{ ._, ._, .sub, .tmp1q, .tmp0q, ._, ._ },
-                        .{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ },
+                        .{ ._, ._, .mov, .mem(.dst0q), .tmp1q, ._, ._ },
                         .{ ._, ._, .sbb, .tmp4q, .tmp0q, ._, ._ },
                         .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp4q, ._, ._ },
                         .{ ._, ._, .sbb, .tmp1q, .tmp1q, ._, ._ },
@@ -101074,7 +103536,97 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse4_1, null, null, null },
+                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
+                    .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i64, .kind = .{ .reg = .rax } },
+                        .{ .type = .vector_4_f32, .kind = .{ .smax_mem = .{} } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } },
+                        .{ .type = .i64, .kind = .{ .reg = .rdx } },
+                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
+                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._d, .mov, .tmp0d, .src0x, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ },
+                        .{ ._, ._d, .movsx, .tmp0q, .tmp0d, ._, ._ },
+                        .{ ._, ._ps, .@"and", .src0x, .lea(.tmp1x), ._, ._ },
+                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                        .{ ._, ._q, .mov, .tmp1q, .src0x, ._, ._ },
+                        .{ ._, .p_q, .extr, .tmp4q, .src0x, .ui(1), ._ },
+                        .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ },
+                        .{ ._, ._, .xor, .tmp4q, .tmp0q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp1q, .tmp0q, ._, ._ },
+                        .{ ._, ._, .mov, .mem(.dst0q), .tmp1q, ._, ._ },
+                        .{ ._, ._, .sbb, .tmp4q, .tmp0q, ._, ._ },
+                        .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp4q, ._, ._ },
+                        .{ ._, ._, .sbb, .tmp1q, .tmp1q, ._, ._ },
+                        .{ ._, ._, .lea, .tmp5p, .memd(.dst0, 16), ._, ._ },
+                        .{ ._, ._, .mov, .tmp6d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
+                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse2, null, null, null },
+                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
+                    .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i64, .kind = .{ .reg = .rax } },
+                        .{ .type = .vector_4_f32, .kind = .{ .smax_mem = .{} } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } },
+                        .{ .type = .i64, .kind = .{ .reg = .rdx } },
+                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
+                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._d, .mov, .tmp0d, .src0x, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ },
+                        .{ ._, ._d, .movsx, .tmp0q, .tmp0d, ._, ._ },
+                        .{ ._, ._ps, .@"and", .src0x, .lea(.tmp1x), ._, ._ },
+                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                        .{ ._, ._q, .mov, .tmp1q, .src0x, ._, ._ },
+                        .{ ._, .p_d, .shuf, .src0x, .src0x, .ui(0b11_10), ._ },
+                        .{ ._, ._q, .mov, .tmp4q, .src0x, ._, ._ },
+                        .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ },
+                        .{ ._, ._, .xor, .tmp4q, .tmp0q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp1q, .tmp0q, ._, ._ },
+                        .{ ._, ._, .mov, .mem(.dst0q), .tmp1q, ._, ._ },
+                        .{ ._, ._, .sbb, .tmp4q, .tmp0q, ._, ._ },
+                        .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp4q, ._, ._ },
+                        .{ ._, ._, .sbb, .tmp1q, .tmp1q, ._, ._ },
+                        .{ ._, ._, .lea, .tmp5p, .memd(.dst0, 16), ._, ._ },
+                        .{ ._, ._, .mov, .tmp6d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
+                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .float = .dword }, .any, .any },
                     .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                     .patterns = &.{
@@ -101082,7 +103634,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .i64, .kind = .{ .reg = .rax } },
                         .{ .type = .vector_4_f32, .kind = .{ .smax_mem = .{} } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } },
@@ -101106,7 +103658,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .xor, .tmp1q, .tmp4q, ._, ._ },
                         .{ ._, ._, .xor, .tmp5q, .tmp4q, ._, ._ },
                         .{ ._, ._, .sub, .tmp1q, .tmp4q, ._, ._ },
-                        .{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ },
+                        .{ ._, ._, .mov, .mem(.dst0q), .tmp1q, ._, ._ },
                         .{ ._, ._, .sbb, .tmp5q, .tmp4q, ._, ._ },
                         .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp5q, ._, ._ },
                         .{ ._, ._, .sbb, .tmp1q, .tmp1q, ._, ._ },
@@ -101115,17 +103667,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .float = .dword }, .any, .any },
                     .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } },
-                        .{ .type = .i64, .kind = .{ .reg = .rax } },
-                        .{ .type = .i64, .kind = .{ .reg = .rdx } },
+                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                         .{ .type = .usize, .kind = .{ .reg = .rdi } },
                         .{ .type = .u32, .kind = .{ .reg = .ecx } },
                         .unused,
@@ -101134,16 +103686,113 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                         .unused,
+                        .unused,
                     },
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ },
-                        .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp2q, ._, ._ },
+                        .{ ._, .v_dqa, .mov, .mem(.dst0x), .src0x, ._, ._ },
                         .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
-                        .{ ._, ._, .lea, .tmp3p, .memd(.dst0, 16), ._, ._ },
-                        .{ ._, ._, .mov, .tmp4d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memd(.dst0, 16), ._, ._ },
+                        .{ ._, ._, .mov, .tmp3d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
+                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse2, null, null, null },
+                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
+                    .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } },
+                        .{ .type = .u64, .kind = .{ .reg = .rax } },
+                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
+                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._dqa, .mov, .mem(.dst0x), .src0x, ._, ._ },
+                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memd(.dst0, 16), ._, ._ },
+                        .{ ._, ._, .mov, .tmp3d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
+                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
+                    .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } },
+                        .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
+                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._, .mov, .mem(.dst0q), .tmp1q0, ._, ._ },
+                        .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp1q1, ._, ._ },
+                        .{ ._, ._, .xor, .tmp1d0, .tmp1d0, ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memd(.dst0, 16), ._, ._ },
+                        .{ ._, ._, .mov, .tmp3d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
+                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse2, null, null, null },
+                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
+                    .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } },
+                        .{ .type = .u64, .kind = .{ .reg = .rax } },
+                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
+                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ps, .mova, .mem(.dst0x), .src0x, ._, ._ },
+                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memd(.dst0, 16), ._, ._ },
+                        .{ ._, ._, .mov, .tmp3d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                         .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                     } },
                 }, .{
@@ -101208,7 +103857,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } },
                         .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                         .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
@@ -101225,12 +103874,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .each = .{ .once = &.{
                         .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                         .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_, .cvttps2dq, .tmp3x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_size), ._, ._ },
+                        .{ .@"0:", .v_, .cvttps2dq, .tmp3x, .memsi(.src0x, .@"4", .tmp0), ._, ._ },
                         .{ ._, .vp_b, .shuf, .tmp3x, .tmp3x, .tmp2x, ._ },
-                        .{ ._, .v_d, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_d, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .ssse3, null, null, null },
@@ -101240,7 +103889,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } },
                         .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                         .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
@@ -101257,12 +103906,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .each = .{ .once = &.{
                         .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                         .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .cvttps2dq, .tmp3x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_size), ._, ._ },
+                        .{ .@"0:", ._, .cvttps2dq, .tmp3x, .memsi(.src0x, .@"4", .tmp0), ._, ._ },
                         .{ ._, .p_b, .shuf, .tmp3x, .tmp2x, ._, ._ },
-                        .{ ._, ._d, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._d, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, .slow_incdec, null, null },
@@ -101272,7 +103921,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                         .unused,
                         .unused,
@@ -101287,11 +103936,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .cvttss2si, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .cvttss2si, .tmp1d, .memsi(.src0d, .@"4", .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp1b, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -101301,7 +103950,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                         .unused,
                         .unused,
@@ -101316,11 +103965,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .cvttss2si, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .cvttss2si, .tmp1d, .memsi(.src0d, .@"4", .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp1b, ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, .slow_incdec, null, null },
@@ -101331,10 +103980,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixsfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -101346,12 +103995,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memsi(.src0d, .@"4", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -101362,10 +104011,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixsfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -101377,12 +104026,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memsi(.src0d, .@"4", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, .slow_incdec, null, null },
@@ -101393,10 +104042,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixsfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -101408,12 +104057,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ss, .mov, .tmp1x, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ss, .mov, .tmp1x, .memsi(.src0d, .@"4", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -101424,10 +104073,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixsfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -101439,12 +104088,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ss, .mov, .tmp1x, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ss, .mov, .tmp1x, .memsi(.src0d, .@"4", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -101506,7 +104155,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -101521,12 +104170,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_, .cvttps2dq, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ },
+                        .{ .@"0:", .v_, .cvttps2dq, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                         .{ ._, .vp_w, .ackssd, .tmp1x, .tmp1x, .tmp1x, ._ },
-                        .{ ._, .v_q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_q, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -101536,7 +104185,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -101551,12 +104200,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .cvttps2dq, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ },
+                        .{ .@"0:", ._, .cvttps2dq, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                         .{ ._, .p_w, .ackssd, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._q, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -101566,7 +104215,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -101581,12 +104230,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_, .cvttps2dq, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ },
+                        .{ .@"0:", .v_, .cvttps2dq, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                         .{ ._, .vp_w, .ackusd, .tmp1x, .tmp1x, .tmp1x, ._ },
-                        .{ ._, .v_q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_q, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse4_1, null, null, null },
@@ -101596,7 +104245,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -101611,12 +104260,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .cvttps2dq, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ },
+                        .{ .@"0:", ._, .cvttps2dq, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                         .{ ._, .p_w, .ackusd, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._q, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -101627,10 +104276,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixsfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -101642,12 +104291,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memsi(.src0d, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -101658,10 +104307,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixsfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -101673,12 +104322,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ss, .mov, .tmp1x, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ss, .mov, .tmp1x, .memsi(.src0d, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -101712,7 +104361,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -101727,11 +104376,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_, .cvttps2dq, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .v_, .cvttps2dq, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
+                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -101741,7 +104390,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -101756,11 +104405,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .cvttps2dq, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", ._, .cvttps2dq, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
+                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -101771,10 +104420,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixsfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -101786,12 +104435,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -101802,10 +104451,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfsi" } },
-                        .{ .type = .u32, .kind = .{ .reg = .eax } },
+                        .{ .type = .u32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -101817,12 +104466,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -101833,10 +104482,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixsfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -101848,12 +104497,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -101864,10 +104513,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfsi" } },
-                        .{ .type = .u32, .kind = .{ .reg = .eax } },
+                        .{ .type = .u32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -101879,12 +104528,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .avx, null, null },
@@ -101894,7 +104543,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                         .unused,
                         .unused,
@@ -101909,11 +104558,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_, .cvttss2si, .tmp1q, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_, .cvttss2si, .tmp1q, .memi(.src0d, .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp1q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse, null, null },
@@ -101923,7 +104572,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                         .unused,
                         .unused,
@@ -101938,11 +104587,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .cvttss2si, .tmp1q, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .cvttss2si, .tmp1q, .memi(.src0d, .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp1q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -101953,10 +104602,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixsfdi" } },
-                        .{ .type = .i64, .kind = .{ .reg = .rax } },
+                        .{ .type = .i64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -101968,12 +104617,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -101984,10 +104633,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfdi" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
+                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -101999,12 +104648,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -102015,10 +104664,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixsfdi" } },
-                        .{ .type = .i64, .kind = .{ .reg = .rax } },
+                        .{ .type = .i64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -102030,12 +104679,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -102046,10 +104695,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfdi" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
+                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -102061,14 +104710,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
@@ -102077,11 +104727,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixsfti" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
-                        .{ .type = .i64, .kind = .{ .reg = .rdx } },
+                        .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -102092,15 +104742,48 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"4", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3q0, ._, ._ },
+                        .{ ._, ._, .mov, .memsid(.dst0q, .@"4", .tmp0, 8), .tmp3q1, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .avx, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixsfti" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
@@ -102109,11 +104792,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
+                        .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -102124,15 +104807,112 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"4", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3q0, ._, ._ },
+                        .{ ._, ._, .mov, .memsid(.dst0q, .@"4", .tmp0, 8), .tmp3q1, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .avx, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse2, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixsfti" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse2, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
@@ -102141,11 +104921,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixsfti" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
-                        .{ .type = .i64, .kind = .{ .reg = .rdx } },
+                        .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -102156,15 +104936,48 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"4", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3q0, ._, ._ },
+                        .{ ._, ._, .mov, .memsid(.dst0q, .@"4", .tmp0, 8), .tmp3q1, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixsfti" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
@@ -102173,11 +104986,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
+                        .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -102188,13 +105001,45 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"4", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3q0, ._, ._ },
+                        .{ ._, ._, .mov, .memsid(.dst0q, .@"4", .tmp0, 8), .tmp3q1, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .avx, null, null },
@@ -102205,11 +105050,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixsfei" } },
                         .unused,
                         .unused,
@@ -102220,15 +105065,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
-                        .{ ._, .v_ss, .mov, .tmp4x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, .v_ss, .mov, .tmp4x, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .avx, null, null },
@@ -102239,11 +105084,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfei" } },
                         .unused,
                         .unused,
@@ -102254,15 +105099,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
-                        .{ ._, .v_ss, .mov, .tmp4x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, .v_ss, .mov, .tmp4x, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse, null, null },
@@ -102273,11 +105118,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixsfei" } },
                         .unused,
                         .unused,
@@ -102288,15 +105133,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
-                        .{ ._, ._ss, .mov, .tmp4x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._ss, .mov, .tmp4x, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse, null, null },
@@ -102307,11 +105152,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfei" } },
                         .unused,
                         .unused,
@@ -102322,15 +105167,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
-                        .{ ._, ._ss, .mov, .tmp4x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._ss, .mov, .tmp4x, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -102643,11 +105488,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .@"or", .dst0q, .tmp5q, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .float = .qword }, .any, .any },
                     .dst_constraints = .{ .{ .signed_int = .xword }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -102663,17 +105509,45 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg_pair = .{ .rax, .rdx } }, .unused },
+                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .float = .qword }, .any, .any },
+                    .dst_constraints = .{ .{ .signed_int = .xword }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixdfti" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .float = .qword }, .any, .any },
                     .dst_constraints = .{ .{ .unsigned_int = .xword }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -102689,7 +105563,34 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg_pair = .{ .rax, .rdx } }, .unused },
+                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .float = .qword }, .any, .any },
+                    .dst_constraints = .{ .{ .unsigned_int = .xword }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfti" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
@@ -102699,12 +105600,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .src_constraints = .{ .{ .float = .qword }, .any, .any },
                     .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixdfei" } },
                         .unused,
                         .unused,
@@ -102727,12 +105628,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .src_constraints = .{ .{ .float = .qword }, .any, .any },
                     .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfei" } },
                         .unused,
                         .unused,
@@ -102839,7 +105740,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } },
                         .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                         .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
@@ -102856,22 +105757,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .each = .{ .once = &.{
                         .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                         .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_, .cvttpd2dq, .tmp3x, .memsia(.src0y, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_size), ._, ._ },
+                        .{ .@"0:", .v_, .cvttpd2dq, .tmp3x, .memsi(.src0y, .@"8", .tmp0), ._, ._ },
                         .{ ._, .vp_b, .shuf, .tmp3x, .tmp3x, .tmp2x, ._ },
-                        .{ ._, .v_d, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_d, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .ssse3, null, null, null },
+                    .required_features = .{ .sse4_1, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .byte } }, .any },
                     .patterns = &.{
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } },
                         .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                         .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
@@ -102888,12 +105789,45 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .each = .{ .once = &.{
                         .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                         .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .cvttpd2dq, .tmp3x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_size), ._, ._ },
+                        .{ .@"0:", ._, .cvttpd2dq, .tmp3x, .memsi(.src0x, .@"8", .tmp0), ._, ._ },
                         .{ ._, .p_b, .shuf, .tmp3x, .tmp2x, ._, ._ },
-                        .{ ._, ._d, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .ssse3, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .byte } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } },
+                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
+                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
+                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
+                        .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_size), ._, ._ },
+                        .{ .@"0:", ._, .cvttpd2dq, .tmp3x, .memsi(.src0x, .@"8", .tmp0), ._, ._ },
+                        .{ ._, .p_b, .shuf, .tmp3x, .tmp2x, ._, ._ },
+                        .{ ._, ._d, .mov, .tmp4d, .tmp3x, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp4w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, .slow_incdec, null, null },
@@ -102903,7 +105837,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                         .unused,
                         .unused,
@@ -102918,11 +105852,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .cvttsd2si, .tmp1d, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .cvttsd2si, .tmp1d, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp1b, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -102932,7 +105866,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                         .unused,
                         .unused,
@@ -102947,11 +105881,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .cvttsd2si, .tmp1d, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .cvttsd2si, .tmp1d, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp1b, ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .x87, .slow_incdec, null, null },
@@ -102961,7 +105895,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .u16, .kind = .mem },
                         .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f64, .kind = .{ .reg = .st7 } },
@@ -102976,18 +105910,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                         .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                         .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
                         .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ },
                         .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                         .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
-                        .{ .@"0:", .f_, .ld, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ },
+                        .{ .@"0:", .f_, .ld, .memsi(.src0q, .@"8", .tmp0), ._, ._, ._ },
                         .{ ._, .fi_p, .st, .tmp4w, ._, ._, ._ },
                         .{ ._, ._, .movzx, .tmp2d, .tmp4b, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp2b, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                         .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                     } },
                 }, .{
@@ -102998,7 +105932,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .u16, .kind = .mem },
                         .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f64, .kind = .{ .reg = .st7 } },
@@ -103013,18 +105947,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                         .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                         .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
                         .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ },
                         .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                         .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
-                        .{ .@"0:", .f_, .ld, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ },
+                        .{ .@"0:", .f_, .ld, .memsi(.src0q, .@"8", .tmp0), ._, ._, ._ },
                         .{ ._, .fi_p, .st, .tmp4w, ._, ._, ._ },
                         .{ ._, ._, .movzx, .tmp2d, .tmp4b, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp2b, ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                         .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                     } },
                 }, .{
@@ -103036,10 +105970,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixdfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -103051,12 +105985,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -103067,10 +106001,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixdfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -103082,12 +106016,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, .slow_incdec, null, null },
@@ -103098,10 +106032,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixdfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -103113,12 +106047,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._sd, .mov, .tmp1x, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._sd, .mov, .tmp1x, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -103129,10 +106063,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixsfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -103144,12 +106078,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._sd, .mov, .tmp1x, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._sd, .mov, .tmp1x, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, .slow_incdec, null, null },
@@ -103160,10 +106094,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixdfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -103175,13 +106109,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, ._ps, .movl, .tmp1x, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._ps, .movl, .tmp1x, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -103192,10 +106126,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixsfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -103207,13 +106141,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, ._ps, .movl, .tmp1x, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._ps, .movl, .tmp1x, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -103301,7 +106235,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -103316,12 +106250,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_, .cvttpd2dq, .tmp1x, .memsia(.src0y, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ },
+                        .{ .@"0:", .v_, .cvttpd2dq, .tmp1x, .memsi(.src0y, .@"4", .tmp0), ._, ._ },
                         .{ ._, .vp_w, .ackssd, .tmp1x, .tmp1x, .tmp1x, ._ },
-                        .{ ._, .v_q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_q, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -103331,7 +106265,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -103346,12 +106280,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .cvttpd2dq, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_size), ._, ._ },
+                        .{ .@"0:", ._, .cvttpd2dq, .tmp1x, .memsi(.src0x, .@"4", .tmp0), ._, ._ },
                         .{ ._, .p_w, .ackssd, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, ._d, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._d, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -103361,7 +106295,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -103376,12 +106310,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_, .cvttpd2dq, .tmp1x, .memsia(.src0y, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ },
+                        .{ .@"0:", .v_, .cvttpd2dq, .tmp1x, .memsi(.src0y, .@"4", .tmp0), ._, ._ },
                         .{ ._, .vp_w, .ackusd, .tmp1x, .tmp1x, .tmp1x, ._ },
-                        .{ ._, .v_q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_q, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse4_1, null, null, null },
@@ -103391,7 +106325,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -103406,12 +106340,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .cvttpd2dq, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_size), ._, ._ },
+                        .{ .@"0:", ._, .cvttpd2dq, .tmp1x, .memsi(.src0x, .@"4", .tmp0), ._, ._ },
                         .{ ._, .p_w, .ackusd, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, ._d, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._d, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -103421,7 +106355,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                         .unused,
                         .unused,
@@ -103436,11 +106370,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .cvttsd2si, .tmp1d, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .cvttsd2si, .tmp1d, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .x87, null, null, null },
@@ -103450,7 +106384,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .u16, .kind = .mem },
                         .{ .type = .f64, .kind = .{ .reg = .st7 } },
                         .unused,
@@ -103470,11 +106404,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ },
                         .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                         .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp0b, ._, ._ },
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .f_, .ld, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, .fi_p, .st, .memia(.dst0w, .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .f_, .ld, .memsi(.src0q, .@"4", .tmp0), ._, ._, ._ },
+                        .{ ._, .fi_p, .st, .memi(.dst0w, .tmp0), ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                         .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                     } },
                 }, .{
@@ -103485,7 +106419,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .u16, .kind = .mem },
                         .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f64, .kind = .{ .reg = .st7 } },
@@ -103500,18 +106434,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                         .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                         .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
                         .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ },
                         .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                         .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
-                        .{ .@"0:", .f_, .ld, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ },
+                        .{ .@"0:", .f_, .ld, .memsi(.src0q, .@"4", .tmp0), ._, ._, ._ },
                         .{ ._, .fi_p, .st, .tmp4d, ._, ._, ._ },
                         .{ ._, ._, .mov, .tmp2d, .tmp4d, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp2w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                         .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                     } },
                 }, .{
@@ -103523,10 +106457,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixdfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -103538,12 +106472,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -103554,10 +106488,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixdfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -103569,12 +106503,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._sd, .mov, .tmp1x, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._sd, .mov, .tmp1x, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -103585,10 +106519,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixdfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -103600,13 +106534,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, ._ps, .movl, .tmp1x, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._ps, .movl, .tmp1x, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -103652,7 +106586,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -103667,11 +106601,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_, .cvttpd2dq, .tmp1x, .memsia(.src0y, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
+                        .{ .@"0:", .v_, .cvttpd2dq, .tmp1x, .memsi(.src0y, .@"2", .tmp0), ._, ._ },
+                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -103681,7 +106615,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -103696,11 +106630,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .cvttpd2dq, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ },
+                        .{ .@"0:", ._, .cvttpd2dq, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
+                        .{ ._, ._q, .mov, .memi(.dst0q, .tmp0), .tmp1q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .x87, null, null, null },
@@ -103710,7 +106644,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .u16, .kind = .mem },
                         .{ .type = .f64, .kind = .{ .reg = .st7 } },
                         .unused,
@@ -103730,11 +106664,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ },
                         .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                         .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp0b, ._, ._ },
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .f_, .ld, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, .fi_p, .st, .memia(.dst0d, .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .f_, .ld, .memsi(.src0q, .@"2", .tmp0), ._, ._, ._ },
+                        .{ ._, .fi_p, .st, .memi(.dst0d, .tmp0), ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                         .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                     } },
                 }, .{
@@ -103745,7 +106679,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .u16, .kind = .mem },
                         .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f64, .kind = .{ .reg = .st7 } },
@@ -103760,18 +106694,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                         .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                         .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
                         .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ },
                         .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                         .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
-                        .{ .@"0:", .f_, .ld, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ },
+                        .{ .@"0:", .f_, .ld, .memsi(.src0q, .@"2", .tmp0), ._, ._, ._ },
                         .{ ._, .fi_p, .st, .tmp4q, ._, ._, ._ },
                         .{ ._, ._, .mov, .tmp2d, .tmp4d, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp2d, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                         .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                     } },
                 }, .{
@@ -103783,10 +106717,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixdfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -103798,12 +106732,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -103814,10 +106748,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfsi" } },
-                        .{ .type = .u32, .kind = .{ .reg = .eax } },
+                        .{ .type = .u32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -103829,12 +106763,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -103845,10 +106779,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixdfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -103860,12 +106794,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._sd, .mov, .tmp1x, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._sd, .mov, .tmp1x, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -103876,10 +106810,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfsi" } },
-                        .{ .type = .u32, .kind = .{ .reg = .eax } },
+                        .{ .type = .u32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -103891,12 +106825,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._sd, .mov, .tmp1x, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._sd, .mov, .tmp1x, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -103907,10 +106841,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixdfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -103922,13 +106856,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, ._ps, .movl, .tmp1x, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._ps, .movl, .tmp1x, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -103939,10 +106873,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfsi" } },
-                        .{ .type = .u32, .kind = .{ .reg = .eax } },
+                        .{ .type = .u32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -103954,13 +106888,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, ._ps, .movl, .tmp1x, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._ps, .movl, .tmp1x, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .avx, null, null },
@@ -103970,7 +106904,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                         .unused,
                         .unused,
@@ -103985,11 +106919,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_, .cvttsd2si, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_, .cvttsd2si, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp1q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse2, null, null },
@@ -103999,7 +106933,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                         .unused,
                         .unused,
@@ -104014,11 +106948,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .cvttsd2si, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .cvttsd2si, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp1q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .x87, null, null, null },
@@ -104028,7 +106962,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .u16, .kind = .mem },
                         .{ .type = .f64, .kind = .{ .reg = .st7 } },
                         .unused,
@@ -104048,11 +106982,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ },
                         .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                         .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp0b, ._, ._ },
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .f_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, .fi_p, .st, .memia(.dst0q, .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .f_, .ld, .memi(.src0q, .tmp0), ._, ._, ._ },
+                        .{ ._, .fi_p, .st, .memi(.dst0q, .tmp0), ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                         .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                     } },
                 }, .{
@@ -104064,10 +106998,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixdfdi" } },
-                        .{ .type = .i64, .kind = .{ .reg = .rax } },
+                        .{ .type = .i64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -104079,12 +107013,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -104095,10 +107029,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfdi" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
+                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -104110,12 +107044,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -104126,10 +107060,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixdfdi" } },
-                        .{ .type = .i64, .kind = .{ .reg = .rax } },
+                        .{ .type = .i64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -104141,12 +107075,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -104157,10 +107091,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfdi" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
+                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -104172,12 +107106,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -104188,10 +107122,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixdfdi" } },
-                        .{ .type = .i64, .kind = .{ .reg = .rax } },
+                        .{ .type = .i64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -104203,13 +107137,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._ps, .movl, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -104220,10 +107154,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfdi" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
+                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -104235,15 +107169,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._ps, .movl, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
@@ -104252,11 +107187,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixdfti" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
-                        .{ .type = .i64, .kind = .{ .reg = .rdx } },
+                        .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -104267,15 +107202,48 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"2", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3q0, ._, ._ },
+                        .{ ._, ._, .mov, .memsid(.dst0q, .@"2", .tmp0, 8), .tmp3q1, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .avx, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixdfti" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
@@ -104284,11 +107252,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfti" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
+                        .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -104299,15 +107267,48 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"2", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3q0, ._, ._ },
+                        .{ ._, ._, .mov, .memsid(.dst0q, .@"2", .tmp0, 8), .tmp3q1, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .avx, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfti" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .sse2, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
@@ -104316,11 +107317,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixdfti" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
-                        .{ .type = .i64, .kind = .{ .reg = .rdx } },
+                        .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -104331,15 +107332,48 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"2", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3q0, ._, ._ },
+                        .{ ._, ._, .mov, .memsid(.dst0q, .@"2", .tmp0, 8), .tmp3q1, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse2, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixdfti" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .sse2, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
@@ -104348,11 +107382,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfti" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
+                        .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -104363,15 +107397,48 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"2", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3q0, ._, ._ },
+                        .{ ._, ._, .mov, .memsid(.dst0q, .@"2", .tmp0, 8), .tmp3q1, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse2, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfti" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
@@ -104380,11 +107447,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixdfti" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
-                        .{ .type = .i64, .kind = .{ .reg = .rdx } },
+                        .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -104395,16 +107462,50 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._ps, .movl, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"2", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3q0, ._, ._ },
+                        .{ ._, ._, .mov, .memsid(.dst0q, .@"2", .tmp0, 8), .tmp3q1, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixdfti" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
+                        .{ ._, ._ps, .movl, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
@@ -104413,11 +107514,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfti" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
+                        .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -104428,14 +107529,47 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._ps, .movl, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"2", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3q0, ._, ._ },
+                        .{ ._, ._, .mov, .memsid(.dst0q, .@"2", .tmp0, 8), .tmp3q1, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfti" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
+                        .{ ._, ._ps, .movl, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .avx, null, null },
@@ -104446,11 +107580,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixdfei" } },
                         .unused,
                         .unused,
@@ -104461,15 +107595,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
-                        .{ ._, .v_sd, .mov, .tmp4x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, .v_sd, .mov, .tmp4x, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .avx, null, null },
@@ -104480,11 +107614,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfei" } },
                         .unused,
                         .unused,
@@ -104495,15 +107629,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
-                        .{ ._, .v_sd, .mov, .tmp4x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, .v_sd, .mov, .tmp4x, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse2, null, null },
@@ -104514,11 +107648,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixdfei" } },
                         .unused,
                         .unused,
@@ -104529,15 +107663,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
-                        .{ ._, ._sd, .mov, .tmp4x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._sd, .mov, .tmp4x, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse2, null, null },
@@ -104548,11 +107682,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfei" } },
                         .unused,
                         .unused,
@@ -104563,15 +107697,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
-                        .{ ._, ._sd, .mov, .tmp4x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._sd, .mov, .tmp4x, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse, null, null },
@@ -104582,11 +107716,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixdfei" } },
                         .unused,
                         .unused,
@@ -104597,16 +107731,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                         .{ .@"0:", ._ps, .xor, .tmp4x, .tmp4x, ._, ._ },
                         .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
-                        .{ ._, ._ps, .movl, .tmp4x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._ps, .movl, .tmp4x, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse, null, null },
@@ -104617,11 +107751,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfei" } },
                         .unused,
                         .unused,
@@ -104632,16 +107766,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                         .{ .@"0:", ._ps, .xor, .tmp4x, .tmp4x, ._, ._ },
                         .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
-                        .{ ._, ._ps, .movl, .tmp4x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._ps, .movl, .tmp4x, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse3, .x87, null, null },
@@ -104772,7 +107906,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
                         .{ .type = .i16, .kind = .mem },
                         .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
@@ -104786,15 +107920,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .f_, .ld, .lea(.tmp0t), ._, ._, ._ },
                         .{ ._, .fi_p, .stt, .tmp3w, ._, ._, ._ },
                         .{ ._, ._, .movsx, .tmp4d, .tmp3b, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp4b, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ },
-                        .{ ._, ._, .add, .tmp1p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp4b, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse3, .x87, null, null },
@@ -104805,7 +107939,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
                         .{ .type = .i16, .kind = .mem },
                         .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
@@ -104819,15 +107953,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .f_, .ld, .lea(.tmp0t), ._, ._, ._ },
                         .{ ._, .fi_p, .stt, .tmp3w, ._, ._, ._ },
                         .{ ._, ._, .movsx, .tmp4d, .tmp3b, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp4b, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ },
-                        .{ ._, ._c, .in, .tmp1p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp4b, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ },
+                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .x87, .slow_incdec, null, null },
@@ -104838,7 +107972,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .u16, .kind = .mem },
                         .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
@@ -104852,8 +107986,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                         .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ },
                         .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ },
                         .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_11_00), ._, ._ },
@@ -104862,10 +107996,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .@"0:", .f_, .ld, .lea(.tmp0t), ._, ._, ._ },
                         .{ ._, .fi_p, .st, .tmp5w, ._, ._, ._ },
                         .{ ._, ._, .movsx, .tmp3d, .tmp5b, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp3b, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ },
-                        .{ ._, ._, .add, .tmp1p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp3b, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                         .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                     } },
                 }, .{
@@ -104877,7 +108011,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .u16, .kind = .mem },
                         .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
@@ -104891,8 +108025,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                         .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ },
                         .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ },
                         .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_11_00), ._, ._ },
@@ -104901,10 +108035,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .@"0:", .f_, .ld, .lea(.tmp0t), ._, ._, ._ },
                         .{ ._, .fi_p, .st, .tmp5w, ._, ._, ._ },
                         .{ ._, ._, .movsx, .tmp3d, .tmp5b, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp3b, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ },
-                        .{ ._, ._c, .in, .tmp1p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp3b, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ },
+                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                         .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                     } },
                 }, .{
@@ -104916,7 +108050,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
                         .{ .type = .i16, .kind = .mem },
                         .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
@@ -104930,15 +108064,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .f_, .ld, .lea(.tmp0t), ._, ._, ._ },
                         .{ ._, .fi_p, .stt, .tmp3w, ._, ._, ._ },
                         .{ ._, ._, .movzx, .tmp4d, .tmp3b, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp4b, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ },
-                        .{ ._, ._, .add, .tmp1p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp4b, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse3, .x87, null, null },
@@ -104949,7 +108083,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
                         .{ .type = .i16, .kind = .mem },
                         .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
@@ -104963,15 +108097,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .f_, .ld, .lea(.tmp0t), ._, ._, ._ },
                         .{ ._, .fi_p, .stt, .tmp3w, ._, ._, ._ },
                         .{ ._, ._, .movzx, .tmp4d, .tmp3b, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp4b, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ },
-                        .{ ._, ._c, .in, .tmp1p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp4b, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ },
+                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .x87, .slow_incdec, null, null },
@@ -104982,7 +108116,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .u16, .kind = .mem },
                         .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
@@ -104996,8 +108130,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                         .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ },
                         .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ },
                         .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_11_00), ._, ._ },
@@ -105006,10 +108140,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .@"0:", .f_, .ld, .lea(.tmp0t), ._, ._, ._ },
                         .{ ._, .fi_p, .st, .tmp5w, ._, ._, ._ },
                         .{ ._, ._, .movzx, .tmp3d, .tmp5b, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp3b, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ },
-                        .{ ._, ._, .add, .tmp1p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp3b, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                         .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                     } },
                 }, .{
@@ -105021,7 +108155,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .u16, .kind = .mem },
                         .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
@@ -105035,8 +108169,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                         .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ },
                         .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ },
                         .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_11_00), ._, ._ },
@@ -105045,10 +108179,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .@"0:", .f_, .ld, .lea(.tmp0t), ._, ._, ._ },
                         .{ ._, .fi_p, .st, .tmp5w, ._, ._, ._ },
                         .{ ._, ._, .movzx, .tmp3d, .tmp5b, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp3b, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ },
-                        .{ ._, ._c, .in, .tmp1p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp3b, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ },
+                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                         .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                     } },
                 }, .{
@@ -105117,7 +108251,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
                         .unused,
                         .unused,
@@ -105132,11 +108266,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, .fi_p, .stt, .memia(.dst0w, .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"8", .tmp0), ._, ._, ._ },
+                        .{ ._, .fi_p, .stt, .memi(.dst0w, .tmp0), ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .x87, null, null, null },
@@ -105146,7 +108280,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .u16, .kind = .mem },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
                         .unused,
@@ -105166,11 +108300,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ },
                         .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                         .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp0b, ._, ._ },
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, .fi_p, .st, .memia(.dst0w, .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"8", .tmp0), ._, ._, ._ },
+                        .{ ._, .fi_p, .st, .memi(.dst0w, .tmp0), ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                         .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                     } },
                 }, .{
@@ -105181,7 +108315,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
                         .{ .type = .i32, .kind = .mem },
                         .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
@@ -105196,13 +108330,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"8", .tmp0), ._, ._, ._ },
                         .{ ._, .fi_p, .stt, .tmp2d, ._, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .tmp2d, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .x87, null, null, null },
@@ -105212,7 +108346,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .u16, .kind = .mem },
                         .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
@@ -105227,18 +108361,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                         .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                         .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
                         .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ },
                         .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                         .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
-                        .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ },
+                        .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"8", .tmp0), ._, ._, ._ },
                         .{ ._, .fi_p, .st, .tmp4d, ._, ._, ._ },
                         .{ ._, ._, .mov, .tmp2d, .tmp4d, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp2w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                         .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                     } },
                 }, .{
@@ -105307,7 +108441,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
                         .unused,
                         .unused,
@@ -105322,11 +108456,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, .fi_p, .stt, .memia(.dst0d, .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"4", .tmp0), ._, ._, ._ },
+                        .{ ._, .fi_p, .stt, .memi(.dst0d, .tmp0), ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .x87, null, null, null },
@@ -105336,7 +108470,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .u16, .kind = .mem },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
                         .unused,
@@ -105356,11 +108490,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ },
                         .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                         .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp0b, ._, ._ },
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, .fi_p, .st, .memia(.dst0d, .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"4", .tmp0), ._, ._, ._ },
+                        .{ ._, .fi_p, .st, .memi(.dst0d, .tmp0), ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                         .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                     } },
                 }, .{
@@ -105371,7 +108505,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
                         .{ .type = .i64, .kind = .mem },
                         .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
@@ -105386,13 +108520,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"4", .tmp0), ._, ._, ._ },
                         .{ ._, .fi_p, .stt, .tmp2q, ._, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .tmp2d, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .x87, null, null, null },
@@ -105402,7 +108536,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .u16, .kind = .mem },
                         .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
@@ -105417,18 +108551,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                         .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                         .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
                         .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ },
                         .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                         .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
-                        .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ },
+                        .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"4", .tmp0), ._, ._, ._ },
                         .{ ._, .fi_p, .st, .tmp4q, ._, ._, ._ },
                         .{ ._, ._, .mov, .tmp2d, .tmp4d, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp2d, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                         .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                     } },
                 }, .{
@@ -105490,6 +108624,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .gnu,
                     .required_features = .{ .@"64bit", .sse3, .x87, null },
                     .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                     .dst_constraints = .{ .{ .exact_unsigned_int = 64 }, .any },
@@ -105526,6 +108661,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .gnu,
                     .required_features = .{ .@"64bit", .x87, null, null },
                     .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                     .dst_constraints = .{ .{ .exact_unsigned_int = 64 }, .any },
@@ -105568,6 +108704,49 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .@"or", .dst0q, .tmp5q, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .msvc,
+                    .required_features = .{ .@"64bit", .x87, null, null },
+                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
+                    .dst_constraints = .{ .{ .exact_unsigned_int = 64 }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .mem, .none, .none } },
+                        .{ .src = .{ .to_x87, .none, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
+                        .{ .type = .u16, .kind = .mem },
+                        .{ .type = .f32, .kind = .{ .@"0x1p63_mem" = .{} } },
+                        .{ .type = .i64, .kind = .mem },
+                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
+                        .{ ._, .f_, .ld, .tmp0t, ._, ._, ._ },
+                        .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ },
+                        .{ ._, ._, .movzx, .dst0d, .memd(.tmp2b, 1), ._, ._ },
+                        .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_11_11), ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
+                        .{ ._, ._, .mov, .memd(.tmp2b, 1), .dst0b, ._, ._ },
+                        .{ ._, ._, .lea, .dst0q, .mem(.tmp3), ._, ._ },
+                        .{ ._, .fi_p, .st, .tmp4q, ._, ._, ._ },
+                        .{ ._, .f_, .sub, .lea(.dst0d), ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp5q, .tmp4q, ._, ._ },
+                        .{ ._, .fi_p, .st, .tmp4q, ._, ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
+                        .{ ._, ._, .mov, .dst0q, .tmp5q, ._, ._ },
+                        .{ ._, ._r, .sa, .dst0q, .ui(63), ._, ._ },
+                        .{ ._, ._, .@"and", .dst0q, .tmp4q, ._, ._ },
+                        .{ ._, ._, .@"or", .dst0q, .tmp5q, ._, ._ },
+                    } },
+                }, .{
                     .required_features = .{ .sse3, .x87, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any },
@@ -105575,7 +108754,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
                         .unused,
                         .unused,
@@ -105590,11 +108769,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, .fi_p, .stt, .memia(.dst0q, .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"2", .tmp0), ._, ._, ._ },
+                        .{ ._, .fi_p, .stt, .memi(.dst0q, .tmp0), ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .x87, null, null, null },
@@ -105604,7 +108783,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .u16, .kind = .mem },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
                         .unused,
@@ -105624,15 +108803,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ },
                         .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                         .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp0b, ._, ._ },
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, .fi_p, .st, .memia(.dst0q, .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"2", .tmp0), ._, ._, ._ },
+                        .{ ._, .fi_p, .st, .memi(.dst0q, .tmp0), ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                         .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .avx, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                     .patterns = &.{
@@ -105640,11 +108820,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
-                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfti" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfdi" } },
+                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -105655,16 +108835,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                         .{ ._, .v_dqa, .mov, .tmp2x, .tmp1x, ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp4q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse2, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse2, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                     .patterns = &.{
@@ -105672,11 +108853,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
-                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfti" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfdi" } },
+                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -105687,16 +108868,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp4q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                     .patterns = &.{
@@ -105704,11 +108886,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
-                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfti" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfdi" } },
+                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -105719,16 +108901,48 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ps, .mova, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._ps, .mova, .tmp2x, .tmp1x, ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp4q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .avx, null, null },
+                    .required_cc_abi = .win64,
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfdi" } },
+                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"2", .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                     .dst_constraints = .{ .{ .signed_int = .xword }, .any },
                     .patterns = &.{
@@ -105736,7 +108950,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixxfti" } },
                         .unused,
@@ -105748,7 +108962,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg_pair = .{ .rax, .rdx } }, .unused },
+                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, .v_dqa, .mov, .tmp0x, .src0x, ._, ._ },
@@ -105756,7 +108970,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .avx, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                     .dst_constraints = .{ .{ .unsigned_int = .xword }, .any },
                     .patterns = &.{
@@ -105764,7 +108979,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfti" } },
                         .unused,
@@ -105776,7 +108991,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg_pair = .{ .rax, .rdx } }, .unused },
+                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, .v_dqa, .mov, .tmp0x, .src0x, ._, ._ },
@@ -105784,7 +108999,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse2, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse2, null, null, null },
                     .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                     .dst_constraints = .{ .{ .signed_int = .xword }, .any },
                     .patterns = &.{
@@ -105792,7 +109008,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixxfti" } },
                         .unused,
@@ -105804,7 +109020,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg_pair = .{ .rax, .rdx } }, .unused },
+                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ },
@@ -105812,7 +109028,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse2, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse2, null, null, null },
                     .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                     .dst_constraints = .{ .{ .unsigned_int = .xword }, .any },
                     .patterns = &.{
@@ -105820,7 +109037,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfti" } },
                         .unused,
@@ -105832,7 +109049,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg_pair = .{ .rax, .rdx } }, .unused },
+                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ },
@@ -105840,7 +109057,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                     .dst_constraints = .{ .{ .signed_int = .xword }, .any },
                     .patterns = &.{
@@ -105848,7 +109066,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixxfti" } },
                         .unused,
@@ -105860,7 +109078,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg_pair = .{ .rax, .rdx } }, .unused },
+                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._ps, .mova, .tmp0x, .src0x, ._, ._ },
@@ -105868,7 +109086,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                     .dst_constraints = .{ .{ .unsigned_int = .xword }, .any },
                     .patterns = &.{
@@ -105876,7 +109095,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfti" } },
                         .unused,
@@ -105888,7 +109107,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg_pair = .{ .rax, .rdx } }, .unused },
+                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._ps, .mova, .tmp0x, .src0x, ._, ._ },
@@ -105896,7 +109115,62 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .avx, null, null },
+                    .required_cc_abi = .win64,
+                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
+                    .dst_constraints = .{ .{ .signed_int = .xword }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixxfti" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
+                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
+                    .dst_constraints = .{ .{ .unsigned_int = .xword }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfti" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
+                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                     .patterns = &.{
@@ -105904,12 +109178,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixxfti" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
-                        .{ .type = .i64, .kind = .{ .reg = .rdx } },
+                        .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -105919,17 +109193,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, .v_dqa, .mov, .tmp2x, .tmp1x, ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4q, ._, ._ },
-                        .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp5q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp4q0, ._, ._ },
+                        .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp4q1, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .avx, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                     .patterns = &.{
@@ -105937,12 +109212,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfti" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
+                        .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -105952,17 +109227,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, .v_dqa, .mov, .tmp2x, .tmp1x, ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4q, ._, ._ },
-                        .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp5q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp4q0, ._, ._ },
+                        .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp4q1, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse2, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse2, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                     .patterns = &.{
@@ -105970,12 +109246,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixxfti" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
-                        .{ .type = .i64, .kind = .{ .reg = .rdx } },
+                        .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -105985,17 +109261,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4q, ._, ._ },
-                        .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp5q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp4q0, ._, ._ },
+                        .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp4q1, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse2, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse2, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                     .patterns = &.{
@@ -106003,12 +109280,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfti" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
+                        .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -106018,17 +109295,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4q, ._, ._ },
-                        .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp5q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp4q0, ._, ._ },
+                        .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp4q1, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                     .patterns = &.{
@@ -106036,12 +109314,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixxfti" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
-                        .{ .type = .i64, .kind = .{ .reg = .rdx } },
+                        .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -106051,17 +109329,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, ._ps, .mova, .tmp2x, .tmp1x, ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4q, ._, ._ },
-                        .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp5q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp4q0, ._, ._ },
+                        .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp4q1, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                     .patterns = &.{
@@ -106069,12 +109348,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfti" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
+                        .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -106084,17 +109363,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, ._ps, .mova, .tmp2x, .tmp1x, ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4q, ._, ._ },
-                        .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp5q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp4q0, ._, ._ },
+                        .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp4q1, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .avx, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                     .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                     .patterns = &.{
@@ -106102,9 +109382,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixxfei" } },
                         .unused,
@@ -106124,7 +109404,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .avx, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                     .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                     .patterns = &.{
@@ -106132,9 +109413,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfei" } },
                         .unused,
@@ -106154,7 +109435,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse2, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse2, null, null, null },
                     .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                     .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                     .patterns = &.{
@@ -106162,9 +109444,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixxfei" } },
                         .unused,
@@ -106184,7 +109466,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse2, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse2, null, null, null },
                     .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                     .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                     .patterns = &.{
@@ -106192,9 +109475,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfei" } },
                         .unused,
@@ -106214,7 +109497,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                     .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                     .patterns = &.{
@@ -106222,9 +109506,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixxfei" } },
                         .unused,
@@ -106244,7 +109528,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                     .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                     .patterns = &.{
@@ -106252,9 +109537,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfei" } },
                         .unused,
@@ -106274,7 +109559,66 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .avx, null, null },
+                    .required_cc_abi = .win64,
+                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
+                    .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixxfei" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .mem(.src0), ._, ._ },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
+                    .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfei" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .mem(.src0), ._, ._ },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                     .dst_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                     .patterns = &.{
@@ -106282,11 +109626,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixxfei" } },
                         .unused,
@@ -106297,19 +109641,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
-                        .{ .@"0:", .v_dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ .@"0:", .v_dqa, .mov, .tmp4x, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                         .{ ._, .v_dqa, .mov, .tmp5x, .tmp4x, ._, ._ },
                         .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .avx, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                     .dst_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                     .patterns = &.{
@@ -106317,11 +109662,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfei" } },
                         .unused,
@@ -106332,19 +109677,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
-                        .{ .@"0:", .v_dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ .@"0:", .v_dqa, .mov, .tmp4x, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                         .{ ._, .v_dqa, .mov, .tmp5x, .tmp4x, ._, ._ },
                         .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse2, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse2, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                     .dst_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                     .patterns = &.{
@@ -106352,11 +109698,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixxfei" } },
                         .unused,
@@ -106367,19 +109713,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
-                        .{ .@"0:", ._dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ .@"0:", ._dqa, .mov, .tmp4x, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                         .{ ._, ._dqa, .mov, .tmp5x, .tmp4x, ._, ._ },
                         .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse2, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse2, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                     .dst_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                     .patterns = &.{
@@ -106387,11 +109734,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfei" } },
                         .unused,
@@ -106402,19 +109749,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
-                        .{ .@"0:", ._dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ .@"0:", ._dqa, .mov, .tmp4x, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                         .{ ._, ._dqa, .mov, .tmp5x, .tmp4x, ._, ._ },
                         .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                     .dst_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                     .patterns = &.{
@@ -106422,11 +109770,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixxfei" } },
                         .unused,
@@ -106437,19 +109785,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
-                        .{ .@"0:", ._ps, .mova, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ .@"0:", ._ps, .mova, .tmp4x, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                         .{ ._, ._ps, .mova, .tmp5x, .tmp4x, ._, ._ },
                         .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                     .dst_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                     .patterns = &.{
@@ -106457,11 +109806,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfei" } },
                         .unused,
@@ -106472,16 +109821,84 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
-                        .{ .@"0:", ._ps, .mova, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ .@"0:", ._ps, .mova, .tmp4x, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                         .{ ._, ._ps, .mova, .tmp5x, .tmp4x, ._, ._ },
                         .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
+                    .dst_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixxfei" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
+                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp4p, .memi(.src0, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
+                    .dst_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfei" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
+                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp4p, .memi(.src0, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, .slow_incdec, null, null },
@@ -106493,10 +109910,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -106507,14 +109924,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .v_dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp4b, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ },
-                        .{ ._, ._, .add, .tmp1p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp4b, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -106526,10 +109943,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -106540,14 +109957,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .v_dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp4b, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ },
-                        .{ ._, ._c, .in, .tmp1p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp4b, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ },
+                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, .slow_incdec, null, null },
@@ -106559,10 +109976,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -106573,14 +109990,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp4b, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ },
-                        .{ ._, ._, .add, .tmp1p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp4b, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -106592,10 +110009,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -106606,14 +110023,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp4b, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ },
-                        .{ ._, ._c, .in, .tmp1p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp4b, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ },
+                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, .slow_incdec, null, null },
@@ -106625,10 +110042,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -106639,14 +110056,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._ps, .mova, .tmp2x, .lea(.tmp0x), ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp4b, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ },
-                        .{ ._, ._, .add, .tmp1p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp4b, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -106658,10 +110075,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -106672,14 +110089,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._ps, .mova, .tmp2x, .lea(.tmp0x), ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp4b, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ },
-                        .{ ._, ._c, .in, .tmp1p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp4b, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ },
+                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -106690,10 +110107,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -106705,12 +110122,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsi(.src0x, .@"8", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -106721,10 +110138,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -106736,12 +110153,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"8", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -106752,10 +110169,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -106767,19 +110184,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ps, .mova, .tmp1x, .memsi(.src0x, .@"8", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .float = .xword }, .any, .any },
                     .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -106795,7 +110212,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .eax }, .unused },
+                    .dst_temps = .{ .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
@@ -106805,7 +110222,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .src_constraints = .{ .{ .float = .xword }, .any, .any },
                     .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -106821,7 +110238,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .eax }, .unused },
+                    .dst_temps = .{ .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
@@ -106835,10 +110252,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -106850,12 +110267,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsi(.src0x, .@"4", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -106866,10 +110283,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfsi" } },
-                        .{ .type = .u32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -106881,12 +110298,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsi(.src0x, .@"4", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -106897,10 +110314,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -106912,12 +110329,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"4", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -106928,10 +110345,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfsi" } },
-                        .{ .type = .u32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -106943,12 +110360,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"4", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -106959,10 +110376,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } },
-                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -106974,12 +110391,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ps, .mova, .tmp1x, .memsi(.src0x, .@"4", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -106990,10 +110407,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfsi" } },
-                        .{ .type = .u32, .kind = .{ .reg = .eax } },
+                        .{ .type = .u32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -107005,19 +110422,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ps, .mova, .tmp1x, .memsi(.src0x, .@"4", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse, null, null },
                     .src_constraints = .{ .{ .float = .xword }, .any, .any },
                     .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -107033,7 +110450,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .rax }, .unused },
+                    .dst_temps = .{ .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
@@ -107043,7 +110460,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .src_constraints = .{ .{ .float = .xword }, .any, .any },
                     .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -107059,7 +110476,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .rax }, .unused },
+                    .dst_temps = .{ .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
@@ -107073,10 +110490,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixtfdi" } },
-                        .{ .type = .i64, .kind = .{ .reg = .rax } },
+                        .{ .type = .i64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -107088,12 +110505,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .avx, null, null },
@@ -107104,10 +110521,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfdi" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
+                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -107119,12 +110536,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse2, null, null },
@@ -107135,10 +110552,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixtfdi" } },
-                        .{ .type = .i64, .kind = .{ .reg = .rax } },
+                        .{ .type = .i64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -107150,12 +110567,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse2, null, null },
@@ -107166,10 +110583,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfdi" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
+                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -107181,12 +110598,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse, null, null },
@@ -107197,10 +110614,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixtfdi" } },
-                        .{ .type = .i64, .kind = .{ .reg = .rax } },
+                        .{ .type = .i64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -107212,12 +110629,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ps, .mova, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse, null, null },
@@ -107228,10 +110645,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfdi" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
+                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -107243,19 +110660,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ps, .mova, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .float = .xword }, .any, .any },
                     .dst_constraints = .{ .{ .signed_int = .xword }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -107271,17 +110689,45 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg_pair = .{ .rax, .rdx } }, .unused },
+                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .float = .xword }, .any, .any },
+                    .dst_constraints = .{ .{ .signed_int = .xword }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfti" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .float = .xword }, .any, .any },
                     .dst_constraints = .{ .{ .unsigned_int = .xword }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -107297,13 +110743,41 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg_pair = .{ .rax, .rdx } }, .unused },
+                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .avx, null, null },
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .float = .xword }, .any, .any },
+                    .dst_constraints = .{ .{ .unsigned_int = .xword }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfti" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                     .patterns = &.{
@@ -107311,11 +110785,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixtfti" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
-                        .{ .type = .i64, .kind = .{ .reg = .rdx } },
+                        .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -107326,16 +110800,49 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q0, ._, ._ },
+                        .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp3q1, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .avx, null, null },
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .avx, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfti" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                     .patterns = &.{
@@ -107343,11 +110850,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfti" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
+                        .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -107358,16 +110865,49 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q0, ._, ._ },
+                        .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp3q1, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse2, null, null },
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .avx, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfti" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse2, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                     .patterns = &.{
@@ -107375,11 +110915,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixtfti" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
-                        .{ .type = .i64, .kind = .{ .reg = .rdx } },
+                        .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -107390,16 +110930,49 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q0, ._, ._ },
+                        .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp3q1, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse2, null, null },
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse2, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfti" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse2, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                     .patterns = &.{
@@ -107407,11 +110980,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfti" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
+                        .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -107422,16 +110995,49 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q0, ._, ._ },
+                        .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp3q1, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse2, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfti" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                     .patterns = &.{
@@ -107439,11 +111045,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixtfti" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
-                        .{ .type = .i64, .kind = .{ .reg = .rdx } },
+                        .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -107454,16 +111060,49 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q0, ._, ._ },
+                        .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp3q1, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfti" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                     .patterns = &.{
@@ -107471,11 +111110,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfti" } },
-                        .{ .type = .u64, .kind = .{ .reg = .rax } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
+                        .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -107486,25 +111125,57 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
-                        .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q0, ._, ._ },
+                        .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp3q1, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfti" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse, null, null },
                     .src_constraints = .{ .{ .float = .xword }, .any, .any },
                     .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixtfei" } },
                         .unused,
                         .unused,
@@ -107527,12 +111198,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .src_constraints = .{ .{ .float = .xword }, .any, .any },
                     .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfei" } },
                         .unused,
                         .unused,
@@ -107559,11 +111230,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixtfei" } },
                         .unused,
                         .unused,
@@ -107574,15 +111245,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
-                        .{ ._, .v_dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, .v_dqa, .mov, .tmp4x, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .avx, null, null },
@@ -107593,11 +111264,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfei" } },
                         .unused,
                         .unused,
@@ -107608,15 +111279,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
-                        .{ ._, .v_dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, .v_dqa, .mov, .tmp4x, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse2, null, null },
@@ -107627,11 +111298,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixtfei" } },
                         .unused,
                         .unused,
@@ -107642,15 +111313,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
-                        .{ ._, ._dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._dqa, .mov, .tmp4x, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse2, null, null },
@@ -107661,11 +111332,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfei" } },
                         .unused,
                         .unused,
@@ -107676,15 +111347,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
-                        .{ ._, ._dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._dqa, .mov, .tmp4x, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse, null, null },
@@ -107695,11 +111366,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixtfei" } },
                         .unused,
                         .unused,
@@ -107710,15 +111381,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
-                        .{ ._, ._ps, .mova, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._ps, .mova, .tmp4x, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse, null, null },
@@ -107729,11 +111400,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfei" } },
                         .unused,
                         .unused,
@@ -107744,15 +111415,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
-                        .{ ._, ._ps, .mova, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._ps, .mova, .tmp4x, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 } }) catch |err| switch (err) {
                     error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{
@@ -107767,7 +111438,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
             },
             .int_from_float_safe => unreachable,
             .int_from_float_optimized_safe => unreachable,
-            .float_from_int => |air_tag| if (use_old) try cg.airFloatFromInt(inst) else {
+            .float_from_int => |air_tag| {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                 var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                 var res: [1]Temp = undefined;
@@ -107980,7 +111651,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
                     .dst_constraints = .{ .{ .float = .word }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .dil }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -107996,7 +111667,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .movsx, .src0d, .src0b, ._, ._ },
@@ -108007,7 +111678,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any },
                     .dst_constraints = .{ .{ .float = .word }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .dil }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -108023,7 +111694,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .movzx, .src0d, .src0b, ._, ._ },
@@ -108034,7 +111705,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .src_constraints = .{ .{ .signed_int = .word }, .any, .any },
                     .dst_constraints = .{ .{ .float = .word }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .di }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -108050,7 +111721,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .movsx, .src0d, .src0w, ._, ._ },
@@ -108061,7 +111732,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any },
                     .dst_constraints = .{ .{ .float = .word }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .di }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -108077,7 +111748,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .movzx, .src0d, .src0w, ._, ._ },
@@ -108088,7 +111759,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .src_constraints = .{ .{ .signed_int = .dword }, .any, .any },
                     .dst_constraints = .{ .{ .float = .word }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .edi }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -108104,7 +111775,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
@@ -108114,7 +111785,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any },
                     .dst_constraints = .{ .{ .float = .word }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .edi }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -108130,7 +111801,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
@@ -108140,7 +111811,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .src_constraints = .{ .{ .signed_int = .qword }, .any, .any },
                     .dst_constraints = .{ .{ .float = .word }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .rdi }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -108156,7 +111827,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
@@ -108166,7 +111837,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any },
                     .dst_constraints = .{ .{ .float = .word }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .rdi }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -108182,17 +111853,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .signed_int = .xword }, .any, .any },
                     .dst_constraints = .{ .{ .float = .word }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -108208,17 +111880,46 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .signed_int = .xword }, .any, .any },
+                    .dst_constraints = .{ .{ .float = .word }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floattihf" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
+                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any },
                     .dst_constraints = .{ .{ .float = .word }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -108234,12 +111935,40 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any },
+                    .dst_constraints = .{ .{ .float = .word }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntihf" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
+                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
+                    } },
+                }, .{
                     .required_features = .{ .@"64bit", .sse, null, null },
                     .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                     .dst_constraints = .{ .{ .float = .word }, .any },
@@ -108248,8 +111977,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floateihf" } },
                         .unused,
                         .unused,
@@ -108260,7 +111989,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
@@ -108276,8 +112005,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatuneihf" } },
                         .unused,
                         .unused,
@@ -108288,7 +112017,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
@@ -108359,7 +112088,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -108374,12 +112103,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .vp_d, .movsxb, .tmp1y, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .vp_d, .movsxb, .tmp1y, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, .v_ps, .cvtdq2, .tmp1y, .tmp1y, ._, ._ },
-                        .{ ._, .v_, .cvtps2ph, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_, .cvtps2ph, .memsi(.dst0x, .@"2", .tmp0), .tmp1y, .rm(.{}), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .f16c, null, null, null },
@@ -108389,7 +112118,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -108404,12 +112133,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .vp_d, .movsxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .vp_d, .movsxb, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, .v_ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, .v_, .cvtps2ph, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp1x, .rm(.{}), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_, .cvtps2ph, .memsi(.dst0q, .@"2", .tmp0), .tmp1x, .rm(.{}), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .f16c, .avx2, null, null },
@@ -108419,7 +112148,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -108434,12 +112163,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .vp_d, .movzxb, .tmp1y, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .vp_d, .movzxb, .tmp1y, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, .v_ps, .cvtdq2, .tmp1y, .tmp1y, ._, ._ },
-                        .{ ._, .v_, .cvtps2ph, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_, .cvtps2ph, .memsi(.dst0x, .@"2", .tmp0), .tmp1y, .rm(.{}), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .f16c, null, null, null },
@@ -108449,7 +112178,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -108464,12 +112193,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .vp_d, .movzxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .vp_d, .movzxb, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, .v_ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, .v_, .cvtps2ph, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp1x, .rm(.{}), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_, .cvtps2ph, .memsi(.dst0q, .@"2", .tmp0), .tmp1x, .rm(.{}), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, .slow_incdec, null, null },
@@ -108480,10 +112209,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -108495,12 +112224,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .vp_w, .extr, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .vp_w, .extr, .memsi(.dst0w, .@"2", .tmp0), .tmp3x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -108511,10 +112240,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -108526,12 +112255,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .vp_w, .extr, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .vp_w, .extr, .memsi(.dst0w, .@"2", .tmp0), .tmp3x, .ui(0), ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse4_1, .slow_incdec, null, null },
@@ -108542,10 +112271,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -108557,12 +112286,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .p_w, .extr, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .p_w, .extr, .memsi(.dst0w, .@"2", .tmp0), .tmp3x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse4_1, null, null, null },
@@ -108573,10 +112302,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -108588,12 +112317,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .p_w, .extr, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .p_w, .extr, .memsi(.dst0w, .@"2", .tmp0), .tmp3x, .ui(0), ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, .slow_incdec, null, null },
@@ -108604,10 +112333,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -108619,13 +112348,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0w, .@"2", .tmp0), .tmp1w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -108636,10 +112365,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -108651,13 +112380,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0w, .@"2", .tmp0), .tmp1w, ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, .slow_incdec, null, null },
@@ -108668,10 +112397,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f32, .kind = .mem },
                         .unused,
                         .unused,
@@ -108683,14 +112412,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ },
                         .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0w, .@"2", .tmp0), .tmp1w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -108701,10 +112430,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f32, .kind = .mem },
                         .unused,
                         .unused,
@@ -108716,14 +112445,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ },
                         .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0w, .@"2", .tmp0), .tmp1w, ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, .slow_incdec, null, null },
@@ -108734,10 +112463,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -108749,12 +112478,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .vp_w, .extr, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .vp_w, .extr, .memsi(.dst0w, .@"2", .tmp0), .tmp3x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -108765,10 +112494,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -108780,12 +112509,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .vp_w, .extr, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .vp_w, .extr, .memsi(.dst0w, .@"2", .tmp0), .tmp3x, .ui(0), ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse4_1, .slow_incdec, null, null },
@@ -108796,10 +112525,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -108811,12 +112540,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .p_w, .extr, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .p_w, .extr, .memsi(.dst0w, .@"2", .tmp0), .tmp3x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse4_1, null, null, null },
@@ -108827,10 +112556,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -108842,12 +112571,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .p_w, .extr, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .p_w, .extr, .memsi(.dst0w, .@"2", .tmp0), .tmp3x, .ui(0), ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, .slow_incdec, null, null },
@@ -108858,10 +112587,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -108873,13 +112602,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0w, .@"2", .tmp0), .tmp1w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -108890,10 +112619,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -108905,13 +112634,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0w, .@"2", .tmp0), .tmp1w, ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, .slow_incdec, null, null },
@@ -108922,10 +112651,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f32, .kind = .mem },
                         .unused,
                         .unused,
@@ -108937,14 +112666,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ },
                         .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0w, .@"2", .tmp0), .tmp1w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -108955,10 +112684,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f32, .kind = .mem },
                         .unused,
                         .unused,
@@ -108970,14 +112699,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ },
                         .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ },
-                        .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memsi(.dst0w, .@"2", .tmp0), .tmp1w, ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .f16c, null, null, null },
@@ -109043,7 +112772,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -109058,12 +112787,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .vp_d, .movsxw, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .vp_d, .movsxw, .tmp1y, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, .v_ps, .cvtdq2, .tmp1y, .tmp1y, ._, ._ },
-                        .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_, .cvtps2ph, .memi(.dst0x, .tmp0), .tmp1y, .rm(.{}), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .f16c, null, null, null },
@@ -109073,7 +112802,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -109088,12 +112817,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .vp_d, .movsxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .vp_d, .movsxw, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, .v_ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, .v_, .cvtps2ph, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, .rm(.{}), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_, .cvtps2ph, .memi(.dst0q, .tmp0), .tmp1x, .rm(.{}), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .f16c, .avx2, null, null },
@@ -109103,7 +112832,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -109118,12 +112847,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .vp_d, .movzxw, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .vp_d, .movzxw, .tmp1y, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, .v_ps, .cvtdq2, .tmp1y, .tmp1y, ._, ._ },
-                        .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_, .cvtps2ph, .memi(.dst0x, .tmp0), .tmp1y, .rm(.{}), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .f16c, null, null, null },
@@ -109133,7 +112862,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -109148,12 +112877,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .vp_d, .movzxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .vp_d, .movzxw, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, .v_ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, .v_, .cvtps2ph, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, .rm(.{}), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_, .cvtps2ph, .memi(.dst0q, .tmp0), .tmp1x, .rm(.{}), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -109164,10 +112893,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -109179,12 +112908,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse4_1, null, null, null },
@@ -109195,10 +112924,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -109210,12 +112939,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -109226,10 +112955,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -109241,13 +112970,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -109258,10 +112987,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f32, .kind = .mem },
                         .unused,
                         .unused,
@@ -109273,14 +113002,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ },
                         .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -109291,10 +113020,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -109306,12 +113035,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse4_1, null, null, null },
@@ -109322,10 +113051,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -109337,12 +113066,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -109353,10 +113082,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -109368,13 +113097,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -109385,10 +113114,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f32, .kind = .mem },
                         .unused,
                         .unused,
@@ -109400,14 +113129,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ },
                         .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .f16c, null, null, null },
@@ -109443,7 +113172,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -109458,11 +113187,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_ps, .cvtdq2, .tmp1y, .memsia(.src0y, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
+                        .{ .@"0:", .v_ps, .cvtdq2, .tmp1y, .memsi(.src0y, .@"2", .tmp0), ._, ._ },
+                        .{ ._, .v_, .cvtps2ph, .memi(.dst0x, .tmp0), .tmp1y, .rm(.{}), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .f16c, null, null, null },
@@ -109472,7 +113201,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -109487,11 +113216,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_ps, .cvtdq2, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, .v_, .cvtps2ph, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, .rm(.{}), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ },
+                        .{ .@"0:", .v_ps, .cvtdq2, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
+                        .{ ._, .v_, .cvtps2ph, .memi(.dst0q, .tmp0), .tmp1x, .rm(.{}), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -109502,10 +113231,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -109517,12 +113246,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1d, .memsi(.src0d, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse4_1, null, null, null },
@@ -109533,10 +113262,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -109548,12 +113277,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1d, .memsi(.src0d, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -109564,10 +113293,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -109579,13 +113308,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1d, .memsi(.src0d, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -109596,10 +113325,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f32, .kind = .mem },
                         .unused,
                         .unused,
@@ -109611,14 +113340,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1d, .memsi(.src0d, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ },
                         .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -109629,10 +113358,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -109644,12 +113373,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1d, .memsi(.src0d, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse4_1, null, null, null },
@@ -109660,10 +113389,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -109675,12 +113404,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1d, .memsi(.src0d, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -109691,10 +113420,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -109706,13 +113435,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1d, .memsi(.src0d, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -109723,10 +113452,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f32, .kind = .mem },
                         .unused,
                         .unused,
@@ -109738,14 +113467,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1d, .memsi(.src0d, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ },
                         .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .f16c, null, null },
@@ -109755,7 +113484,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -109770,13 +113499,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .v_ps, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
-                        .{ ._, .v_ss, .cvtsi2, .tmp1x, .tmp1x, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._ },
+                        .{ ._, .v_ss, .cvtsi2, .tmp1x, .tmp1x, .memsi(.src0q, .@"4", .tmp0), ._ },
                         .{ ._, .v_, .cvtps2ph, .tmp1q, .tmp1x, .rm(.{}), ._ },
-                        .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .avx, null, null },
@@ -109787,10 +113516,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i64, .kind = .{ .reg = .rdi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatdihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -109802,12 +113531,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse4_1, null, null },
@@ -109818,10 +113547,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i64, .kind = .{ .reg = .rdi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatdihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -109833,12 +113562,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse2, null, null },
@@ -109849,10 +113578,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i64, .kind = .{ .reg = .rdi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatdihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -109864,13 +113593,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse, null, null },
@@ -109881,10 +113610,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i64, .kind = .{ .reg = .rdi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatdihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f32, .kind = .mem },
                         .unused,
                         .unused,
@@ -109896,14 +113625,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ },
                         .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .avx, null, null },
@@ -109914,10 +113643,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatundihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -109929,12 +113658,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse4_1, null, null },
@@ -109945,10 +113674,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatundihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -109960,12 +113689,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse2, null, null },
@@ -109976,10 +113705,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatundihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -109991,13 +113720,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse, null, null },
@@ -110008,10 +113737,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatundihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f32, .kind = .mem },
                         .unused,
                         .unused,
@@ -110023,17 +113752,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ },
                         .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .avx, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                     .patterns = &.{
@@ -110041,11 +113771,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
-                        .{ .type = .i64, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floattihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -110056,16 +113786,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"8", .tmp0, .add_unaligned_size, 8), ._, ._ },
-                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4x, .ui(0), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"8", .tmp0, 8), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse4_1, null, null },
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                     .patterns = &.{
@@ -110073,11 +113804,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
-                        .{ .type = .i64, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floattihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -110088,16 +113819,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"8", .tmp0, .add_unaligned_size, 8), ._, ._ },
-                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4x, .ui(0), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse2, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse4_1, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                     .patterns = &.{
@@ -110105,11 +113836,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
-                        .{ .type = .i64, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floattihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -110120,17 +113851,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"8", .tmp0, .add_unaligned_size, 8), ._, ._ },
-                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, .p_w, .extr, .tmp1d, .tmp4x, .ui(0), ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"8", .tmp0, 8), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse4_1, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                     .patterns = &.{
@@ -110138,33 +113869,167 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
-                        .{ .type = .i64, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floattihf" } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse2, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floattihf" } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"8", .tmp0, 8), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .p_w, .extr, .tmp1d0, .tmp3x, .ui(0), ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w0, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse2, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floattihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floattihf" } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f32, .kind = .mem },
                         .unused,
                         .unused,
                         .unused,
                         .unused,
                         .unused,
+                        .unused,
                     },
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"8", .tmp0, .add_unaligned_size, 8), ._, ._ },
-                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, ._ss, .mov, .tmp5d, .tmp4d, ._, ._ },
-                        .{ ._, ._, .mov, .tmp1d, .tmp5d, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"8", .tmp0, 8), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._ss, .mov, .mem(.tmp4d), .tmp3x, ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d0, .mem(.tmp4d), ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w0, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .avx, null, null },
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floattihf" } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f32, .kind = .mem },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._ss, .mov, .mem(.tmp4d), .tmp3x, ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .mem(.tmp4d), ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                     .patterns = &.{
@@ -110172,11 +114037,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
-                        .{ .type = .u64, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatuntihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -110187,16 +114052,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"8", .tmp0, .add_unaligned_size, 8), ._, ._ },
-                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4x, .ui(0), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"8", .tmp0, 8), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse4_1, null, null },
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                     .patterns = &.{
@@ -110204,11 +114070,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
-                        .{ .type = .u64, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatuntihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -110219,16 +114085,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"8", .tmp0, .add_unaligned_size, 8), ._, ._ },
-                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4x, .ui(0), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse2, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse4_1, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                     .patterns = &.{
@@ -110236,11 +114102,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
-                        .{ .type = .u64, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatuntihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -110251,17 +114117,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"8", .tmp0, .add_unaligned_size, 8), ._, ._ },
-                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, .p_w, .extr, .tmp1d, .tmp4x, .ui(0), ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"8", .tmp0, 8), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse4_1, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                     .patterns = &.{
@@ -110269,30 +114135,163 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
-                        .{ .type = .u64, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatuntihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse2, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntihf" } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"8", .tmp0, 8), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .p_w, .extr, .tmp1d0, .tmp3x, .ui(0), ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w0, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse2, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntihf" } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntihf" } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f32, .kind = .mem },
                         .unused,
                         .unused,
                         .unused,
                         .unused,
                         .unused,
+                        .unused,
                     },
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"8", .tmp0, .add_unaligned_size, 8), ._, ._ },
-                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, ._ss, .mov, .tmp5d, .tmp4d, ._, ._ },
-                        .{ ._, ._, .mov, .tmp1d, .tmp5d, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"8", .tmp0, 8), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._ss, .mov, .mem(.tmp4d), .tmp3x, ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d0, .mem(.tmp4d), ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w0, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntihf" } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f32, .kind = .mem },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._ss, .mov, .mem(.tmp4d), .tmp3x, ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .mem(.tmp4d), ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .avx, null, null },
@@ -110304,11 +114303,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floateihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -110318,15 +114317,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp1, .add_unaligned_size), .tmp5x, .ui(0), ._ },
-                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp1p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp1), .tmp5x, .ui(0), ._ },
+                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse4_1, null, null },
@@ -110338,11 +114337,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floateihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -110352,15 +114351,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, .p_w, .extr, .memia(.dst0w, .tmp1, .add_unaligned_size), .tmp5x, .ui(0), ._ },
-                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp1p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp1), .tmp5x, .ui(0), ._ },
+                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse2, null, null },
@@ -110372,11 +114371,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floateihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -110386,16 +114385,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                         .{ ._, .p_w, .extr, .tmp2d, .tmp5x, .ui(0), ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp1, .add_unaligned_size), .tmp2w, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp1p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp1), .tmp2w, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse, null, null },
@@ -110407,11 +114406,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floateihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f32, .kind = .mem },
                         .unused,
                         .unused,
@@ -110421,17 +114420,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                         .{ ._, ._ss, .mov, .tmp6d, .tmp5d, ._, ._ },
                         .{ ._, ._, .mov, .tmp2d, .tmp6d, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp1, .add_unaligned_size), .tmp2w, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp1p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp1), .tmp2w, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .avx, null, null },
@@ -110443,11 +114442,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatuneihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -110457,15 +114456,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp1, .add_unaligned_size), .tmp5x, .ui(0), ._ },
-                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp1p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp1), .tmp5x, .ui(0), ._ },
+                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse4_1, null, null },
@@ -110477,11 +114476,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatuneihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -110491,15 +114490,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, .p_w, .extr, .memia(.dst0w, .tmp1, .add_unaligned_size), .tmp5x, .ui(0), ._ },
-                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp1p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp1), .tmp5x, .ui(0), ._ },
+                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse2, null, null },
@@ -110511,11 +114510,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatuneihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -110525,16 +114524,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                         .{ ._, .p_w, .extr, .tmp2d, .tmp5x, .ui(0), ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp1, .add_unaligned_size), .tmp2w, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp1p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp1), .tmp2w, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse, null, null },
@@ -110546,11 +114545,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatuneihf" } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f32, .kind = .mem },
                         .unused,
                         .unused,
@@ -110560,17 +114559,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                         .{ ._, ._ss, .mov, .tmp6d, .tmp5d, ._, ._ },
                         .{ ._, ._, .mov, .tmp2d, .tmp6d, ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp1, .add_unaligned_size), .tmp2w, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp1p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp1), .tmp2w, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -110965,11 +114964,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .@"1:", ._ss, .cvtsi2, .dst0x, .src0q, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .signed_int = .xword }, .any, .any },
                     .dst_constraints = .{ .{ .float = .dword }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -110985,17 +114985,46 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .signed_int = .xword }, .any, .any },
+                    .dst_constraints = .{ .{ .float = .dword }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floattisf" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
+                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any },
                     .dst_constraints = .{ .{ .float = .dword }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -111011,12 +115040,40 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any },
+                    .dst_constraints = .{ .{ .float = .dword }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntisf" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
+                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
+                    } },
+                }, .{
                     .required_features = .{ .@"64bit", .sse, null, null },
                     .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                     .dst_constraints = .{ .{ .float = .dword }, .any },
@@ -111025,8 +115082,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floateisf" } },
                         .unused,
                         .unused,
@@ -111037,7 +115094,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
@@ -111053,8 +115110,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatuneisf" } },
                         .unused,
                         .unused,
@@ -111065,7 +115122,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
@@ -111158,7 +115215,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -111173,12 +115230,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .vp_d, .movsxb, .tmp1y, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .vp_d, .movsxb, .tmp1y, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, .v_ps, .cvtdq2, .tmp1y, .tmp1y, ._, ._ },
-                        .{ ._, .v_ps, .mova, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_ps, .mova, .memsi(.dst0y, .@"4", .tmp0), .tmp1y, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -111188,7 +115245,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -111203,12 +115260,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .vp_d, .movsxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .vp_d, .movsxb, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, .v_ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, .v_ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_ps, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse4_1, null, null, null },
@@ -111218,7 +115275,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -111233,12 +115290,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .p_d, .movsxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .p_d, .movsxb, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, ._ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx2, null, null, null },
@@ -111248,7 +115305,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -111263,12 +115320,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .vp_d, .movzxb, .tmp1y, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .vp_d, .movzxb, .tmp1y, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, .v_ps, .cvtdq2, .tmp1y, .tmp1y, ._, ._ },
-                        .{ ._, .v_ps, .mova, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_ps, .mova, .memsi(.dst0y, .@"4", .tmp0), .tmp1y, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -111278,7 +115335,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -111293,12 +115350,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .vp_d, .movzxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .vp_d, .movzxb, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, .v_ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, .v_ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_ps, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse4_1, null, null, null },
@@ -111308,7 +115365,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -111323,12 +115380,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .p_d, .movzxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .p_d, .movzxb, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, ._ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, .slow_incdec, null, null },
@@ -111339,10 +115396,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsisf" } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -111354,12 +115411,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .v_ss, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_ss, .mov, .memsi(.dst0d, .@"4", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -111370,10 +115427,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsisf" } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -111385,12 +115442,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .v_ss, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_ss, .mov, .memsi(.dst0d, .@"4", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, .slow_incdec, null, null },
@@ -111401,10 +115458,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsisf" } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -111416,12 +115473,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._ss, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ss, .mov, .memsi(.dst0d, .@"4", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -111432,10 +115489,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsisf" } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -111447,12 +115504,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._ss, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ss, .mov, .memsi(.dst0d, .@"4", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, .slow_incdec, null, null },
@@ -111463,10 +115520,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsisf" } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -111478,12 +115535,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .v_ss, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_ss, .mov, .memsi(.dst0d, .@"4", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -111494,10 +115551,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsisf" } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -111509,12 +115566,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .v_ss, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_ss, .mov, .memsi(.dst0d, .@"4", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, .slow_incdec, null, null },
@@ -111525,10 +115582,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsisf" } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -111540,12 +115597,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._ss, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ss, .mov, .memsi(.dst0d, .@"4", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -111556,10 +115613,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsisf" } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -111571,12 +115628,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._ss, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ss, .mov, .memsi(.dst0d, .@"4", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -111664,7 +115721,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -111679,12 +115736,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .vp_d, .movsxw, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .vp_d, .movsxw, .tmp1y, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, .v_ps, .cvtdq2, .tmp1y, .tmp1y, ._, ._ },
-                        .{ ._, .v_ps, .mova, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_ps, .mova, .memsi(.dst0y, .@"2", .tmp0), .tmp1y, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -111694,7 +115751,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -111709,12 +115766,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .vp_d, .movsxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .vp_d, .movsxw, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, .v_ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, .v_ps, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_ps, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse4_1, null, null, null },
@@ -111724,7 +115781,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -111739,12 +115796,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .p_d, .movsxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .p_d, .movsxw, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, ._ps, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx2, null, null, null },
@@ -111754,7 +115811,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -111769,12 +115826,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .vp_d, .movzxw, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .vp_d, .movzxw, .tmp1y, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, .v_ps, .cvtdq2, .tmp1y, .tmp1y, ._, ._ },
-                        .{ ._, .v_ps, .mova, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_ps, .mova, .memsi(.dst0y, .@"2", .tmp0), .tmp1y, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -111784,7 +115841,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -111799,12 +115856,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .vp_d, .movzxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .vp_d, .movzxw, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, .v_ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, .v_ps, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_ps, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse4_1, null, null, null },
@@ -111814,7 +115871,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -111829,12 +115886,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .p_d, .movzxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .p_d, .movzxw, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, ._ps, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -111845,10 +115902,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsisf" } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -111860,12 +115917,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .v_ss, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_ss, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -111876,10 +115933,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsisf" } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -111891,12 +115948,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._ss, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ss, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -111907,10 +115964,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsisf" } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -111922,12 +115979,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .v_ss, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_ss, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -111938,10 +115995,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsisf" } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -111953,12 +116010,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._ss, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ss, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -112004,7 +116061,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -112019,11 +116076,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_ps, .cvtdq2, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .v_ps, .cvtdq2, .tmp1y, .memi(.src0y, .tmp0), ._, ._ },
+                        .{ ._, .v_ps, .mova, .memi(.dst0y, .tmp0), .tmp1y, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -112033,7 +116090,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -112048,11 +116105,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_ps, .cvtdq2, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, .v_ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
+                        .{ .@"0:", .v_ps, .cvtdq2, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
+                        .{ ._, .v_ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -112062,7 +116119,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -112077,11 +116134,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ps, .cvtdq2, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
+                        .{ .@"0:", ._ps, .cvtdq2, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
+                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -112091,7 +116148,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -112106,11 +116163,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ss, .cvtsi2, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ss, .cvtsi2, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
+                        .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -112121,10 +116178,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsisf" } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -112136,12 +116193,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -112152,10 +116209,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsisf" } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -112167,12 +116224,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -112183,10 +116240,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsisf" } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -112198,12 +116255,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -112214,10 +116271,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsisf" } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -112229,12 +116286,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .avx, null, null },
@@ -112244,7 +116301,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -112259,12 +116316,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .v_ps, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
-                        .{ ._, .v_ss, .cvtsi2, .tmp1x, .tmp1x, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._ },
-                        .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_ss, .cvtsi2, .tmp1x, .tmp1x, .memsi(.src0q, .@"2", .tmp0), ._ },
+                        .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse, null, null },
@@ -112274,7 +116331,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -112289,12 +116346,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, ._ss, .cvtsi2, .tmp1x, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ss, .cvtsi2, .tmp1x, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
+                        .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .avx, null, null },
@@ -112305,10 +116362,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i64, .kind = .{ .reg = .rdi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatdisf" } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -112320,12 +116377,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse, null, null },
@@ -112336,10 +116393,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i64, .kind = .{ .reg = .rdi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatdisf" } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -112351,12 +116408,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .avx, null, null },
@@ -112367,10 +116424,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatundisf" } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -112382,12 +116439,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse, null, null },
@@ -112398,10 +116455,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatundisf" } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -112413,15 +116470,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .avx, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                     .patterns = &.{
@@ -112429,11 +116487,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
-                        .{ .type = .i64, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floattisf" } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -112444,16 +116502,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"4", .tmp0, .add_unaligned_size, 8), ._, ._ },
-                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"4", .tmp0, 8), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                     .patterns = &.{
@@ -112461,11 +116520,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
-                        .{ .type = .i64, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floattisf" } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -112476,16 +116535,81 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"4", .tmp0, .add_unaligned_size, 8), ._, ._ },
-                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"4", .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .avx, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floattisf" } },
+                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"4", .tmp0, 8), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floattisf" } },
+                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"4", .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                     .patterns = &.{
@@ -112493,11 +116617,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
-                        .{ .type = .u64, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatuntisf" } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -112508,16 +116632,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"4", .tmp0, .add_unaligned_size, 8), ._, ._ },
-                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"4", .tmp0, 8), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                     .patterns = &.{
@@ -112525,11 +116650,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
-                        .{ .type = .u64, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatuntisf" } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -112540,13 +116665,77 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"4", .tmp0, .add_unaligned_size, 8), ._, ._ },
-                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"4", .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntisf" } },
+                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"4", .tmp0, 8), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntisf" } },
+                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"4", .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .avx, null, null },
@@ -112558,11 +116747,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floateisf" } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -112572,15 +116761,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp1p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp1), .tmp5x, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse, null, null },
@@ -112592,11 +116781,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floateisf" } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -112606,15 +116795,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, ._ss, .mov, .memia(.dst0d, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp1p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ss, .mov, .memi(.dst0d, .tmp1), .tmp5x, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .avx, null, null },
@@ -112626,11 +116815,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatuneisf" } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -112640,15 +116829,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp1p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp1), .tmp5x, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse, null, null },
@@ -112660,11 +116849,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatuneisf" } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -112674,15 +116863,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, ._ss, .mov, .memia(.dst0d, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp1p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ss, .mov, .memi(.dst0d, .tmp1), .tmp5x, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -113295,11 +117484,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .@"0:", .f_p, .st, .dst0q, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .signed_int = .xword }, .any, .any },
                     .dst_constraints = .{ .{ .float = .qword }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -113315,17 +117505,46 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .signed_int = .xword }, .any, .any },
+                    .dst_constraints = .{ .{ .float = .qword }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floattidf" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
+                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any },
                     .dst_constraints = .{ .{ .float = .qword }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -113341,12 +117560,40 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any },
+                    .dst_constraints = .{ .{ .float = .qword }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntidf" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
+                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
+                    } },
+                }, .{
                     .required_features = .{ .@"64bit", .sse, null, null },
                     .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                     .dst_constraints = .{ .{ .float = .qword }, .any },
@@ -113355,8 +117602,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floateidf" } },
                         .unused,
                         .unused,
@@ -113367,7 +117614,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
@@ -113383,8 +117630,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatuneidf" } },
                         .unused,
                         .unused,
@@ -113395,7 +117642,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
@@ -113488,7 +117735,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -113503,12 +117750,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .vp_d, .movsxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .vp_d, .movsxb, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, .v_pd, .cvtdq2, .tmp1y, .tmp1x, ._, ._ },
-                        .{ ._, .v_pd, .mova, .memsia(.dst0y, .@"8", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_pd, .mova, .memsi(.dst0y, .@"8", .tmp0), .tmp1y, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -113518,7 +117765,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -113533,14 +117780,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_size), ._, ._ },
                         .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
-                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
+                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                         .{ ._, .vp_d, .movsxb, .tmp1x, .tmp1d, ._, ._ },
                         .{ ._, .v_pd, .cvtdq2, .tmp1x, .tmp1q, ._, ._ },
-                        .{ ._, .v_pd, .mova, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_pd, .mova, .memsi(.dst0x, .@"8", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse4_1, null, null, null },
@@ -113550,7 +117797,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -113565,14 +117812,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_size), ._, ._ },
                         .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+                        .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                         .{ ._, .p_d, .movsxb, .tmp1x, .tmp1d, ._, ._ },
                         .{ ._, ._pd, .cvtdq2, .tmp1x, .tmp1q, ._, ._ },
-                        .{ ._, ._pd, .mova, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._pd, .mova, .memsi(.dst0x, .@"8", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx2, null, null, null },
@@ -113582,7 +117829,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -113597,12 +117844,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .vp_d, .movzxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .vp_d, .movzxb, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, .v_pd, .cvtdq2, .tmp1y, .tmp1x, ._, ._ },
-                        .{ ._, .v_pd, .mova, .memsia(.dst0y, .@"8", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_pd, .mova, .memsi(.dst0y, .@"8", .tmp0), .tmp1y, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -113612,7 +117859,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -113627,14 +117874,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_size), ._, ._ },
                         .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
-                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
+                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                         .{ ._, .vp_d, .movzxb, .tmp1x, .tmp1d, ._, ._ },
                         .{ ._, .v_pd, .cvtdq2, .tmp1x, .tmp1q, ._, ._ },
-                        .{ ._, .v_pd, .mova, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_pd, .mova, .memsi(.dst0x, .@"8", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse4_1, null, null, null },
@@ -113644,7 +117891,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -113659,14 +117906,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_size), ._, ._ },
                         .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+                        .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                         .{ ._, .p_d, .movzxb, .tmp1x, .tmp1d, ._, ._ },
                         .{ ._, ._pd, .cvtdq2, .tmp1x, .tmp1q, ._, ._ },
-                        .{ ._, ._pd, .mova, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._pd, .mova, .memsi(.dst0x, .@"8", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, .slow_incdec, null, null },
@@ -113677,10 +117924,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -113692,12 +117939,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .v_sd, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_sd, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -113708,10 +117955,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -113723,12 +117970,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .v_sd, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_sd, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, .slow_incdec, null, null },
@@ -113739,10 +117986,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -113754,12 +118001,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._sd, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._sd, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -113770,10 +118017,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -113785,12 +118032,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._sd, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._sd, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, .slow_incdec, null, null },
@@ -113801,10 +118048,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -113816,12 +118063,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._ps, .movl, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ps, .movl, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -113832,10 +118079,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -113847,12 +118094,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._ps, .movl, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ps, .movl, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, .slow_incdec, null, null },
@@ -113863,10 +118110,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -113878,12 +118125,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .v_sd, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_sd, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -113894,10 +118141,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -113909,12 +118156,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .v_sd, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_sd, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, .slow_incdec, null, null },
@@ -113925,10 +118172,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -113940,12 +118187,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._sd, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._sd, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -113956,10 +118203,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -113971,12 +118218,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._sd, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._sd, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, .slow_incdec, null, null },
@@ -113987,10 +118234,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -114002,12 +118249,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._ps, .movl, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ps, .movl, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -114018,10 +118265,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -114033,12 +118280,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._ps, .movl, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ps, .movl, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -114126,7 +118373,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -114141,12 +118388,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .vp_d, .movsxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .vp_d, .movsxw, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, .v_pd, .cvtdq2, .tmp1y, .tmp1x, ._, ._ },
-                        .{ ._, .v_ps, .mova, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_pd, .mova, .memsi(.dst0y, .@"4", .tmp0), .tmp1y, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -114156,7 +118403,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -114171,13 +118418,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_d, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .v_d, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, .vp_d, .movsxw, .tmp1x, .tmp1q, ._, ._ },
                         .{ ._, .v_pd, .cvtdq2, .tmp1x, .tmp1q, ._, ._ },
-                        .{ ._, .v_ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_pd, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse4_1, null, null, null },
@@ -114187,7 +118434,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -114202,13 +118449,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._d, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", ._d, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, .p_d, .movsxw, .tmp1x, .tmp1q, ._, ._ },
                         .{ ._, ._pd, .cvtdq2, .tmp1x, .tmp1q, ._, ._ },
-                        .{ ._, ._ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._pd, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx2, null, null, null },
@@ -114218,7 +118465,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -114233,12 +118480,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .vp_d, .movzxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .vp_d, .movzxw, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, .v_pd, .cvtdq2, .tmp1y, .tmp1x, ._, ._ },
-                        .{ ._, .v_ps, .mova, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_pd, .mova, .memsi(.dst0y, .@"4", .tmp0), .tmp1y, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -114248,7 +118495,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -114263,13 +118510,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_d, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .v_d, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, .vp_d, .movzxw, .tmp1x, .tmp1q, ._, ._ },
                         .{ ._, .v_pd, .cvtdq2, .tmp1x, .tmp1q, ._, ._ },
-                        .{ ._, .v_ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_pd, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse4_1, null, null, null },
@@ -114279,7 +118526,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -114294,13 +118541,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._d, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", ._d, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, .p_d, .movzxw, .tmp1x, .tmp1q, ._, ._ },
                         .{ ._, ._pd, .cvtdq2, .tmp1x, .tmp1q, ._, ._ },
-                        .{ ._, ._ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._pd, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -114311,10 +118558,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -114326,12 +118573,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .v_sd, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_sd, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -114342,10 +118589,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -114357,12 +118604,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._sd, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._sd, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -114373,10 +118620,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -114388,12 +118635,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._ps, .movl, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ps, .movl, .memsi(.dst0q, .@"4", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -114404,10 +118651,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -114419,12 +118666,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .v_sd, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_sd, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -114435,10 +118682,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -114450,12 +118697,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._sd, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._sd, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -114466,10 +118713,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -114481,12 +118728,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._ps, .movl, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ps, .movl, .memsi(.dst0q, .@"4", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -114532,7 +118779,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -114547,11 +118794,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_pd, .cvtdq2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, .v_pd, .mova, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .v_pd, .cvtdq2, .tmp1y, .memi(.src0x, .tmp0), ._, ._ },
+                        .{ ._, .v_pd, .mova, .memsi(.dst0y, .@"2", .tmp0), .tmp1y, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -114561,7 +118808,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -114576,11 +118823,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_pd, .cvtdq2, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, .v_pd, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .v_pd, .cvtdq2, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
+                        .{ ._, .v_pd, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -114590,7 +118837,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -114605,11 +118852,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._pd, .cvtdq2, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._pd, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", ._pd, .cvtdq2, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
+                        .{ ._, ._pd, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -114620,10 +118867,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -114635,12 +118882,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .v_sd, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_sd, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -114651,10 +118898,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -114666,12 +118913,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._sd, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._sd, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -114682,10 +118929,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -114697,12 +118944,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._ps, .movl, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ps, .movl, .memsi(.dst0q, .@"2", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -114713,10 +118960,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -114728,12 +118975,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .v_sd, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_sd, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -114744,10 +118991,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -114759,12 +119006,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._sd, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._sd, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -114775,10 +119022,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -114790,12 +119037,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._ps, .movl, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ps, .movl, .memsi(.dst0q, .@"2", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .avx, null, null },
@@ -114805,7 +119052,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f64, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -114820,12 +119067,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .v_pd, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
-                        .{ ._, .v_sd, .cvtsi2, .tmp1x, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._ },
-                        .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_sd, .cvtsi2, .tmp1x, .tmp1x, .memi(.src0q, .tmp0), ._ },
+                        .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse2, null, null },
@@ -114835,7 +119082,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f64, .kind = .{ .rc = .sse } },
                         .unused,
                         .unused,
@@ -114850,12 +119097,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._pd, .xor, .tmp1x, .tmp1x, ._, ._ },
-                        .{ ._, ._sd, .cvtsi2, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._sd, .cvtsi2, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
+                        .{ ._, ._sd, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .avx, null, null },
@@ -114866,10 +119113,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i64, .kind = .{ .reg = .rdi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatdidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -114881,12 +119128,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse2, null, null },
@@ -114897,10 +119144,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i64, .kind = .{ .reg = .rdi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatdidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -114912,12 +119159,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse, null, null },
@@ -114928,10 +119175,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i64, .kind = .{ .reg = .rdi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatdidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -114943,12 +119190,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ps, .movl, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .avx, null, null },
@@ -114959,10 +119206,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatundidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -114974,12 +119221,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse2, null, null },
@@ -114990,10 +119237,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatundidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -115005,12 +119252,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse, null, null },
@@ -115021,10 +119268,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatundidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -115036,15 +119283,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ps, .movl, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .avx, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                     .patterns = &.{
@@ -115052,11 +119300,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
-                        .{ .type = .i64, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floattidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -115067,16 +119315,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"2", .tmp0, .add_unaligned_size, 8), ._, ._ },
-                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"2", .tmp0, 8), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse2, null, null },
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                     .patterns = &.{
@@ -115084,11 +119333,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
-                        .{ .type = .i64, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floattidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -115099,16 +119348,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"2", .tmp0, .add_unaligned_size, 8), ._, ._ },
-                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"2", .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse2, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                     .patterns = &.{
@@ -115116,11 +119365,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
-                        .{ .type = .i64, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floattidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -115131,16 +119380,114 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"2", .tmp0, .add_unaligned_size, 8), ._, ._ },
-                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"2", .tmp0, 8), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .avx, null, null },
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse2, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floattidf" } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"2", .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floattidf" } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"2", .tmp0, 8), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._ps, .movl, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floattidf" } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"2", .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._ps, .movl, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                     .patterns = &.{
@@ -115148,11 +119495,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
-                        .{ .type = .u64, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatuntidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -115163,16 +119510,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"2", .tmp0, .add_unaligned_size, 8), ._, ._ },
-                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"2", .tmp0, 8), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse2, null, null },
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                     .patterns = &.{
@@ -115180,11 +119528,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
-                        .{ .type = .u64, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatuntidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -115195,16 +119543,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"2", .tmp0, .add_unaligned_size, 8), ._, ._ },
-                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"2", .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse2, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                     .patterns = &.{
@@ -115212,11 +119560,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
-                        .{ .type = .u64, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatuntidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -115227,13 +119575,110 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"2", .tmp0, .add_unaligned_size, 8), ._, ._ },
-                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"2", .tmp0, 8), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse2, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntidf" } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"2", .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntidf" } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"2", .tmp0, 8), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._ps, .movl, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0p, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntidf" } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"2", .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._ps, .movl, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0p, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .avx, null, null },
@@ -115245,11 +119690,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floateidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -115259,15 +119704,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp1p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp1), .tmp5x, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse2, null, null },
@@ -115279,11 +119724,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floateidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -115293,15 +119738,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, ._sd, .mov, .memia(.dst0q, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp1p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._sd, .mov, .memi(.dst0q, .tmp1), .tmp5x, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse, null, null },
@@ -115313,11 +119758,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floateidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -115327,15 +119772,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, ._ps, .movl, .memia(.dst0q, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp1p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ps, .movl, .memi(.dst0q, .tmp1), .tmp5x, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .avx, null, null },
@@ -115347,11 +119792,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatuneidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -115361,15 +119806,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp1p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp1), .tmp5x, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse2, null, null },
@@ -115381,11 +119826,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatuneidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -115395,15 +119840,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, ._sd, .mov, .memia(.dst0q, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp1p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._sd, .mov, .memi(.dst0q, .tmp1), .tmp5x, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse, null, null },
@@ -115415,11 +119860,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatuneidf" } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -115429,15 +119874,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, ._ps, .movl, .memia(.dst0q, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp1p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ps, .movl, .memi(.dst0q, .tmp1), .tmp5x, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .x87, null, null, null },
@@ -115627,6 +120072,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_abi = .gnu,
                     .required_features = .{ .x87, null, null, null },
                     .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any },
                     .dst_constraints = .{ .{ .float = .tbyte }, .any },
@@ -115634,10 +120080,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
+                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u1, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_2_f32, .kind = .f32_0_0x1p64_mem },
-                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                        .{ .type = .u1, .kind = .{ .rc = .general_purpose } },
                         .unused,
                         .unused,
                         .unused,
@@ -115650,18 +120096,56 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
                         .{ ._, .fi_, .ld, .src0q, ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ },
+                        .{ ._, ._, .mov, .tmp3d, .memd(.src0d, 4), ._, ._ },
+                        .{ ._, ._r, .sh, .tmp3d, .ui(31), ._, ._ },
+                        .{ ._, .f_, .add, .leasi(.tmp1d, .@"4", .tmp3), ._, ._, ._ },
+                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_abi = .msvc,
+                    .required_features = .{ .x87, null, null, null },
+                    .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any },
+                    .dst_constraints = .{ .{ .float = .tbyte }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                        .{ .type = .u1, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u16, .kind = .mem },
+                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .vector_2_f32, .kind = .f32_0_0x1p64_mem },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, .fi_, .ld, .src0q, ._, ._, ._ },
                         .{ ._, ._, .mov, .tmp1d, .memd(.src0d, 4), ._, ._ },
                         .{ ._, ._r, .sh, .tmp1d, .ui(31), ._, ._ },
-                        .{ ._, .f_, .add, .leasi(.tmp0d, .@"4", .tmp1), ._, ._, ._ },
+                        .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ },
+                        .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ },
+                        .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_00_11), ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
+                        .{ ._, ._, .mov, .memd(.tmp2b, 1), .tmp3b, ._, ._ },
+                        .{ ._, ._, .lea, .tmp3p, .mem(.tmp4), ._, ._ },
+                        .{ ._, .f_, .add, .leasi(.tmp3d, .@"4", .tmp1), ._, ._, ._ },
+                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                         .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .signed_int = .xword }, .any, .any },
                     .dst_constraints = .{ .{ .float = .tbyte }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -115683,11 +120167,40 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .win64,
+                    .src_constraints = .{ .{ .signed_int = .xword }, .any, .any },
+                    .dst_constraints = .{ .{ .float = .tbyte }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floattixf" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any },
                     .dst_constraints = .{ .{ .float = .tbyte }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -115709,7 +120222,36 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .win64,
+                    .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any },
+                    .dst_constraints = .{ .{ .float = .tbyte }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntixf" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                     .dst_constraints = .{ .{ .float = .tbyte }, .any },
                     .patterns = &.{
@@ -115717,8 +120259,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floateixf" } },
                         .unused,
                         .unused,
@@ -115737,7 +120279,38 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
+                    .dst_constraints = .{ .{ .float = .tbyte }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floateixf" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_bit_size), ._, ._ },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                     .dst_constraints = .{ .{ .float = .tbyte }, .any },
                     .patterns = &.{
@@ -115745,8 +120318,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatuneixf" } },
                         .unused,
                         .unused,
@@ -115765,6 +120338,36 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
+                    .dst_constraints = .{ .{ .float = .tbyte }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuneixf" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_bit_size), ._, ._ },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                    } },
+                }, .{
                     .required_features = .{ .x87, .slow_incdec, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
@@ -115772,7 +120375,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .i16, .kind = .mem },
@@ -115787,15 +120390,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .mov, .tmp3w, .tmp2w, ._, ._ },
                         .{ ._, .fi_, .ld, .tmp3w, ._, ._, ._ },
                         .{ ._, .f_p, .st, .lea(.tmp1t), ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .x87, null, null, null },
@@ -115805,7 +120408,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .i16, .kind = .mem },
@@ -115820,15 +120423,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .mov, .tmp3w, .tmp2w, ._, ._ },
                         .{ ._, .fi_, .ld, .tmp3w, ._, ._, ._ },
                         .{ ._, .f_p, .st, .lea(.tmp1t), ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .x87, .slow_incdec, null, null },
@@ -115838,7 +120441,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .i16, .kind = .mem },
@@ -115853,15 +120456,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .mov, .tmp3w, .tmp2w, ._, ._ },
                         .{ ._, .fi_, .ld, .tmp3w, ._, ._, ._ },
                         .{ ._, .f_p, .st, .lea(.tmp1t), ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .x87, null, null, null },
@@ -115871,7 +120474,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .i16, .kind = .mem },
@@ -115886,17 +120489,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .mov, .tmp3w, .tmp2w, ._, ._ },
                         .{ ._, .fi_, .ld, .tmp3w, ._, ._, ._ },
                         .{ ._, .f_p, .st, .lea(.tmp1t), ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .x87, .slow_incdec, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
@@ -115905,9 +120509,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsixf" } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
                         .unused,
@@ -115920,17 +120524,52 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                         .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                         .{ ._, .f_p, .st, .lea(.tmp1t), ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .slow_incdec, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsixf" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
+                        .{ ._, ._, .movsx, .tmp3d, .memi(.src0b, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .x87, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
@@ -115939,9 +120578,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsixf" } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
                         .unused,
@@ -115954,17 +120593,51 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                         .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                         .{ ._, .f_p, .st, .lea(.tmp1t), ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .win64,
+                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsixf" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
+                        .{ ._, ._, .movsx, .tmp3d, .memi(.src0b, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .x87, .slow_incdec, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
@@ -115973,9 +120646,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsixf" } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
                         .unused,
@@ -115988,17 +120661,52 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                         .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                         .{ ._, .f_p, .st, .lea(.tmp1t), ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .slow_incdec, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsixf" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
+                        .{ ._, ._, .movzx, .tmp3d, .memi(.src0b, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .x87, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
@@ -116007,9 +120715,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsixf" } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
                         .unused,
@@ -116022,15 +120730,48 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                         .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                         .{ ._, .f_p, .st, .lea(.tmp1t), ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsixf" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
+                        .{ ._, ._, .movzx, .tmp3d, .memi(.src0b, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .x87, null, null, null },
@@ -116040,7 +120781,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
                         .unused,
                         .unused,
@@ -116055,13 +120796,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .fi_, .ld, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, .f_p, .st, .memsia(.dst0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .fi_, .ld, .memi(.src0w, .tmp0), ._, ._, ._ },
+                        .{ ._, .f_p, .st, .memsi(.dst0t, .@"8", .tmp0), ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .x87, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
@@ -116070,8 +120812,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsixf" } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
                         .unused,
@@ -116085,15 +120827,47 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
-                        .{ ._, .f_p, .st, .memsia(.dst0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .f_p, .st, .memsi(.dst0t, .@"8", .tmp0), ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .win64,
+                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsixf" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.dst0, .@"8", .tmp0), ._, ._ },
+                        .{ ._, ._, .movsx, .tmp2d, .memi(.src0w, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .x87, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
@@ -116102,8 +120876,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsixf" } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
                         .unused,
@@ -116117,13 +120891,44 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
-                        .{ ._, .f_p, .st, .memsia(.dst0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .f_p, .st, .memsi(.dst0t, .@"8", .tmp0), ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsixf" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.dst0, .@"8", .tmp0), ._, ._ },
+                        .{ ._, ._, .movzx, .tmp2d, .memi(.src0w, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .x87, null, null, null },
@@ -116133,7 +120938,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
                         .unused,
                         .unused,
@@ -116148,13 +120953,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .fi_, .ld, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, .f_p, .st, .memsia(.dst0t, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .fi_, .ld, .memi(.src0d, .tmp0), ._, ._, ._ },
+                        .{ ._, .f_p, .st, .memsi(.dst0t, .@"4", .tmp0), ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .x87, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
@@ -116163,8 +120969,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsixf" } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
                         .unused,
@@ -116178,15 +120984,47 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
-                        .{ ._, .f_p, .st, .memsia(.dst0t, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .f_p, .st, .memsi(.dst0t, .@"4", .tmp0), ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .win64,
+                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsixf" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.dst0, .@"4", .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp2d, .memi(.src0d, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .x87, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
@@ -116195,8 +121033,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsixf" } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
                         .unused,
@@ -116210,13 +121048,44 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
-                        .{ ._, .f_p, .st, .memsia(.dst0t, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .f_p, .st, .memsi(.dst0t, .@"4", .tmp0), ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsixf" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.dst0, .@"4", .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp2d, .memi(.src0d, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .x87, null, null, null },
@@ -116226,7 +121095,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .none, .none } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
                         .unused,
                         .unused,
@@ -116241,14 +121110,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .fi_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, .f_p, .st, .memsia(.dst0t, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .fi_, .ld, .memi(.src0q, .tmp0), ._, ._, ._ },
+                        .{ ._, .f_p, .st, .memsi(.dst0t, .@"2", .tmp0), ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .x87, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .x87, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                     .patterns = &.{
@@ -116256,8 +121126,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i64, .kind = .{ .reg = .rdi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatdixf" } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
                         .unused,
@@ -116271,16 +121141,48 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
-                        .{ ._, .f_p, .st, .memsia(.dst0t, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .f_p, .st, .memsi(.dst0t, .@"2", .tmp0), ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .x87, null, null },
+                    .required_cc_abi = .win64,
+                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floatdixf" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.dst0, .@"2", .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp2q, .memi(.src0q, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .x87, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                     .patterns = &.{
@@ -116288,8 +121190,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatundixf" } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
                         .unused,
@@ -116303,16 +121205,48 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
-                        .{ ._, .f_p, .st, .memsia(.dst0t, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .f_p, .st, .memsi(.dst0t, .@"2", .tmp0), ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .x87, null, null },
+                    .required_cc_abi = .win64,
+                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floatundixf" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.dst0, .@"2", .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp2q, .memi(.src0q, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .x87, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                     .patterns = &.{
@@ -116320,9 +121254,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
-                        .{ .type = .i64, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floattixf" } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
                         .unused,
@@ -116331,21 +121264,54 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                         .unused,
+                        .unused,
                     },
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ },
-                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q0, .memi(.src0q, .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1q1, .memid(.src0q, .tmp0, 8), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
-                        .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .f_p, .st, .memi(.dst0t, .tmp0), ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .x87, null, null },
+                    .required_cc_abi = .win64,
+                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floattixf" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.dst0, .tmp0), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .x87, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                     .patterns = &.{
@@ -116353,9 +121319,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
-                        .{ .type = .u64, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatuntixf" } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
                         .unused,
@@ -116364,21 +121329,54 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                         .unused,
+                        .unused,
                     },
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ },
-                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q0, .memi(.src0q, .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1q1, .memid(.src0q, .tmp0, 8), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                         .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
-                        .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .f_p, .st, .memi(.dst0t, .tmp0), ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .x87, null, null },
+                    .required_cc_abi = .win64,
+                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntixf" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.dst0, .tmp0), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .x87, null, null, null },
                     .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                     .patterns = &.{
@@ -116387,9 +121385,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floateixf" } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
                         .unused,
@@ -116401,19 +121399,54 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                         .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
-                        .{ ._, .f_p, .st, .memia(.dst0t, .tmp1, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .f_p, .st, .memi(.dst0t, .tmp1), ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .x87, null, null },
+                    .required_cc_abi = .win64,
+                    .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floateixf" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp2p, .memi(.dst0, .tmp1), ._, ._ },
+                        .{ ._, ._, .mov, .tmp3p, .tmp0p, ._, ._ },
+                        .{ ._, ._, .mov, .tmp4d, .sa(.src0, .add_bit_size), ._, ._ },
+                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .x87, null, null, null },
                     .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                     .patterns = &.{
@@ -116422,9 +121455,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatuneixf" } },
                         .{ .type = .f80, .kind = .{ .reg = .st7 } },
                         .unused,
@@ -116436,16 +121469,50 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                         .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
-                        .{ ._, .f_p, .st, .memia(.dst0t, .tmp1, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .f_p, .st, .memi(.dst0t, .tmp1), ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuneixf" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp2p, .memi(.dst0, .tmp1), ._, ._ },
+                        .{ ._, ._, .mov, .tmp3p, .tmp0p, ._, ._ },
+                        .{ ._, ._, .mov, .tmp4d, .sa(.src0, .add_bit_size), ._, ._ },
+                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -116457,7 +121524,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } },
                         .unused,
                         .unused,
@@ -116469,7 +121536,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ },
@@ -116485,7 +121552,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } },
                         .unused,
                         .unused,
@@ -116497,7 +121564,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ },
@@ -116513,7 +121580,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } },
                         .unused,
                         .unused,
@@ -116525,7 +121592,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ },
@@ -116541,7 +121608,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } },
                         .unused,
                         .unused,
@@ -116553,7 +121620,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ },
@@ -116564,7 +121631,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .src_constraints = .{ .{ .signed_int = .dword }, .any, .any },
                     .dst_constraints = .{ .{ .float = .xword }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .edi }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -116580,7 +121647,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
@@ -116590,7 +121657,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any },
                     .dst_constraints = .{ .{ .float = .xword }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .edi }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -116606,7 +121673,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
@@ -116616,7 +121683,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .src_constraints = .{ .{ .signed_int = .qword }, .any, .any },
                     .dst_constraints = .{ .{ .float = .xword }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .rdi }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -116632,7 +121699,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
@@ -116642,7 +121709,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any },
                     .dst_constraints = .{ .{ .float = .xword }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .rdi }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -116658,17 +121725,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .signed_int = .xword }, .any, .any },
                     .dst_constraints = .{ .{ .float = .xword }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -116684,17 +121752,46 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .signed_int = .xword }, .any, .any },
+                    .dst_constraints = .{ .{ .float = .xword }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floattitf" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
+                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any },
                     .dst_constraints = .{ .{ .float = .xword }, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -116710,12 +121807,40 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any },
+                    .dst_constraints = .{ .{ .float = .xword }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntitf" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
+                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
+                    } },
+                }, .{
                     .required_features = .{ .@"64bit", .sse, null, null },
                     .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                     .dst_constraints = .{ .{ .float = .xword }, .any },
@@ -116724,8 +121849,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floateitf" } },
                         .unused,
                         .unused,
@@ -116736,7 +121861,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
@@ -116752,8 +121877,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatuneitf" } },
                         .unused,
                         .unused,
@@ -116764,7 +121889,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
@@ -116780,11 +121905,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -116795,14 +121920,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                         .{ ._, .v_dqa, .mov, .lea(.tmp1x), .tmp4x, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -116813,11 +121938,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -116828,14 +121953,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                         .{ ._, .v_dqa, .mov, .lea(.tmp1x), .tmp4x, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, .slow_incdec, null, null },
@@ -116846,11 +121971,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -116861,14 +121986,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                         .{ ._, ._dqa, .mov, .lea(.tmp1x), .tmp4x, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -116879,11 +122004,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -116894,14 +122019,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                         .{ ._, ._dqa, .mov, .lea(.tmp1x), .tmp4x, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, .slow_incdec, null, null },
@@ -116912,11 +122037,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -116927,14 +122052,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                         .{ ._, ._ps, .mova, .lea(.tmp1x), .tmp4x, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -116945,11 +122070,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -116960,14 +122085,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                         .{ ._, ._ps, .mova, .lea(.tmp1x), .tmp4x, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, .slow_incdec, null, null },
@@ -116978,11 +122103,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -116993,14 +122118,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                         .{ ._, .v_dqa, .mov, .lea(.tmp1x), .tmp4x, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -117011,11 +122136,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -117026,14 +122151,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                         .{ ._, .v_dqa, .mov, .lea(.tmp1x), .tmp4x, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, .slow_incdec, null, null },
@@ -117044,11 +122169,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -117059,14 +122184,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                         .{ ._, ._dqa, .mov, .lea(.tmp1x), .tmp4x, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -117077,11 +122202,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -117092,14 +122217,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                         .{ ._, ._dqa, .mov, .lea(.tmp1x), .tmp4x, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, .slow_incdec, null, null },
@@ -117110,11 +122235,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -117125,14 +122250,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                         .{ ._, ._ps, .mova, .lea(.tmp1x), .tmp4x, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -117143,11 +122268,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -117158,14 +122283,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                         .{ ._, ._ps, .mova, .lea(.tmp1x), .tmp4x, ._, ._ },
-                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ },
-                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
-                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
+                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -117176,10 +122301,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -117191,12 +122316,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"8", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -117207,10 +122332,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -117222,12 +122347,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"8", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -117238,10 +122363,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -117253,12 +122378,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._ps, .mova, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"8", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -117269,10 +122394,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -117284,12 +122409,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"8", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -117300,10 +122425,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -117315,12 +122440,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"8", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -117331,10 +122456,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -117346,12 +122471,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._ps, .mova, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"8", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -117362,10 +122487,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -117377,12 +122502,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"4", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -117393,10 +122518,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -117408,12 +122533,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"4", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -117424,10 +122549,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -117439,12 +122564,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -117455,10 +122580,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -117470,12 +122595,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"4", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -117486,10 +122611,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -117501,12 +122626,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"4", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -117517,10 +122642,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u32, .kind = .{ .reg = .edi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -117532,12 +122657,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .avx, null, null },
@@ -117548,10 +122673,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i64, .kind = .{ .reg = .rdi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatditf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -117563,12 +122688,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"2", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse2, null, null },
@@ -117579,10 +122704,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i64, .kind = .{ .reg = .rdi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatditf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -117594,12 +122719,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"2", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse, null, null },
@@ -117610,10 +122735,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .i64, .kind = .{ .reg = .rdi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatditf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -117625,12 +122750,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._ps, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .avx, null, null },
@@ -117641,10 +122766,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunditf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -117656,12 +122781,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"2", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse2, null, null },
@@ -117672,10 +122797,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunditf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -117687,12 +122812,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"2", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse, null, null },
@@ -117703,10 +122828,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatunditf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -117718,15 +122843,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                        .{ ._, ._ps, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .avx, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                     .patterns = &.{
@@ -117734,11 +122860,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
-                        .{ .type = .i64, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floattitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -117749,16 +122875,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ },
-                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q0, .memi(.src0q, .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1q1, .memid(.src0q, .tmp0, 8), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse2, null, null },
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                     .patterns = &.{
@@ -117766,11 +122893,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
-                        .{ .type = .i64, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floattitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -117781,16 +122908,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ },
-                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse2, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                     .patterns = &.{
@@ -117798,11 +122925,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
-                        .{ .type = .i64, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floattitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -117813,16 +122940,114 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ },
-                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q0, .memi(.src0q, .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1q1, .memid(.src0q, .tmp0, 8), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .avx, null, null },
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse2, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floattitf" } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floattitf" } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q0, .memi(.src0q, .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1q1, .memid(.src0q, .tmp0, 8), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floattitf" } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                     .patterns = &.{
@@ -117830,11 +123055,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
-                        .{ .type = .u64, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatuntitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -117845,16 +123070,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ },
-                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q0, .memi(.src0q, .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1q1, .memid(.src0q, .tmp0, 8), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse2, null, null },
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                     .patterns = &.{
@@ -117862,11 +123088,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
-                        .{ .type = .u64, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatuntitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -117877,16 +123103,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ },
-                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse2, null, null, null },
                     .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                     .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                     .patterns = &.{
@@ -117894,11 +123120,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
-                        .{ .type = .u64, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatuntitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
                         .unused,
                         .unused,
                         .unused,
@@ -117909,13 +123135,110 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ },
-                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q0, .memi(.src0q, .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1q1, .memid(.src0q, .tmp0, 8), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse2, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntitf" } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntitf" } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q0, .memi(.src0q, .tmp0), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1q1, .memid(.src0q, .tmp0, 8), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
+                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .none, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntitf" } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .avx, null, null },
@@ -117927,11 +123250,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floateitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -117941,15 +123264,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp1), .tmp5x, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse2, null, null },
@@ -117961,11 +123284,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floateitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -117975,15 +123298,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp1), .tmp5x, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse, null, null },
@@ -117995,11 +123318,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floateitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -118009,15 +123332,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, ._ps, .mova, .memia(.dst0x, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp1), .tmp5x, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .avx, null, null },
@@ -118029,11 +123352,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatuneitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -118043,15 +123366,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp1), .tmp5x, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse2, null, null },
@@ -118063,11 +123386,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatuneitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -118077,15 +123400,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp1), .tmp5x, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .@"64bit", .sse, null, null },
@@ -118097,11 +123420,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
                         .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
-                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__floatuneitf" } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .unused,
                         .unused,
                         .unused,
@@ -118111,15 +123434,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
-                        .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                         .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, ._ps, .mova, .memia(.dst0x, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ },
-                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ },
-                        .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp1), .tmp5x, ._, ._ },
+                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
+                        .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 } }) catch |err| switch (err) {
                     error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{
@@ -118132,7 +123455,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{ty_op.operand}, &ops, cg);
             },
-            .reduce => |air_tag| if (use_old) try cg.airReduce(inst) else {
+            .reduce => |air_tag| {
                 const nan = std.math.nan(f16);
                 const reduce = air_datas[@intFromEnum(inst)].reduce;
                 const res_ty = cg.typeOfIndex(inst);
@@ -131814,7 +137137,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__fminh" } },
                             .unused,
                             .unused,
@@ -131825,7 +137148,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, .vp_, .xor, .dst0x, .dst0x, .dst0x, ._ },
@@ -131847,7 +137170,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__fminh" } },
                             .unused,
                             .unused,
@@ -131858,7 +137181,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, .p_, .xor, .dst0x, .dst0x, ._, ._ },
@@ -131882,7 +137205,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                             .{ .type = .f16, .kind = .{ .reg = .ax } },
                             .{ .type = .f32, .kind = .mem },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__fminh" } },
                             .unused,
                             .unused,
@@ -131891,7 +137214,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
@@ -133482,7 +138805,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "fminq" } },
                             .unused,
                             .unused,
@@ -133493,7 +138816,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
@@ -133513,7 +138836,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "fminq" } },
                             .unused,
                             .unused,
@@ -133524,7 +138847,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
@@ -133544,7 +138867,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "fminq" } },
                             .unused,
                             .unused,
@@ -133555,7 +138878,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
@@ -141934,7 +147257,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__fmaxh" } },
                             .unused,
                             .unused,
@@ -141945,7 +147268,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, .vp_, .xor, .dst0x, .dst0x, .dst0x, ._ },
@@ -141967,7 +147290,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__fmaxh" } },
                             .unused,
                             .unused,
@@ -141978,7 +147301,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, .p_, .xor, .dst0x, .dst0x, ._, ._ },
@@ -142002,7 +147325,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                             .{ .type = .f16, .kind = .{ .reg = .ax } },
                             .{ .type = .f32, .kind = .mem },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__fmaxh" } },
                             .unused,
                             .unused,
@@ -142011,7 +147334,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
@@ -143610,7 +148933,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } },
                             .unused,
                             .unused,
@@ -143621,7 +148944,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
@@ -143641,7 +148964,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } },
                             .unused,
                             .unused,
@@ -143652,7 +148975,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
@@ -143672,7 +148995,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } },
                             .unused,
                             .unused,
@@ -143683,7 +149006,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
@@ -147548,7 +152871,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true },
                         .each = .{ .once = &.{
                             .{ ._, .vp_, .xor, .dst0x, .dst0x, .dst0x, ._ },
@@ -147581,7 +152904,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true },
                         .each = .{ .once = &.{
                             .{ ._, .vp_, .xor, .dst0x, .dst0x, .dst0x, ._ },
@@ -147605,7 +152928,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                             .unused,
                             .unused,
@@ -147616,7 +152939,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, .vp_, .xor, .dst0x, .dst0x, .dst0x, ._ },
@@ -147638,7 +152961,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                             .unused,
                             .unused,
@@ -147649,7 +152972,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, .p_, .xor, .dst0x, .dst0x, ._, ._ },
@@ -147673,7 +152996,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                             .{ .type = .f16, .kind = .{ .reg = .ax } },
                             .{ .type = .f32, .kind = .mem },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                             .unused,
                             .unused,
@@ -147682,7 +153005,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
@@ -148150,6 +153473,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
                         } },
                     }, .{
+                        .required_abi = .gnu,
                         .required_features = .{ .x87, null, null, null },
                         .dst_constraints = .{ .{ .float = .tbyte }, .any },
                         .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
@@ -148157,8 +153481,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .{ .src = .{ .to_mem, .none, .none } },
                         },
                         .extra_temps = .{
-                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                             .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                             .{ .type = .f80, .kind = .{ .reg = .st6 } },
                             .unused,
                             .unused,
@@ -148172,13 +153496,51 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .dst_temps = .{ .{ .rc = .x87 }, .unused },
                         .clobbers = .{ .eflags = true },
                         .each = .{ .once = &.{
-                            .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_unaligned_size), ._, ._ },
                             .{ ._, .f_, .ld, .mem(.src0t), ._, ._, ._ },
-                            .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
+                            .{ ._, ._, .mov, .tmp1p, .sia(16, .src0, .sub_unaligned_size), ._, ._ },
+                            .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp1, .add_unaligned_size), ._, ._, ._ },
                             .{ ._, .f_p, .add, ._, ._, ._, ._ },
-                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+                            .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ },
+                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                            .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
+                        } },
+                    }, .{
+                        .required_abi = .msvc,
+                        .required_features = .{ .x87, null, null, null },
+                        .dst_constraints = .{ .{ .float = .tbyte }, .any },
+                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
+                        .patterns = &.{
+                            .{ .src = .{ .to_mem, .none, .none } },
+                        },
+                        .extra_temps = .{
+                            .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                            .{ .type = .u16, .kind = .mem },
+                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                        },
+                        .dst_temps = .{ .{ .rc = .x87 }, .unused },
+                        .clobbers = .{ .eflags = true },
+                        .each = .{ .once = &.{
+                            .{ ._, .f_, .ld, .mem(.src0t), ._, ._, ._ },
+                            .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
+                            .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
+                            .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_00_11), ._, ._ },
+                            .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
+                            .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
+                            .{ ._, ._, .mov, .tmp2p, .sia(16, .src0, .sub_unaligned_size), ._, ._ },
+                            .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp2, .add_unaligned_size), ._, ._, ._ },
+                            .{ ._, .f_p, .add, ._, ._, ._, ._ },
+                            .{ ._, ._, .add, .tmp2p, .si(16), ._, ._ },
                             .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                             .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
+                            .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                         } },
                     }, .{
                         .required_features = .{ .avx, null, null, null },
@@ -148190,7 +153552,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                             .unused,
                             .unused,
@@ -148201,7 +153563,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_unaligned_size), ._, ._ },
@@ -148221,7 +153583,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                             .unused,
                             .unused,
@@ -148232,7 +153594,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_unaligned_size), ._, ._ },
@@ -148252,7 +153614,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                             .unused,
                             .unused,
@@ -148263,7 +153625,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_unaligned_size), ._, ._ },
@@ -151240,7 +156602,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true },
                         .each = .{ .once = &.{
                             .{ ._, .vp_, .xor, .dst0x, .dst0x, .dst0x, ._ },
@@ -151264,7 +156626,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } },
                             .unused,
                             .unused,
@@ -151275,7 +156637,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, .vp_, .xor, .dst0x, .dst0x, .dst0x, ._ },
@@ -151297,7 +156659,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } },
                             .unused,
                             .unused,
@@ -151308,7 +156670,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, .p_, .xor, .dst0x, .dst0x, ._, ._ },
@@ -151332,7 +156694,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                             .{ .type = .f16, .kind = .{ .reg = .ax } },
                             .{ .type = .f32, .kind = .mem },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } },
                             .unused,
                             .unused,
@@ -151341,7 +156703,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
@@ -151689,6 +157051,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                         } },
                     }, .{
+                        .required_abi = .gnu,
                         .required_features = .{ .x87, null, null, null },
                         .dst_constraints = .{ .{ .float = .tbyte }, .any },
                         .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
@@ -151696,8 +157059,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .{ .src = .{ .to_mem, .none, .none } },
                         },
                         .extra_temps = .{
-                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                             .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                             .{ .type = .f80, .kind = .{ .reg = .st6 } },
                             .unused,
                             .unused,
@@ -151711,13 +157074,51 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .dst_temps = .{ .{ .rc = .x87 }, .unused },
                         .clobbers = .{ .eflags = true },
                         .each = .{ .once = &.{
-                            .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_unaligned_size), ._, ._ },
                             .{ ._, .f_, .ld, .mem(.src0t), ._, ._, ._ },
-                            .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
+                            .{ ._, ._, .mov, .tmp1p, .sia(16, .src0, .sub_unaligned_size), ._, ._ },
+                            .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp1, .add_unaligned_size), ._, ._, ._ },
                             .{ ._, .f_p, .mul, ._, ._, ._, ._ },
-                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+                            .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ },
+                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                            .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
+                        } },
+                    }, .{
+                        .required_abi = .msvc,
+                        .required_features = .{ .x87, null, null, null },
+                        .dst_constraints = .{ .{ .float = .tbyte }, .any },
+                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
+                        .patterns = &.{
+                            .{ .src = .{ .to_mem, .none, .none } },
+                        },
+                        .extra_temps = .{
+                            .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                            .{ .type = .u16, .kind = .mem },
+                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                        },
+                        .dst_temps = .{ .{ .rc = .x87 }, .unused },
+                        .clobbers = .{ .eflags = true },
+                        .each = .{ .once = &.{
+                            .{ ._, .f_, .ld, .mem(.src0t), ._, ._, ._ },
+                            .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
+                            .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
+                            .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_00_11), ._, ._ },
+                            .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
+                            .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
+                            .{ ._, ._, .mov, .tmp2p, .sia(16, .src0, .sub_unaligned_size), ._, ._ },
+                            .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp2, .add_unaligned_size), ._, ._, ._ },
+                            .{ ._, .f_p, .mul, ._, ._, ._, ._ },
+                            .{ ._, ._, .add, .tmp2p, .si(16), ._, ._ },
                             .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                             .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
+                            .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                         } },
                     }, .{
                         .required_features = .{ .avx, null, null, null },
@@ -151729,7 +157130,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } },
                             .unused,
                             .unused,
@@ -151740,7 +157141,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_unaligned_size), ._, ._ },
@@ -151760,7 +157161,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } },
                             .unused,
                             .unused,
@@ -151771,7 +157172,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_unaligned_size), ._, ._ },
@@ -151791,7 +157192,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } },
                             .unused,
                             .unused,
@@ -151802,7 +157203,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_unaligned_size), ._, ._ },
@@ -151836,7 +157237,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 }
                 try res[0].finish(inst, &.{reduce.operand}, &ops, cg);
             },
-            .reduce_optimized => |air_tag| if (use_old) try cg.airReduce(inst) else {
+            .reduce_optimized => |air_tag| {
                 const inf = std.math.inf(f16);
                 const reduce = air_datas[@intFromEnum(inst)].reduce;
                 var ops = try cg.tempsFromOperands(inst, .{reduce.operand});
@@ -152303,7 +157704,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__fminh" } },
                             .unused,
                             .unused,
@@ -152314,7 +157715,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, .vp_, .xor, .dst0x, .dst0x, .dst0x, ._ },
@@ -152336,7 +157737,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__fminh" } },
                             .unused,
                             .unused,
@@ -152347,7 +157748,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, .p_, .xor, .dst0x, .dst0x, ._, ._ },
@@ -152371,7 +157772,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                             .{ .type = .f16, .kind = .{ .reg = .ax } },
                             .{ .type = .f32, .kind = .mem },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__fminh" } },
                             .unused,
                             .unused,
@@ -152380,7 +157781,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
@@ -153451,7 +158852,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "fminq" } },
                             .unused,
                             .unused,
@@ -153462,7 +158863,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
@@ -153482,7 +158883,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "fminq" } },
                             .unused,
                             .unused,
@@ -153493,7 +158894,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
@@ -153513,7 +158914,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "fminq" } },
                             .unused,
                             .unused,
@@ -153524,7 +158925,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
@@ -153995,7 +159396,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__fmaxh" } },
                             .unused,
                             .unused,
@@ -154006,7 +159407,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, .vp_, .xor, .dst0x, .dst0x, .dst0x, ._ },
@@ -154028,7 +159429,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__fmaxh" } },
                             .unused,
                             .unused,
@@ -154039,7 +159440,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, .p_, .xor, .dst0x, .dst0x, ._, ._ },
@@ -154063,7 +159464,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                             .{ .type = .f16, .kind = .{ .reg = .ax } },
                             .{ .type = .f32, .kind = .mem },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__fmaxh" } },
                             .unused,
                             .unused,
@@ -154072,7 +159473,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
@@ -155143,7 +160544,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } },
                             .unused,
                             .unused,
@@ -155154,7 +160555,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
@@ -155174,7 +160575,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } },
                             .unused,
                             .unused,
@@ -155185,7 +160586,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
@@ -155205,7 +160606,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } },
                             .unused,
                             .unused,
@@ -155216,7 +160617,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
@@ -155936,7 +161337,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                             .unused,
                             .unused,
@@ -155947,7 +161348,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, .vp_, .xor, .dst0x, .dst0x, .dst0x, ._ },
@@ -155969,7 +161370,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                             .unused,
                             .unused,
@@ -155980,7 +161381,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, .p_, .xor, .dst0x, .dst0x, ._, ._ },
@@ -156004,7 +161405,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                             .{ .type = .f16, .kind = .{ .reg = .ax } },
                             .{ .type = .f32, .kind = .mem },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                             .unused,
                             .unused,
@@ -156013,7 +161414,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
@@ -157362,6 +162763,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
                         } },
                     }, .{
+                        .required_abi = .gnu,
                         .required_features = .{ .x87, null, null, null },
                         .dst_constraints = .{ .{ .float = .tbyte }, .any },
                         .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
@@ -157369,8 +162771,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .{ .src = .{ .to_mem, .none, .none } },
                         },
                         .extra_temps = .{
-                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                             .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                             .{ .type = .f80, .kind = .{ .reg = .st6 } },
                             .unused,
                             .unused,
@@ -157384,15 +162786,53 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .dst_temps = .{ .{ .rc = .x87 }, .unused },
                         .clobbers = .{ .eflags = true },
                         .each = .{ .once = &.{
-                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                             .{ ._, .f_, .ld, .memad(.src0t, .add_unaligned_size, -16), ._, ._, ._ },
-                            .{ .@"0:", .f_, .ld, .memi(.src0t, .tmp0), ._, ._, ._ },
+                            .{ ._, ._, .mov, .tmp1d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
+                            .{ .@"0:", .f_, .ld, .memi(.src0t, .tmp1), ._, ._, ._ },
                             .{ ._, .f_p, .add, ._, ._, ._, ._ },
-                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                            .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ },
                             .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                             .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                         } },
                     }, .{
+                        .required_abi = .msvc,
+                        .required_features = .{ .x87, null, null, null },
+                        .dst_constraints = .{ .{ .float = .tbyte }, .any },
+                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
+                        .patterns = &.{
+                            .{ .src = .{ .to_mem, .none, .none } },
+                        },
+                        .extra_temps = .{
+                            .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                            .{ .type = .u16, .kind = .mem },
+                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                        },
+                        .dst_temps = .{ .{ .rc = .x87 }, .unused },
+                        .clobbers = .{ .eflags = true },
+                        .each = .{ .once = &.{
+                            .{ ._, .f_, .ld, .mem(.src0t), ._, ._, ._ },
+                            .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
+                            .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
+                            .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_00_11), ._, ._ },
+                            .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
+                            .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
+                            .{ ._, ._, .mov, .tmp2p, .sia(16, .src0, .sub_unaligned_size), ._, ._ },
+                            .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp2, .add_unaligned_size), ._, ._, ._ },
+                            .{ ._, .f_p, .add, ._, ._, ._, ._ },
+                            .{ ._, ._, .add, .tmp2p, .si(16), ._, ._ },
+                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                            .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
+                            .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
+                        } },
+                    }, .{
                         .required_features = .{ .avx, null, null, null },
                         .dst_constraints = .{ .{ .float = .xword }, .any },
                         .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
@@ -157402,7 +162842,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                             .unused,
                             .unused,
@@ -157413,7 +162853,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
@@ -157433,7 +162873,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                             .unused,
                             .unused,
@@ -157444,7 +162884,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
@@ -157464,7 +162904,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                             .unused,
                             .unused,
@@ -157475,7 +162915,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
@@ -157946,7 +163386,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } },
                             .unused,
                             .unused,
@@ -157957,7 +163397,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, .vp_, .xor, .dst0x, .dst0x, .dst0x, ._ },
@@ -157979,7 +163419,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } },
                             .unused,
                             .unused,
@@ -157990,7 +163430,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, .p_, .xor, .dst0x, .dst0x, ._, ._ },
@@ -158014,7 +163454,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                             .{ .type = .f16, .kind = .{ .reg = .ax } },
                             .{ .type = .f32, .kind = .mem },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } },
                             .unused,
                             .unused,
@@ -158023,7 +163463,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
@@ -158905,6 +164345,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
                         } },
                     }, .{
+                        .required_abi = .gnu,
                         .required_features = .{ .x87, null, null, null },
                         .dst_constraints = .{ .{ .float = .tbyte }, .any },
                         .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
@@ -158936,6 +164377,44 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                         } },
                     }, .{
+                        .required_abi = .msvc,
+                        .required_features = .{ .x87, null, null, null },
+                        .dst_constraints = .{ .{ .float = .tbyte }, .any },
+                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
+                        .patterns = &.{
+                            .{ .src = .{ .to_mem, .none, .none } },
+                        },
+                        .extra_temps = .{
+                            .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                            .{ .type = .u16, .kind = .mem },
+                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                            .unused,
+                        },
+                        .dst_temps = .{ .{ .rc = .x87 }, .unused },
+                        .clobbers = .{ .eflags = true },
+                        .each = .{ .once = &.{
+                            .{ ._, .f_, .ld, .mem(.src0t), ._, ._, ._ },
+                            .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
+                            .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
+                            .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_00_11), ._, ._ },
+                            .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
+                            .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
+                            .{ ._, ._, .mov, .tmp2p, .sia(16, .src0, .sub_unaligned_size), ._, ._ },
+                            .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp2, .add_unaligned_size), ._, ._, ._ },
+                            .{ ._, .f_p, .mul, ._, ._, ._, ._ },
+                            .{ ._, ._, .add, .tmp2p, .si(16), ._, ._ },
+                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                            .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
+                            .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
+                        } },
+                    }, .{
                         .required_features = .{ .avx, null, null, null },
                         .dst_constraints = .{ .{ .float = .xword }, .any },
                         .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
@@ -158945,7 +164424,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } },
                             .unused,
                             .unused,
@@ -158956,7 +164435,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
@@ -158976,7 +164455,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } },
                             .unused,
                             .unused,
@@ -158987,7 +164466,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
@@ -159007,7 +164486,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .call_frame = .{ .alignment = .@"16" },
                         .extra_temps = .{
                             .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                             .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } },
                             .unused,
                             .unused,
@@ -159018,7 +164497,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                             .unused,
                             .unused,
                         },
-                        .dst_temps = .{ .{ .reg = .xmm0 }, .unused },
+                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                         .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                         .each = .{ .once = &.{
                             .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
@@ -159040,7 +164519,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{reduce.operand}, &ops, cg);
             },
-            .splat => |air_tag| if (use_old) try cg.airSplat(inst) else fallback: {
+            .splat => |air_tag| fallback: {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                 if (cg.typeOf(ty_op.operand).toIntern() == .bool_type) break :fallback try cg.airSplat(inst);
                 var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
@@ -160346,16 +165825,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .sse, null, null, null },
-                    .dst_constraints = .{ .{ .scalar = .{ .of = .xword, .is = .xword } }, .any },
-                    .src_constraints = .{ .{ .int_or_float = .xword }, .any, .any },
-                    .patterns = &.{
-                        .{ .src = .{ .mut_mem, .none, .none } },
-                        .{ .src = .{ .to_mut_sse, .none, .none } },
-                    },
-                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
-                    .each = .{ .once = &.{} },
-                }, .{
                     .required_features = .{ .avx2, null, null, null },
                     .dst_constraints = .{ .{ .scalar = .{ .of = .yword, .is = .xword } }, .any },
                     .src_constraints = .{ .{ .int_or_float = .xword }, .any, .any },
@@ -160593,16 +166062,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
-                    .required_features = .{ .@"64bit", .sse, null, null },
-                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
-                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
-                    .patterns = &.{
-                        .{ .src = .{ .mut_mem, .none, .none } },
-                        .{ .src = .{ .to_mut_sse, .none, .none } },
-                    },
-                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
-                    .each = .{ .once = &.{} },
-                }, .{
                     .required_features = .{ .@"64bit", .avx2, null, null },
                     .dst_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .tbyte } }, .any },
                     .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
@@ -160859,11 +166318,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
 
             .memset => try cg.airMemset(inst, false),
             .memset_safe => try cg.airMemset(inst, true),
-            .memcpy, .memmove => |air_tag| if (use_old) switch (air_tag) {
-                else => unreachable,
-                .memcpy => try cg.airMemcpy(inst),
-                .memmove => return cg.fail("TODO implement airMemmove for {}", .{cg.target.cpu.arch}),
-            } else {
+            .memcpy, .memmove => |air_tag| {
                 const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }) ++ .{undefined};
                 ops[2] = ops[0].getByteLen(cg) catch |err| switch (err) {
@@ -160882,9 +166337,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     inline .memcpy, .memmove => |symbol| comptime &.{.{
                         .patterns = &.{
                             .{ .src = .{
-                                .{ .to_param_gpr = .{ .cc = .ccc, .at = 0 } },
-                                .{ .to_param_gpr = .{ .cc = .ccc, .at = 1 } },
-                                .{ .to_param_gpr = .{ .cc = .ccc, .at = 2 } },
+                                .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                                .{ .to_param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                                .{ .to_param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } },
                             } },
                         },
                         .call_frame = .{ .alignment = .@"16" },
@@ -160926,7 +166381,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
             .atomic_store_release => try cg.airAtomicStore(inst, .release),
             .atomic_store_seq_cst => try cg.airAtomicStore(inst, .seq_cst),
             .atomic_rmw => try cg.airAtomicRmw(inst),
-            .is_named_enum_value => |air_tag| if (use_old) try cg.airTagName(inst, true) else {
+            .is_named_enum_value => |air_tag| {
                 const un_op = air_datas[@intFromEnum(inst)].un_op;
                 var ops = try cg.tempsFromOperands(inst, .{un_op});
                 var res: [1]Temp = undefined;
@@ -160934,7 +166389,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .int = .gpr }, .any, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .at = 0 } }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"32" },
                     .extra_temps = .{
@@ -160960,7 +166415,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .int = .gpr }, .any, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .at = 0 } }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -160985,7 +166440,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 }, .{
                     .src_constraints = .{ .{ .int = .gpr }, .any, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .at = 0 } }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"8" },
                     .extra_temps = .{
@@ -161017,7 +166472,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{un_op}, &ops, cg);
             },
-            .tag_name => |air_tag| if (use_old) try cg.airTagName(inst, false) else {
+            .tag_name => |air_tag| {
                 const un_op = air_datas[@intFromEnum(inst)].un_op;
                 var ops = try cg.tempsFromOperands(inst, .{un_op});
                 var res: [1]Temp = undefined;
@@ -161025,7 +166480,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .int = .gpr }, .any, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .at = 0 } }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"32" },
                     .extra_temps = .{
@@ -161041,7 +166496,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .ret_gpr = .{ .cc = .zigcc, .at = 1 } }, .unused },
+                    .dst_temps = .{ .{ .ret_gpr = .{ .cc = .zigcc, .after = 1, .at = 1 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .zigcc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
@@ -161050,7 +166505,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .int = .gpr }, .any, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .at = 0 } }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -161066,7 +166521,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .ret_gpr = .{ .cc = .zigcc, .at = 1 } }, .unused },
+                    .dst_temps = .{ .{ .ret_gpr = .{ .cc = .zigcc, .after = 1, .at = 1 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .zigcc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
@@ -161074,7 +166529,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 }, .{
                     .src_constraints = .{ .{ .int = .gpr }, .any, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .at = 0 } }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"8" },
                     .extra_temps = .{
@@ -161090,7 +166545,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .ret_gpr = .{ .cc = .zigcc, .at = 1 } }, .unused },
+                    .dst_temps = .{ .{ .ret_gpr = .{ .cc = .zigcc, .after = 1, .at = 1 } }, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .zigcc },
                     .each = .{ .once = &.{
                         .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
@@ -161106,7 +166561,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 try ops[0].toPair(&res[0], cg);
                 try res[0].finish(inst, &.{un_op}, &ops, cg);
             },
-            .error_name => |air_tag| if (use_old) try cg.airErrorName(inst) else {
+            .error_name => |air_tag| {
                 const un_op = air_datas[@intFromEnum(inst)].un_op;
                 var ops = try cg.tempsFromOperands(inst, .{un_op});
                 var res: [2]Temp = undefined;
@@ -161214,7 +166669,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{un_op}, &ops, cg);
             },
-            .error_set_has_value => |air_tag| if (use_old) try cg.airErrorSetHasValue(inst) else {
+            .error_set_has_value => |air_tag| {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                 var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}) ++ .{try cg.tempInit(ty_op.ty.toType(), .none)};
                 var res: [1]Temp = undefined;
@@ -161222,7 +166677,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .required_features = .{ .avx, null, null, null },
                     .src_constraints = .{ .{ .int = .gpr }, .any, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .at = 0 } }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"32" },
                     .extra_temps = .{
@@ -161248,7 +166703,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .required_features = .{ .sse, null, null, null },
                     .src_constraints = .{ .{ .int = .gpr }, .any, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .at = 0 } }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -161273,7 +166728,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 }, .{
                     .src_constraints = .{ .{ .int = .gpr }, .any, .any },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .at = 0 } }, .none, .none } },
+                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .after = 0, .at = 0 } }, .none, .none } },
                     },
                     .call_frame = .{ .alignment = .@"8" },
                     .extra_temps = .{
@@ -161306,7 +166761,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 for (ops[1..]) |op| try op.die(cg);
                 try res[0].finish(inst, &.{ty_op.operand}, ops[0..1], cg);
             },
-            .aggregate_init => |air_tag| if (use_old) try cg.airAggregateInit(inst) else fallback: {
+            .aggregate_init => |air_tag| fallback: {
                 const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                 const agg_ty = ty_pl.ty.toType();
                 if ((agg_ty.isVector(zcu) and agg_ty.childType(zcu).toIntern() == .bool_type) or
@@ -161376,7 +166831,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 }
                 try res.finish(inst, &.{}, &.{}, cg);
             },
-            .union_init => if (use_old) try cg.airUnionInit(inst) else {
+            .union_init => {
                 const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                 const union_init = cg.air.extraData(Air.UnionInit, ty_pl.payload).data;
                 const union_ty = ty_pl.ty.toType();
@@ -161425,7 +166880,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 const res = try cg.tempInit(.void, .none);
                 try res.finish(inst, &.{prefetch.ptr}, &ops, cg);
             },
-            .mul_add => |air_tag| if (use_old) try cg.airMulAdd(inst) else {
+            .mul_add => |air_tag| {
                 const pl_op = air_datas[@intFromEnum(inst)].pl_op;
                 const bin_op = cg.air.extraData(Air.Bin, pl_op.payload).data;
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs, pl_op.operand });
@@ -161469,7 +166924,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .scalar_float = .{ .of = .word, .is = .word } },
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .{ .to_reg = .xmm2 } } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } },
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -161577,7 +167036,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .to_mem, .to_mem } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                         .{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } },
                         .{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } },
@@ -161591,14 +167050,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .dst_temps = .{ .mem, .unused },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, .v_ps, .cvtph2, .tmp3y, .memia(.src2x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memi(.src0x, .tmp0), ._, ._ },
+                        .{ ._, .v_ps, .cvtph2, .tmp2y, .memi(.src1x, .tmp0), ._, ._ },
+                        .{ ._, .v_ps, .cvtph2, .tmp3y, .memi(.src2x, .tmp0), ._, ._ },
                         .{ ._, .v_ps, .fmadd213, .tmp1y, .tmp2y, .tmp3y, ._ },
-                        .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_, .cvtps2ph, .memi(.dst0x, .tmp0), .tmp1y, .rm(.{}), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -161612,10 +167071,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm2 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmah" } },
                         .unused,
                         .unused,
@@ -161627,15 +167086,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .vp_, .xor, .tmp3x, .tmp3x, .tmp3x, ._ },
-                        .{ ._, .vp_w, .insr, .tmp1x, .tmp3x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
-                        .{ ._, .vp_w, .insr, .tmp2x, .tmp3x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) },
-                        .{ ._, .vp_w, .insr, .tmp3x, .tmp3x, .memia(.src2w, .tmp0, .add_unaligned_size), .ui(0) },
+                        .{ ._, .vp_w, .insr, .tmp1x, .tmp3x, .memi(.src0w, .tmp0), .ui(0) },
+                        .{ ._, .vp_w, .insr, .tmp2x, .tmp3x, .memi(.src1w, .tmp0), .ui(0) },
+                        .{ ._, .vp_w, .insr, .tmp3x, .tmp3x, .memi(.src2w, .tmp0), .ui(0) },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse4_1, null, null, null },
@@ -161649,10 +167108,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm2 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmah" } },
                         .unused,
                         .unused,
@@ -161664,17 +167123,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                         .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                         .{ ._, .p_, .xor, .tmp3x, .tmp3x, ._, ._ },
-                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
-                        .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
-                        .{ ._, .p_w, .insr, .tmp3x, .memia(.src2w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+                        .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
+                        .{ ._, .p_w, .insr, .tmp2x, .memi(.src1w, .tmp0), .ui(0), ._ },
+                        .{ ._, .p_w, .insr, .tmp3x, .memi(.src2w, .tmp0), .ui(0), ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -161688,10 +167147,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm2 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmah" } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
                         .unused,
@@ -161703,18 +167162,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                         .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                         .{ ._, .p_, .xor, .tmp3x, .tmp3x, ._, ._ },
-                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
-                        .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
-                        .{ ._, .p_w, .insr, .tmp3x, .memia(.src2w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+                        .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
+                        .{ ._, .p_w, .insr, .tmp2x, .memi(.src1w, .tmp0), .ui(0), ._ },
+                        .{ ._, .p_w, .insr, .tmp3x, .memi(.src2w, .tmp0), .ui(0), ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                         .{ ._, .p_w, .extr, .tmp5d, .tmp1x, .ui(0), ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp5w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp5w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -161728,12 +167187,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .f16, .kind = .{ .reg = .ax } },
                         .{ .type = .f32, .kind = .mem },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
-                        .{ .type = .f16, .kind = .{ .reg = .xmm2 } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmah" } },
                         .unused,
                         .unused,
@@ -161743,22 +167202,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                         .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                         .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
-                        .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .movzx, .tmp1d, .memi(.src1w, .tmp0), ._, ._ },
                         .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                         .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ },
-                        .{ ._, ._, .movzx, .tmp1d, .memia(.src2w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .movzx, .tmp1d, .memi(.src2w, .tmp0), ._, ._ },
                         .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                         .{ ._, ._ss, .mov, .tmp5x, .mem(.tmp2d), ._, ._ },
                         .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
                         .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ },
                         .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ },
-                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .fma, null, null, null },
@@ -161818,7 +167277,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .{ .to_reg = .xmm2 } } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } },
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -161950,7 +167413,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .to_mem, .to_mem } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                         .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } },
                         .unused,
@@ -161964,13 +167427,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .dst_temps = .{ .mem, .unused },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, .v_ps, .mova, .tmp2y, .memia(.src1y, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, .v_ps, .fmadd213, .tmp1y, .tmp2y, .memia(.src2y, .tmp0, .add_unaligned_size), ._ },
-                        .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .v_ps, .mova, .tmp1y, .memi(.src0y, .tmp0), ._, ._ },
+                        .{ ._, .v_ps, .mova, .tmp2y, .memi(.src1y, .tmp0), ._, ._ },
+                        .{ ._, .v_ps, .fmadd213, .tmp1y, .tmp2y, .memi(.src2y, .tmp0), ._ },
+                        .{ ._, .v_ps, .mova, .memi(.dst0y, .tmp0), .tmp1y, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -161984,10 +167447,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm1 } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm2 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "fmaf" } },
                         .unused,
                         .unused,
@@ -161999,14 +167462,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, .v_ss, .mov, .tmp2x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, .v_ss, .mov, .tmp3x, .memia(.src2d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
+                        .{ ._, .v_ss, .mov, .tmp2x, .memi(.src1d, .tmp0), ._, ._ },
+                        .{ ._, .v_ss, .mov, .tmp3x, .memi(.src2d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -162020,10 +167483,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm1 } },
-                        .{ .type = .f32, .kind = .{ .reg = .xmm2 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "fmaf" } },
                         .unused,
                         .unused,
@@ -162035,14 +167498,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._ss, .mov, .tmp2x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._ss, .mov, .tmp3x, .memia(.src2d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
+                        .{ ._, ._ss, .mov, .tmp2x, .memi(.src1d, .tmp0), ._, ._ },
+                        .{ ._, ._ss, .mov, .tmp3x, .memi(.src2d, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .fma, null, null, null },
@@ -162102,7 +167565,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .{ .to_reg = .xmm2 } } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } },
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -162234,7 +167701,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .src = .{ .to_mem, .to_mem, .to_mem } },
                     },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                         .{ .type = .vector_4_f64, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                         .{ .type = .vector_4_f64, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } },
                         .unused,
@@ -162248,13 +167715,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .dst_temps = .{ .mem, .unused },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, .v_pd, .mova, .tmp2y, .memia(.src1y, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, .v_pd, .fmadd213, .tmp1y, .tmp2y, .memia(.src2y, .tmp0, .add_unaligned_size), ._ },
-                        .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
+                        .{ .@"0:", .v_pd, .mova, .tmp1y, .memi(.src0y, .tmp0), ._, ._ },
+                        .{ ._, .v_pd, .mova, .tmp2y, .memi(.src1y, .tmp0), ._, ._ },
+                        .{ ._, .v_pd, .fmadd213, .tmp1y, .tmp2y, .memi(.src2y, .tmp0), ._ },
+                        .{ ._, .v_pd, .mova, .memi(.dst0y, .tmp0), .tmp1y, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .avx, null, null, null },
@@ -162268,10 +167735,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm1 } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm2 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "fma" } },
                         .unused,
                         .unused,
@@ -162283,14 +167750,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, .v_sd, .mov, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, .v_sd, .mov, .tmp3x, .memia(.src2q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
+                        .{ ._, .v_sd, .mov, .tmp2x, .memi(.src1q, .tmp0), ._, ._ },
+                        .{ ._, .v_sd, .mov, .tmp3x, .memi(.src2q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -162304,10 +167771,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm1 } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm2 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "fma" } },
                         .unused,
                         .unused,
@@ -162319,14 +167786,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._sd, .mov, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._sd, .mov, .tmp3x, .memia(.src2q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
+                        .{ ._, ._sd, .mov, .tmp2x, .memi(.src1q, .tmp0), ._, ._ },
+                        .{ ._, ._sd, .mov, .tmp3x, .memi(.src2q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._sd, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -162340,10 +167807,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm1 } },
-                        .{ .type = .f64, .kind = .{ .reg = .xmm2 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "fma" } },
                         .unused,
                         .unused,
@@ -162355,19 +167822,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                         .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                         .{ ._, ._ps, .xor, .tmp2x, .tmp2x, ._, ._ },
                         .{ ._, ._ps, .xor, .tmp3x, .tmp3x, ._, ._ },
-                        .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._ps, .movl, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._ps, .movl, .tmp3x, .memia(.src2q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._ps, .movl, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
+                        .{ ._, ._ps, .movl, .tmp2x, .memi(.src1q, .tmp0), ._, ._ },
+                        .{ ._, ._ps, .movl, .tmp3x, .memi(.src2q, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ps, .movl, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .sse, .x87, null, null },
                     .src_constraints = .{
                         .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -162379,7 +167847,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16 * 3, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmax" } },
                         .unused,
@@ -162403,6 +167871,40 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                     } },
                 }, .{
+                    .required_cc_abi = .win64,
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .to_mem } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fmax" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .mem(.src1), ._, ._ },
+                        .{ ._, ._, .lea, .tmp3p, .mem(.src2), ._, ._ },
+                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .sysv64,
                     .required_features = .{ .sse, .x87, null, null },
                     .src_constraints = .{
                         .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
@@ -162414,8 +167916,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .size = 16 * 3, .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                         .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                         .{ .type = .usize, .kind = .{ .extern_func = "__fmax" } },
                         .unused,
@@ -162429,18 +167931,54 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                         .{ ._, ._ps, .mova, .mem(.tmp2x), .tmp1x, ._, ._ },
-                        .{ ._, ._ps, .mova, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._ps, .mova, .tmp1x, .memi(.src1x, .tmp0), ._, ._ },
                         .{ ._, ._ps, .mova, .memd(.tmp2x, 16), .tmp1x, ._, ._ },
-                        .{ ._, ._ps, .mova, .tmp1x, .memia(.src2x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._ps, .mova, .tmp1x, .memi(.src2x, .tmp0), ._, ._ },
                         .{ ._, ._ps, .mova, .memd(.tmp2x, 16 * 2), .tmp1x, ._, ._ },
                         .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                         .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
-                        .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .f_p, .st, .memi(.dst0t, .tmp0), ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_cc_abi = .win64,
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .to_mem } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
+                        .{ .type = .usize, .kind = .{ .extern_func = "__fmax" } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.dst0, .tmp0), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ },
+                        .{ ._, ._, .lea, .tmp3p, .memi(.src1, .tmp0), ._, ._ },
+                        .{ ._, ._, .lea, .tmp4p, .memi(.src2, .tmp0), ._, ._ },
+                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -162450,7 +167988,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                     },
                     .patterns = &.{
-                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .{ .to_reg = .xmm2 } } },
+                        .{ .src = .{
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
+                            .{ .to_param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } },
+                        } },
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
@@ -162483,10 +168025,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm2 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "fmaq" } },
                         .unused,
                         .unused,
@@ -162498,14 +168040,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, .v_dqa, .mov, .tmp3x, .memia(.src2x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
+                        .{ ._, .v_dqa, .mov, .tmp2x, .memi(.src1x, .tmp0), ._, ._ },
+                        .{ ._, .v_dqa, .mov, .tmp3x, .memi(.src2x, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse2, null, null, null },
@@ -162519,10 +168061,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm2 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "fmaq" } },
                         .unused,
                         .unused,
@@ -162534,14 +168076,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._dqa, .mov, .tmp3x, .memia(.src2x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
+                        .{ ._, ._dqa, .mov, .tmp2x, .memi(.src1x, .tmp0), ._, ._ },
+                        .{ ._, ._dqa, .mov, .tmp3x, .memi(.src2x, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 }, .{
                     .required_features = .{ .sse, null, null, null },
@@ -162555,10 +168097,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     },
                     .call_frame = .{ .alignment = .@"16" },
                     .extra_temps = .{
-                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
-                        .{ .type = .f128, .kind = .{ .reg = .xmm2 } },
+                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                         .{ .type = .usize, .kind = .{ .extern_func = "fmaq" } },
                         .unused,
                         .unused,
@@ -162570,14 +168112,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                     .dst_temps = .{ .mem, .unused },
                     .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                     .each = .{ .once = &.{
-                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                        .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
-                        .{ ._, ._ps, .mova, .tmp3x, .memia(.src2x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
+                        .{ ._, ._ps, .mova, .tmp2x, .memi(.src1x, .tmp0), ._, ._ },
+                        .{ ._, ._ps, .mova, .tmp3x, .memi(.src2x, .tmp0), ._, ._ },
                         .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                        .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
+                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
+                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                     } },
                 } }) catch |err| switch (err) {
                     error.SelectFailed => return cg.fail("failed to select {s} {} {} {} {}", .{
@@ -162591,7 +168133,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs, pl_op.operand }, &ops, cg);
             },
-            .field_parent_ptr => if (use_old) try cg.airFieldParentPtr(inst) else {
+            .field_parent_ptr => {
                 const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                 const field_parent_ptr = cg.air.extraData(Air.FieldParentPtr, ty_pl.payload).data;
                 var ops = try cg.tempsFromOperands(inst, .{field_parent_ptr.field_ptr});
@@ -162603,7 +168145,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 try ops[0].finish(inst, &.{field_parent_ptr.field_ptr}, &ops, cg);
             },
             .wasm_memory_size, .wasm_memory_grow => unreachable,
-            .cmp_lt_errors_len => |air_tag| if (use_old) try cg.airCmpLtErrorsLen(inst) else {
+            .cmp_lt_errors_len => |air_tag| {
                 const un_op = air_datas[@intFromEnum(inst)].un_op;
                 var ops = try cg.tempsFromOperands(inst, .{un_op});
                 var res: [1]Temp = undefined;
@@ -163494,36 +169036,38 @@ fn getValueIfFree(self: *CodeGen, value: MCValue, inst: ?Air.Inst.Index) void {
         self.register_manager.getRegAssumeFree(reg, inst);
 }
 
-fn freeReg(self: *CodeGen, reg: Register) !void {
+const FreeOptions = struct { emit_instructions: bool = true };
+
+fn freeReg(self: *CodeGen, reg: Register, comptime opts: FreeOptions) !void {
     self.register_manager.freeReg(reg);
-    if (reg.isClass(.x87)) try self.asmRegister(.{ .f_, .free }, reg);
+    if (opts.emit_instructions and reg.isClass(.x87)) try self.asmRegister(.{ .f_, .free }, reg);
 }
 
-fn freeValue(self: *CodeGen, value: MCValue) !void {
+fn freeValue(self: *CodeGen, value: MCValue, comptime opts: FreeOptions) !void {
     switch (value) {
-        .register => |reg| try self.freeReg(reg),
+        .register => |reg| try self.freeReg(reg, opts),
         inline .register_pair,
         .register_triple,
         .register_quadruple,
-        => |regs| for (regs) |reg| try self.freeReg(reg),
-        .register_offset, .indirect => |reg_off| try self.freeReg(reg_off.reg),
+        => |regs| for (regs) |reg| try self.freeReg(reg, opts),
+        .register_offset, .indirect => |reg_off| try self.freeReg(reg_off.reg, opts),
         .register_overflow => |reg_ov| {
-            try self.freeReg(reg_ov.reg);
+            try self.freeReg(reg_ov.reg, opts);
             self.eflags_inst = null;
         },
-        .register_mask => |reg_mask| try self.freeReg(reg_mask.reg),
+        .register_mask => |reg_mask| try self.freeReg(reg_mask.reg, opts),
         .eflags => self.eflags_inst = null,
         else => {}, // TODO process stack allocation death
     }
 }
 
 fn feed(self: *CodeGen, bt: *Air.Liveness.BigTomb, operand: Air.Inst.Ref) !void {
-    if (bt.feed()) if (operand.toIndex()) |inst| try self.processDeath(inst);
+    if (bt.feed()) if (operand.toIndex()) |inst| try self.processDeath(inst, .{});
 }
 
 /// Asserts there is already capacity to insert into top branch inst_table.
-fn processDeath(self: *CodeGen, inst: Air.Inst.Index) !void {
-    try self.inst_tracking.getPtr(inst).?.die(self, inst);
+fn processDeath(self: *CodeGen, inst: Air.Inst.Index, comptime opts: FreeOptions) !void {
+    try self.inst_tracking.getPtr(inst).?.die(self, inst, opts);
 }
 
 fn finishAirResult(self: *CodeGen, inst: Air.Inst.Index, result: MCValue) void {
@@ -163550,7 +169094,7 @@ fn finishAir(
     for (0.., operands) |op_index, op| {
         if (tomb_bits & @as(Air.Liveness.Bpi, 1) << @intCast(op_index) == 0) continue;
         if (self.reused_operands.isSet(op_index)) continue;
-        try self.processDeath(op.toIndexAllowNone() orelse continue);
+        try self.processDeath(op.toIndexAllowNone() orelse continue, .{});
     }
     self.finishAirResult(inst, result);
 }
@@ -163704,7 +169248,7 @@ fn allocRegOrMemAdvanced(self: *CodeGen, ty: Type, inst: ?Air.Inst.Index, reg_ok
 
     if (reg_ok) need_mem: {
         if (std.math.isPowerOfTwo(abi_size) and abi_size <= @as(u32, max_abi_size: switch (ty.zigTypeTag(zcu)) {
-            .float => switch (ty.floatBits(self.target.*)) {
+            .float => switch (ty.floatBits(self.target)) {
                 16, 32, 64, 128 => 16,
                 80 => break :need_mem,
                 else => unreachable,
@@ -163772,21 +169316,6 @@ fn vectorSize(cg: *CodeGen, kind: enum { int, float }) u6 {
     })) 32 else if (cg.hasFeature(.sse)) 16 else 8;
 }
 
-fn limbType(cg: *CodeGen, ty: Type) Type {
-    const pt = cg.pt;
-    const zcu = pt.zcu;
-    const vector_size = cg.vectorSize(if (ty.isRuntimeFloat()) .float else .int);
-    const scalar_ty, const scalar_size = scalar: {
-        const scalar_ty = ty.scalarType(zcu);
-        const scalar_size = scalar_ty.abiSize(zcu);
-        if (scalar_size <= vector_size) break :scalar .{ scalar_ty, scalar_size };
-    };
-    pt.vectorType(.{
-        .len = @divExact(vector_size, scalar_size),
-        .child = scalar_ty.toIntern(),
-    });
-}
-
 const State = struct {
     registers: RegisterManager.TrackedRegisters,
     reg_tracking: [RegisterManager.RegisterBitSet.bit_length]InstTracking,
@@ -163835,12 +169364,12 @@ fn restoreState(self: *CodeGen, state: State, deaths: []const Air.Inst.Index, co
         for (
             self.inst_tracking.keys()[@intFromEnum(state.next_temp_index)..@intFromEnum(self.next_temp_index)],
             self.inst_tracking.values()[@intFromEnum(state.next_temp_index)..@intFromEnum(self.next_temp_index)],
-        ) |inst, *tracking| try tracking.die(self, inst);
+        ) |inst, *tracking| try tracking.die(self, inst, .{ .emit_instructions = opts.emit_instructions });
         self.next_temp_index = state.next_temp_index;
         for (
             self.inst_tracking.keys()[state.inst_tracking_len..],
             self.inst_tracking.values()[state.inst_tracking_len..],
-        ) |inst, *tracking| try tracking.die(self, inst);
+        ) |inst, *tracking| try tracking.die(self, inst, .{ .emit_instructions = opts.emit_instructions });
         self.inst_tracking.shrinkRetainingCapacity(state.inst_tracking_len);
     }
 
@@ -163854,7 +169383,7 @@ fn restoreState(self: *CodeGen, state: State, deaths: []const Air.Inst.Index, co
             self.inst_tracking.values()[Temp.Index.max..state.inst_tracking_len],
         ) |inst, *tracking| try tracking.resurrect(self, inst, state.scope_generation);
     }
-    for (deaths) |death| try self.processDeath(death);
+    for (deaths) |death| try self.processDeath(death, .{ .emit_instructions = opts.emit_instructions });
 
     const ExpectedContents = [@typeInfo(RegisterManager.TrackedRegisters).array.len]RegisterLock;
     var stack align(@max(@alignOf(ExpectedContents), @alignOf(std.heap.StackFallbackAllocator(0)))) =
@@ -163993,9 +169522,9 @@ fn airRetPtr(self: *CodeGen, inst: Air.Inst.Index) !void {
 fn airFptrunc(self: *CodeGen, inst: Air.Inst.Index) !void {
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const dst_ty = self.typeOfIndex(inst);
-    const dst_bits = dst_ty.floatBits(self.target.*);
+    const dst_bits = dst_ty.floatBits(self.target);
     const src_ty = self.typeOf(ty_op.operand);
-    const src_bits = src_ty.floatBits(self.target.*);
+    const src_bits = src_ty.floatBits(self.target);
 
     const result = result: {
         if (switch (dst_bits) {
@@ -164095,10 +169624,10 @@ fn airFpext(self: *CodeGen, inst: Air.Inst.Index) !void {
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const dst_ty = self.typeOfIndex(inst);
     const dst_scalar_ty = dst_ty.scalarType(zcu);
-    const dst_bits = dst_scalar_ty.floatBits(self.target.*);
+    const dst_bits = dst_scalar_ty.floatBits(self.target);
     const src_ty = self.typeOf(ty_op.operand);
     const src_scalar_ty = src_ty.scalarType(zcu);
-    const src_bits = src_scalar_ty.floatBits(self.target.*);
+    const src_bits = src_scalar_ty.floatBits(self.target);
 
     const result = result: {
         if (switch (src_bits) {
@@ -168207,7 +173736,7 @@ fn floatSign(self: *CodeGen, inst: Air.Inst.Index, tag: Air.Inst.Tag, operand: A
     const zcu = pt.zcu;
 
     const result = result: {
-        const scalar_bits = ty.scalarType(zcu).floatBits(self.target.*);
+        const scalar_bits = ty.scalarType(zcu).floatBits(self.target);
         if (scalar_bits == 80) {
             if (ty.zigTypeTag(zcu) != .float) return self.fail("TODO implement floatSign for {}", .{
                 ty.fmt(pt),
@@ -168363,14 +173892,14 @@ fn getRoundTag(self: *CodeGen, ty: Type) ?Mir.Inst.FixedTag {
     const pt = self.pt;
     const zcu = pt.zcu;
     return if (self.hasFeature(.sse4_1)) switch (ty.zigTypeTag(zcu)) {
-        .float => switch (ty.floatBits(self.target.*)) {
+        .float => switch (ty.floatBits(self.target)) {
             32 => if (self.hasFeature(.avx)) .{ .v_ss, .round } else .{ ._ss, .round },
             64 => if (self.hasFeature(.avx)) .{ .v_sd, .round } else .{ ._sd, .round },
             16, 80, 128 => null,
             else => unreachable,
         },
         .vector => switch (ty.childType(zcu).zigTypeTag(zcu)) {
-            .float => switch (ty.childType(zcu).floatBits(self.target.*)) {
+            .float => switch (ty.childType(zcu).floatBits(self.target)) {
                 32 => switch (ty.vectorLen(zcu)) {
                     1 => if (self.hasFeature(.avx)) .{ .v_ss, .round } else .{ ._ss, .round },
                     2...4 => if (self.hasFeature(.avx)) .{ .v_ps, .round } else .{ ._ps, .round },
@@ -168670,7 +174199,7 @@ fn airSqrt(self: *CodeGen, inst: Air.Inst.Index) !void {
     const result: MCValue = result: {
         switch (ty.zigTypeTag(zcu)) {
             .float => {
-                const float_bits = ty.floatBits(self.target.*);
+                const float_bits = ty.floatBits(self.target);
                 if (switch (float_bits) {
                     16 => !self.hasFeature(.f16c),
                     32, 64 => false,
@@ -168701,7 +174230,7 @@ fn airSqrt(self: *CodeGen, inst: Air.Inst.Index) !void {
         defer if (dst_lock) |lock| self.register_manager.unlockReg(lock);
 
         const mir_tag = @as(?Mir.Inst.FixedTag, switch (ty.zigTypeTag(zcu)) {
-            .float => switch (ty.floatBits(self.target.*)) {
+            .float => switch (ty.floatBits(self.target)) {
                 16 => {
                     assert(self.hasFeature(.f16c));
                     const mat_src_reg = if (src_mcv.isRegister())
@@ -168723,7 +174252,7 @@ fn airSqrt(self: *CodeGen, inst: Air.Inst.Index) !void {
                 else => unreachable,
             },
             .vector => switch (ty.childType(zcu).zigTypeTag(zcu)) {
-                .float => switch (ty.childType(zcu).floatBits(self.target.*)) {
+                .float => switch (ty.childType(zcu).floatBits(self.target)) {
                     16 => if (self.hasFeature(.f16c)) switch (ty.vectorLen(zcu)) {
                         1 => {
                             try self.asmRegisterRegister(
@@ -169028,6 +174557,7 @@ fn load(self: *CodeGen, dst_mcv: MCValue, ptr_ty: Type, ptr_mcv: MCValue) InnerE
         .register_quadruple,
         .register_overflow,
         .register_mask,
+        .indirect_load_frame,
         .elementwise_args,
         .reserved_frame,
         => unreachable, // not a valid pointer
@@ -169248,6 +174778,7 @@ fn store(
         .register_quadruple,
         .register_overflow,
         .register_mask,
+        .indirect_load_frame,
         .elementwise_args,
         .reserved_frame,
         => unreachable, // not a valid pointer
@@ -169307,31 +174838,6 @@ fn airStore(self: *CodeGen, inst: Air.Inst.Index, safety: bool) !void {
     return self.finishAir(inst, .none, .{ bin_op.lhs, bin_op.rhs, .none });
 }
 
-fn airStructFieldPtr(self: *CodeGen, inst: Air.Inst.Index) !void {
-    const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
-    const extra = self.air.extraData(Air.StructField, ty_pl.payload).data;
-    const result = try self.fieldPtr(inst, extra.struct_operand, extra.field_index);
-    return self.finishAir(inst, result, .{ extra.struct_operand, .none, .none });
-}
-
-fn airStructFieldPtrIndex(self: *CodeGen, inst: Air.Inst.Index, field_index: u8) !void {
-    const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
-    const result = try self.fieldPtr(inst, ty_op.operand, field_index);
-    return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
-}
-
-fn fieldPtr(self: *CodeGen, inst: Air.Inst.Index, operand: Air.Inst.Ref, field_index: u32) !MCValue {
-    const ptr_field_ty = self.typeOfIndex(inst);
-
-    const src_mcv = try self.resolveInst(operand);
-    const dst_mcv = if (switch (src_mcv) {
-        .immediate, .lea_frame => true,
-        .register, .register_offset => self.reuseOperand(inst, operand, 0, src_mcv),
-        else => false,
-    }) src_mcv else try self.copyToRegisterWithInstTracking(inst, ptr_field_ty, src_mcv);
-    return dst_mcv.offset(self.fieldOffset(self.typeOf(operand), ptr_field_ty, field_index));
-}
-
 fn fieldOffset(self: *CodeGen, ptr_agg_ty: Type, ptr_field_ty: Type, field_index: u32) i32 {
     const pt = self.pt;
     const zcu = pt.zcu;
@@ -169344,291 +174850,6 @@ fn fieldOffset(self: *CodeGen, ptr_agg_ty: Type, ptr_field_ty: Type, field_index
     };
 }
 
-fn airStructFieldVal(self: *CodeGen, inst: Air.Inst.Index) !void {
-    const pt = self.pt;
-    const zcu = pt.zcu;
-    const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
-    const extra = self.air.extraData(Air.StructField, ty_pl.payload).data;
-    const result: MCValue = result: {
-        const operand = extra.struct_operand;
-        const index = extra.field_index;
-
-        const container_ty = self.typeOf(operand);
-        const container_rc = self.regSetForType(container_ty);
-        const field_ty = container_ty.fieldType(index, zcu);
-        if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result .none;
-        const field_rc = self.regSetForType(field_ty);
-        const field_is_gp = field_rc.supersetOf(abi.RegisterClass.gp);
-
-        const src_mcv = try self.resolveInst(operand);
-        const field_off: u32 = switch (container_ty.containerLayout(zcu)) {
-            .auto, .@"extern" => @intCast(container_ty.structFieldOffset(extra.field_index, zcu) * 8),
-            .@"packed" => if (zcu.typeToStruct(container_ty)) |loaded_struct|
-                pt.structPackedFieldBitOffset(loaded_struct, extra.field_index)
-            else
-                0,
-        };
-
-        switch (src_mcv) {
-            .register => |src_reg| {
-                const src_reg_lock = self.register_manager.lockRegAssumeUnused(src_reg);
-                defer self.register_manager.unlockReg(src_reg_lock);
-
-                const src_in_field_rc =
-                    field_rc.isSet(RegisterManager.indexOfRegIntoTracked(src_reg).?);
-                const dst_reg = if (src_in_field_rc and self.reuseOperand(inst, operand, 0, src_mcv))
-                    src_reg
-                else if (field_off == 0)
-                    (try self.copyToRegisterWithInstTracking(inst, field_ty, src_mcv)).register
-                else
-                    try self.copyToTmpRegister(.usize, .{ .register = src_reg });
-                const dst_mcv: MCValue = .{ .register = dst_reg };
-                const dst_lock = self.register_manager.lockReg(dst_reg);
-                defer if (dst_lock) |lock| self.register_manager.unlockReg(lock);
-
-                if (field_off > 0) {
-                    try self.spillEflagsIfOccupied();
-                    try self.genShiftBinOpMir(.{ ._r, .sh }, .usize, dst_mcv, .u8, .{ .immediate = field_off });
-                }
-                if (abi.RegisterClass.gp.isSet(RegisterManager.indexOfRegIntoTracked(dst_reg).?) and
-                    container_ty.abiSize(zcu) * 8 > field_ty.bitSize(zcu))
-                    try self.truncateRegister(field_ty, dst_reg);
-
-                break :result if (field_off == 0 or field_rc.supersetOf(abi.RegisterClass.gp))
-                    dst_mcv
-                else
-                    try self.copyToRegisterWithInstTracking(inst, field_ty, dst_mcv);
-            },
-            .register_pair => |src_regs| {
-                const src_regs_lock = self.register_manager.lockRegsAssumeUnused(2, src_regs);
-                defer for (src_regs_lock) |lock| self.register_manager.unlockReg(lock);
-
-                const field_bit_size: u32 = @intCast(field_ty.bitSize(zcu));
-                const src_reg = if (field_off + field_bit_size <= 64)
-                    src_regs[0]
-                else if (field_off >= 64)
-                    src_regs[1]
-                else {
-                    const dst_regs: [2]Register = if (field_rc.supersetOf(container_rc) and
-                        self.reuseOperand(inst, operand, 0, src_mcv)) src_regs else dst: {
-                        const dst_regs =
-                            try self.register_manager.allocRegs(2, @splat(null), field_rc);
-                        const dst_locks = self.register_manager.lockRegsAssumeUnused(2, dst_regs);
-                        defer for (dst_locks) |lock| self.register_manager.unlockReg(lock);
-
-                        try self.genCopy(container_ty, .{ .register_pair = dst_regs }, src_mcv, .{});
-                        break :dst dst_regs;
-                    };
-                    const dst_mcv = MCValue{ .register_pair = dst_regs };
-                    const dst_locks = self.register_manager.lockRegs(2, dst_regs);
-                    defer for (dst_locks) |dst_lock| if (dst_lock) |lock|
-                        self.register_manager.unlockReg(lock);
-
-                    if (field_off > 0) {
-                        try self.spillEflagsIfOccupied();
-                        try self.genShiftBinOpMir(.{ ._r, .sh }, .u128, dst_mcv, .u8, .{ .immediate = field_off });
-                    }
-
-                    if (field_bit_size <= 64) {
-                        if (self.regExtraBits(field_ty) > 0)
-                            try self.truncateRegister(field_ty, dst_regs[0]);
-                        break :result if (field_rc.supersetOf(abi.RegisterClass.gp))
-                            .{ .register = dst_regs[0] }
-                        else
-                            try self.copyToRegisterWithInstTracking(inst, field_ty, .{
-                                .register = dst_regs[0],
-                            });
-                    }
-
-                    if (field_bit_size < 128) try self.truncateRegister(
-                        try pt.intType(.unsigned, @intCast(field_bit_size - 64)),
-                        dst_regs[1],
-                    );
-                    break :result if (field_rc.supersetOf(abi.RegisterClass.gp))
-                        dst_mcv
-                    else
-                        try self.copyToRegisterWithInstTracking(inst, field_ty, dst_mcv);
-                };
-
-                const dst_reg = try self.copyToTmpRegister(.usize, .{ .register = src_reg });
-                const dst_mcv = MCValue{ .register = dst_reg };
-                const dst_lock = self.register_manager.lockReg(dst_reg);
-                defer if (dst_lock) |lock| self.register_manager.unlockReg(lock);
-
-                if (field_off % 64 > 0) {
-                    try self.spillEflagsIfOccupied();
-                    try self.genShiftBinOpMir(.{ ._r, .sh }, .usize, dst_mcv, .u8, .{ .immediate = field_off % 64 });
-                }
-                if (self.regExtraBits(field_ty) > 0) try self.truncateRegister(field_ty, dst_reg);
-
-                break :result if (field_rc.supersetOf(abi.RegisterClass.gp))
-                    dst_mcv
-                else
-                    try self.copyToRegisterWithInstTracking(inst, field_ty, dst_mcv);
-            },
-            .register_overflow => |ro| {
-                switch (index) {
-                    // Get wrapped value for overflow operation.
-                    0 => if (self.reuseOperand(inst, extra.struct_operand, 0, src_mcv)) {
-                        self.eflags_inst = null; // actually stop tracking the overflow part
-                        break :result .{ .register = ro.reg };
-                    } else break :result try self.copyToRegisterWithInstTracking(inst, .usize, .{ .register = ro.reg }),
-                    // Get overflow bit.
-                    1 => if (self.reuseOperandAdvanced(inst, extra.struct_operand, 0, src_mcv, null)) {
-                        self.eflags_inst = inst; // actually keep tracking the overflow part
-                        break :result .{ .eflags = ro.eflags };
-                    } else {
-                        const dst_reg = try self.register_manager.allocReg(inst, abi.RegisterClass.gp);
-                        try self.asmSetccRegister(ro.eflags, dst_reg.to8());
-                        break :result .{ .register = dst_reg.to8() };
-                    },
-                    else => unreachable,
-                }
-            },
-            .load_frame => |frame_addr| {
-                const field_abi_size: u32 = @intCast(field_ty.abiSize(zcu));
-                if (field_off % 8 == 0) {
-                    const field_byte_off = @divExact(field_off, 8);
-                    const off_mcv = src_mcv.address().offset(@intCast(field_byte_off)).deref();
-                    const field_bit_size = field_ty.bitSize(zcu);
-
-                    if (field_abi_size <= 8) {
-                        const int_ty = try pt.intType(
-                            if (field_ty.isAbiInt(zcu)) field_ty.intInfo(zcu).signedness else .unsigned,
-                            @intCast(field_bit_size),
-                        );
-
-                        const dst_reg = try self.register_manager.allocReg(
-                            if (field_is_gp) inst else null,
-                            abi.RegisterClass.gp,
-                        );
-                        const dst_mcv = MCValue{ .register = dst_reg };
-                        const dst_lock = self.register_manager.lockRegAssumeUnused(dst_reg);
-                        defer self.register_manager.unlockReg(dst_lock);
-
-                        try self.genCopy(int_ty, dst_mcv, off_mcv, .{});
-                        if (self.regExtraBits(field_ty) > 0) try self.truncateRegister(int_ty, dst_reg);
-                        break :result if (field_is_gp)
-                            dst_mcv
-                        else
-                            try self.copyToRegisterWithInstTracking(inst, field_ty, dst_mcv);
-                    }
-
-                    const container_abi_size: u32 = @intCast(container_ty.abiSize(zcu));
-                    const dst_mcv = if (field_byte_off + field_abi_size <= container_abi_size and
-                        self.reuseOperand(inst, operand, 0, src_mcv))
-                        off_mcv
-                    else dst: {
-                        const dst_mcv = try self.allocRegOrMem(inst, true);
-                        try self.genCopy(field_ty, dst_mcv, off_mcv, .{});
-                        break :dst dst_mcv;
-                    };
-                    if (field_abi_size * 8 > field_bit_size and dst_mcv.isBase()) {
-                        const tmp_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);
-                        const tmp_lock = self.register_manager.lockRegAssumeUnused(tmp_reg);
-                        defer self.register_manager.unlockReg(tmp_lock);
-
-                        const hi_mcv =
-                            dst_mcv.address().offset(@intCast(field_bit_size / 64 * 8)).deref();
-                        try self.genSetReg(tmp_reg, .usize, hi_mcv, .{});
-                        try self.truncateRegister(field_ty, tmp_reg);
-                        try self.genCopy(.usize, hi_mcv, .{ .register = tmp_reg }, .{});
-                    }
-                    break :result dst_mcv;
-                }
-
-                const limb_abi_size: u31 = @min(field_abi_size, 8);
-                const limb_abi_bits = limb_abi_size * 8;
-                const field_byte_off: i32 = @intCast(field_off / limb_abi_bits * limb_abi_size);
-                const field_bit_off = field_off % limb_abi_bits;
-
-                if (field_abi_size > 8) {
-                    return self.fail("TODO implement struct_field_val with large packed field", .{});
-                }
-
-                const dst_reg = try self.register_manager.allocReg(
-                    if (field_is_gp) inst else null,
-                    abi.RegisterClass.gp,
-                );
-                const field_extra_bits = self.regExtraBits(field_ty);
-                const load_abi_size =
-                    if (field_bit_off < field_extra_bits) field_abi_size else field_abi_size * 2;
-                if (load_abi_size <= 8) {
-                    const load_reg = registerAlias(dst_reg, load_abi_size);
-                    try self.asmRegisterMemory(.{ ._, .mov }, load_reg, .{
-                        .base = .{ .frame = frame_addr.index },
-                        .mod = .{ .rm = .{
-                            .size = .fromSize(load_abi_size),
-                            .disp = frame_addr.off + field_byte_off,
-                        } },
-                    });
-                    try self.spillEflagsIfOccupied();
-                    try self.asmRegisterImmediate(.{ ._r, .sh }, load_reg, .u(field_bit_off));
-                } else {
-                    const tmp_reg = registerAlias(
-                        try self.register_manager.allocReg(null, abi.RegisterClass.gp),
-                        field_abi_size,
-                    );
-                    const tmp_lock = self.register_manager.lockRegAssumeUnused(tmp_reg);
-                    defer self.register_manager.unlockReg(tmp_lock);
-
-                    const dst_alias = registerAlias(dst_reg, field_abi_size);
-                    try self.asmRegisterMemory(
-                        .{ ._, .mov },
-                        dst_alias,
-                        .{
-                            .base = .{ .frame = frame_addr.index },
-                            .mod = .{ .rm = .{
-                                .size = .fromSize(field_abi_size),
-                                .disp = frame_addr.off + field_byte_off,
-                            } },
-                        },
-                    );
-                    try self.asmRegisterMemory(.{ ._, .mov }, tmp_reg, .{
-                        .base = .{ .frame = frame_addr.index },
-                        .mod = .{ .rm = .{
-                            .size = .fromSize(field_abi_size),
-                            .disp = frame_addr.off + field_byte_off + limb_abi_size,
-                        } },
-                    });
-                    try self.spillEflagsIfOccupied();
-                    try self.asmRegisterRegisterImmediate(
-                        .{ ._rd, .sh },
-                        dst_alias,
-                        tmp_reg,
-                        .u(field_bit_off),
-                    );
-                }
-
-                if (field_extra_bits > 0) try self.truncateRegister(field_ty, dst_reg);
-
-                const dst_mcv = MCValue{ .register = dst_reg };
-                break :result if (field_is_gp)
-                    dst_mcv
-                else
-                    try self.copyToRegisterWithInstTracking(inst, field_ty, dst_mcv);
-            },
-            else => return self.fail("TODO implement airStructFieldVal for {}", .{src_mcv}),
-        }
-    };
-    return self.finishAir(inst, result, .{ extra.struct_operand, .none, .none });
-}
-
-fn airFieldParentPtr(self: *CodeGen, inst: Air.Inst.Index) !void {
-    const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
-    const extra = self.air.extraData(Air.FieldParentPtr, ty_pl.payload).data;
-
-    const ptr_agg_ty = self.typeOfIndex(inst);
-    const src_mcv = try self.resolveInst(extra.field_ptr);
-    const dst_mcv = if (src_mcv.isRegisterOffset() and
-        self.reuseOperand(inst, extra.field_ptr, 0, src_mcv))
-        src_mcv
-    else
-        try self.copyToRegisterWithInstTracking(inst, ptr_agg_ty, src_mcv);
-    const result = dst_mcv.offset(-self.fieldOffset(ptr_agg_ty, self.typeOf(extra.field_ptr), extra.field_index));
-    return self.finishAir(inst, result, .{ extra.field_ptr, .none, .none });
-}
-
 fn genUnOp(self: *CodeGen, maybe_inst: ?Air.Inst.Index, tag: Air.Inst.Tag, src_air: Air.Inst.Ref) !MCValue {
     const pt = self.pt;
     const zcu = pt.zcu;
@@ -169732,6 +174953,7 @@ fn genUnOpMir(self: *CodeGen, mir_tag: Mir.Inst.FixedTag, dst_ty: Type, dst_mcv:
         .eflags,
         .register_overflow,
         .register_mask,
+        .indirect_load_frame,
         .lea_frame,
         .lea_nav,
         .lea_uav,
@@ -170401,495 +175623,6 @@ fn genShiftBinOpMir(
     });
 }
 
-/// Result is always a register.
-/// Clobbers .rcx for non-immediate rhs, therefore care is needed to spill .rcx upfront.
-/// Asserts .rcx is free.
-fn genShiftBinOp(
-    self: *CodeGen,
-    air_tag: Air.Inst.Tag,
-    maybe_inst: ?Air.Inst.Index,
-    lhs_mcv: MCValue,
-    rhs_mcv: MCValue,
-    lhs_ty: Type,
-    rhs_ty: Type,
-) !MCValue {
-    const pt = self.pt;
-    const zcu = pt.zcu;
-    if (lhs_ty.zigTypeTag(zcu) == .vector) return self.fail("TODO implement genShiftBinOp for {}", .{
-        lhs_ty.fmt(pt),
-    });
-
-    try self.register_manager.getKnownReg(.rcx, null);
-    const rcx_lock = self.register_manager.lockReg(.rcx);
-    defer if (rcx_lock) |lock| self.register_manager.unlockReg(lock);
-
-    const mat_lhs_mcv: MCValue, const can_reuse_lhs = switch (lhs_mcv) {
-        .register => |lhs_reg| switch (lhs_reg.class()) {
-            .general_purpose => .{ lhs_mcv, true },
-            else => lhs: {
-                const mat_lhs_mcv = try self.allocTempRegOrMem(lhs_ty, true);
-                try self.genCopy(lhs_ty, mat_lhs_mcv, lhs_mcv, .{});
-                break :lhs .{ mat_lhs_mcv, false };
-            },
-        },
-        else => .{ lhs_mcv, true },
-    };
-    const lhs_lock = switch (mat_lhs_mcv) {
-        .register => |reg| self.register_manager.lockReg(reg),
-        else => null,
-    };
-    defer if (lhs_lock) |lock| self.register_manager.unlockReg(lock);
-
-    const rhs_lock = switch (rhs_mcv) {
-        .register => |reg| self.register_manager.lockReg(reg),
-        else => null,
-    };
-    defer if (rhs_lock) |lock| self.register_manager.unlockReg(lock);
-
-    const dst_mcv: MCValue = dst: {
-        if (can_reuse_lhs) if (maybe_inst) |inst| {
-            const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
-            if (self.reuseOperand(inst, bin_op.lhs, 0, mat_lhs_mcv)) break :dst mat_lhs_mcv;
-        };
-        const dst_mcv = try self.allocRegOrMemAdvanced(lhs_ty, maybe_inst, true);
-        try self.genCopy(lhs_ty, dst_mcv, mat_lhs_mcv, .{});
-        break :dst dst_mcv;
-    };
-
-    const signedness = lhs_ty.intInfo(zcu).signedness;
-    try self.genShiftBinOpMir(switch (air_tag) {
-        .shl, .shl_exact => switch (signedness) {
-            .signed => .{ ._l, .sa },
-            .unsigned => .{ ._l, .sh },
-        },
-        .shr, .shr_exact => switch (signedness) {
-            .signed => .{ ._r, .sa },
-            .unsigned => .{ ._r, .sh },
-        },
-        else => unreachable,
-    }, lhs_ty, dst_mcv, rhs_ty, rhs_mcv);
-    return dst_mcv;
-}
-
-/// Result is always a register.
-/// Clobbers .rax and .rdx therefore care is needed to spill .rax and .rdx upfront.
-/// Asserts .rax and .rdx are free.
-fn genMulDivBinOp(
-    self: *CodeGen,
-    tag: Air.Inst.Tag,
-    maybe_inst: ?Air.Inst.Index,
-    dst_ty: Type,
-    src_ty: Type,
-    lhs_mcv: MCValue,
-    rhs_mcv: MCValue,
-) !MCValue {
-    const pt = self.pt;
-    const zcu = pt.zcu;
-    if (dst_ty.zigTypeTag(zcu) == .vector or dst_ty.zigTypeTag(zcu) == .float) return self.fail(
-        "TODO implement genMulDivBinOp for {s} from {} to {}",
-        .{ @tagName(tag), src_ty.fmt(pt), dst_ty.fmt(pt) },
-    );
-    const dst_abi_size: u32 = @intCast(dst_ty.abiSize(zcu));
-    const src_abi_size: u32 = @intCast(src_ty.abiSize(zcu));
-
-    assert(self.register_manager.isRegFree(.rax));
-    assert(self.register_manager.isRegFree(.rcx));
-    assert(self.register_manager.isRegFree(.rdx));
-    assert(self.eflags_inst == null);
-
-    if (dst_abi_size == 16 and src_abi_size == 16) {
-        assert(tag == .mul or tag == .mul_wrap);
-        const reg_locks = self.register_manager.lockRegs(2, .{ .rax, .rdx });
-        defer for (reg_locks) |reg_lock| if (reg_lock) |lock| self.register_manager.unlockReg(lock);
-
-        const mat_lhs_mcv = switch (lhs_mcv) {
-            .load_nav, .load_uav, .load_lazy_sym => mat_lhs_mcv: {
-                // TODO clean this up!
-                const addr_reg = try self.copyToTmpRegister(.usize, lhs_mcv.address());
-                break :mat_lhs_mcv MCValue{ .indirect = .{ .reg = addr_reg } };
-            },
-            else => lhs_mcv,
-        };
-        const mat_lhs_lock = switch (mat_lhs_mcv) {
-            .indirect => |reg_off| self.register_manager.lockReg(reg_off.reg),
-            else => null,
-        };
-        defer if (mat_lhs_lock) |lock| self.register_manager.unlockReg(lock);
-        const mat_rhs_mcv = switch (rhs_mcv) {
-            .load_nav, .load_uav, .load_lazy_sym => mat_rhs_mcv: {
-                // TODO clean this up!
-                const addr_reg = try self.copyToTmpRegister(.usize, rhs_mcv.address());
-                break :mat_rhs_mcv MCValue{ .indirect = .{ .reg = addr_reg } };
-            },
-            else => rhs_mcv,
-        };
-        const mat_rhs_lock = switch (mat_rhs_mcv) {
-            .indirect => |reg_off| self.register_manager.lockReg(reg_off.reg),
-            else => null,
-        };
-        defer if (mat_rhs_lock) |lock| self.register_manager.unlockReg(lock);
-
-        const tmp_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);
-        const tmp_lock = self.register_manager.lockRegAssumeUnused(tmp_reg);
-        defer self.register_manager.unlockReg(tmp_lock);
-
-        if (mat_lhs_mcv.isBase())
-            try self.asmRegisterMemory(.{ ._, .mov }, .rax, try mat_lhs_mcv.mem(self, .{ .size = .qword }))
-        else
-            try self.asmRegisterRegister(.{ ._, .mov }, .rax, mat_lhs_mcv.register_pair[0]);
-        if (mat_rhs_mcv.isBase()) try self.asmRegisterMemory(
-            .{ ._, .mov },
-            tmp_reg,
-            try mat_rhs_mcv.address().offset(8).deref().mem(self, .{ .size = .qword }),
-        ) else try self.asmRegisterRegister(.{ ._, .mov }, tmp_reg, mat_rhs_mcv.register_pair[1]);
-        try self.asmRegisterRegister(.{ .i_, .mul }, tmp_reg, .rax);
-        if (mat_rhs_mcv.isBase())
-            try self.asmMemory(.{ ._, .mul }, try mat_rhs_mcv.mem(self, .{ .size = .qword }))
-        else
-            try self.asmRegister(.{ ._, .mul }, mat_rhs_mcv.register_pair[0]);
-        try self.asmRegisterRegister(.{ ._, .add }, .rdx, tmp_reg);
-        if (mat_lhs_mcv.isBase()) try self.asmRegisterMemory(
-            .{ ._, .mov },
-            tmp_reg,
-            try mat_lhs_mcv.address().offset(8).deref().mem(self, .{ .size = .qword }),
-        ) else try self.asmRegisterRegister(.{ ._, .mov }, tmp_reg, mat_lhs_mcv.register_pair[1]);
-        if (mat_rhs_mcv.isBase())
-            try self.asmRegisterMemory(.{ .i_, .mul }, tmp_reg, try mat_rhs_mcv.mem(self, .{ .size = .qword }))
-        else
-            try self.asmRegisterRegister(.{ .i_, .mul }, tmp_reg, mat_rhs_mcv.register_pair[0]);
-        try self.asmRegisterRegister(.{ ._, .add }, .rdx, tmp_reg);
-        return .{ .register_pair = .{ .rax, .rdx } };
-    }
-
-    if (switch (tag) {
-        else => unreachable,
-        .mul, .mul_wrap => dst_abi_size != src_abi_size and dst_abi_size != src_abi_size * 2,
-        .div_trunc, .div_floor, .div_exact, .rem, .mod => dst_abi_size != src_abi_size,
-    } or src_abi_size > 8) {
-        const src_info = src_ty.intInfo(zcu);
-        switch (tag) {
-            .mul, .mul_wrap => {
-                const slow_inc = self.hasFeature(.slow_incdec);
-                const limb_len = std.math.divCeil(u32, src_abi_size, 8) catch unreachable;
-
-                try self.spillRegisters(&.{ .rax, .rcx, .rdx });
-                const reg_locks = self.register_manager.lockRegs(3, .{ .rax, .rcx, .rdx });
-                defer for (reg_locks) |reg_lock| if (reg_lock) |lock|
-                    self.register_manager.unlockReg(lock);
-
-                const dst_mcv = try self.allocRegOrMemAdvanced(dst_ty, maybe_inst, false);
-                try self.genInlineMemset(
-                    dst_mcv.address(),
-                    .{ .immediate = 0 },
-                    .{ .immediate = src_abi_size },
-                    .{},
-                );
-
-                const temp_regs =
-                    try self.register_manager.allocRegs(4, @splat(null), abi.RegisterClass.gp);
-                const temp_locks = self.register_manager.lockRegsAssumeUnused(4, temp_regs);
-                defer for (temp_locks) |lock| self.register_manager.unlockReg(lock);
-
-                try self.asmRegisterRegister(.{ ._, .xor }, temp_regs[0].to32(), temp_regs[0].to32());
-
-                const outer_loop: Mir.Inst.Index = @intCast(self.mir_instructions.len);
-                try self.asmRegisterMemory(.{ ._, .mov }, temp_regs[1].to64(), .{
-                    .base = .{ .frame = rhs_mcv.load_frame.index },
-                    .mod = .{ .rm = .{
-                        .size = .qword,
-                        .index = temp_regs[0].to64(),
-                        .scale = .@"8",
-                        .disp = rhs_mcv.load_frame.off,
-                    } },
-                });
-                try self.asmRegisterRegister(.{ ._, .@"test" }, temp_regs[1].to64(), temp_regs[1].to64());
-                const skip_inner = try self.asmJccReloc(.z, undefined);
-
-                try self.asmRegisterRegister(.{ ._, .xor }, temp_regs[2].to32(), temp_regs[2].to32());
-                try self.asmRegisterRegister(.{ ._, .mov }, temp_regs[3].to32(), temp_regs[0].to32());
-                try self.asmRegisterRegister(.{ ._, .xor }, .ecx, .ecx);
-                try self.asmRegisterRegister(.{ ._, .xor }, .edx, .edx);
-
-                const inner_loop: Mir.Inst.Index = @intCast(self.mir_instructions.len);
-                try self.asmRegisterImmediate(.{ ._r, .sh }, .cl, .u(1));
-                try self.asmMemoryRegister(.{ ._, .adc }, .{
-                    .base = .{ .frame = dst_mcv.load_frame.index },
-                    .mod = .{ .rm = .{
-                        .size = .qword,
-                        .index = temp_regs[3].to64(),
-                        .scale = .@"8",
-                        .disp = dst_mcv.load_frame.off,
-                    } },
-                }, .rdx);
-                try self.asmSetccRegister(.c, .cl);
-
-                try self.asmRegisterMemory(.{ ._, .mov }, .rax, .{
-                    .base = .{ .frame = lhs_mcv.load_frame.index },
-                    .mod = .{ .rm = .{
-                        .size = .qword,
-                        .index = temp_regs[2].to64(),
-                        .scale = .@"8",
-                        .disp = lhs_mcv.load_frame.off,
-                    } },
-                });
-                try self.asmRegister(.{ ._, .mul }, temp_regs[1].to64());
-
-                try self.asmRegisterImmediate(.{ ._r, .sh }, .ch, .u(1));
-                try self.asmMemoryRegister(.{ ._, .adc }, .{
-                    .base = .{ .frame = dst_mcv.load_frame.index },
-                    .mod = .{ .rm = .{
-                        .size = .qword,
-                        .index = temp_regs[3].to64(),
-                        .scale = .@"8",
-                        .disp = dst_mcv.load_frame.off,
-                    } },
-                }, .rax);
-                try self.asmSetccRegister(.c, .ch);
-
-                if (slow_inc) {
-                    try self.asmRegisterImmediate(.{ ._, .add }, temp_regs[2].to32(), .u(1));
-                    try self.asmRegisterImmediate(.{ ._, .add }, temp_regs[3].to32(), .u(1));
-                } else {
-                    try self.asmRegister(.{ ._c, .in }, temp_regs[2].to32());
-                    try self.asmRegister(.{ ._c, .in }, temp_regs[3].to32());
-                }
-                try self.asmRegisterImmediate(.{ ._, .cmp }, temp_regs[3].to32(), .u(limb_len));
-                _ = try self.asmJccReloc(.b, inner_loop);
-
-                self.performReloc(skip_inner);
-                if (slow_inc) {
-                    try self.asmRegisterImmediate(.{ ._, .add }, temp_regs[0].to32(), .u(1));
-                } else {
-                    try self.asmRegister(.{ ._c, .in }, temp_regs[0].to32());
-                }
-                try self.asmRegisterImmediate(.{ ._, .cmp }, temp_regs[0].to32(), .u(limb_len));
-                _ = try self.asmJccReloc(.b, outer_loop);
-
-                return dst_mcv;
-            },
-            .div_trunc, .div_floor, .div_exact, .rem, .mod => switch (src_info.signedness) {
-                .signed => {},
-                .unsigned => {
-                    const dst_mcv = try self.allocRegOrMemAdvanced(dst_ty, maybe_inst, false);
-                    const manyptr_u32_ty = try pt.ptrType(.{
-                        .child = .u32_type,
-                        .flags = .{
-                            .size = .many,
-                        },
-                    });
-                    const manyptr_const_u32_ty = try pt.ptrType(.{
-                        .child = .u32_type,
-                        .flags = .{
-                            .size = .many,
-                            .is_const = true,
-                        },
-                    });
-                    _ = try self.genCall(.{ .extern_func = .{
-                        .return_type = .void_type,
-                        .param_types = &.{
-                            manyptr_u32_ty.toIntern(),
-                            manyptr_const_u32_ty.toIntern(),
-                            manyptr_const_u32_ty.toIntern(),
-                            .usize_type,
-                        },
-                        .sym = switch (tag) {
-                            .div_trunc,
-                            .div_floor,
-                            .div_exact,
-                            => "__udivei4",
-                            .rem,
-                            .mod,
-                            => "__umodei4",
-                            else => unreachable,
-                        },
-                    } }, &.{
-                        manyptr_u32_ty,
-                        manyptr_const_u32_ty,
-                        manyptr_const_u32_ty,
-                        .usize,
-                    }, &.{
-                        dst_mcv.address(),
-                        lhs_mcv.address(),
-                        rhs_mcv.address(),
-                        .{ .immediate = 8 * src_abi_size },
-                    }, .{});
-                    return dst_mcv;
-                },
-            },
-            else => {},
-        }
-        return self.fail(
-            "TODO implement genMulDivBinOp for {s} from {} to {}",
-            .{ @tagName(tag), src_ty.fmt(pt), dst_ty.fmt(pt) },
-        );
-    }
-    const ty = if (dst_abi_size <= 8) dst_ty else src_ty;
-    const abi_size = if (dst_abi_size <= 8) dst_abi_size else src_abi_size;
-
-    const reg_locks = self.register_manager.lockRegs(2, .{ .rax, .rdx });
-    defer for (reg_locks) |reg_lock| if (reg_lock) |lock| self.register_manager.unlockReg(lock);
-
-    const int_info = ty.intInfo(zcu);
-    const signedness = int_info.signedness;
-    switch (tag) {
-        .mul,
-        .mul_wrap,
-        .rem,
-        .div_trunc,
-        .div_exact,
-        => {
-            const track_inst_rax = switch (tag) {
-                .mul, .mul_wrap => if (dst_abi_size <= 8) maybe_inst else null,
-                .div_exact, .div_trunc => maybe_inst,
-                else => null,
-            };
-            const track_inst_rdx = switch (tag) {
-                .rem => maybe_inst,
-                else => null,
-            };
-            try self.register_manager.getKnownReg(.rax, track_inst_rax);
-            try self.register_manager.getKnownReg(.rdx, track_inst_rdx);
-
-            try self.genIntMulDivOpMir(switch (signedness) {
-                .signed => switch (tag) {
-                    .mul, .mul_wrap => .{ .i_, .mul },
-                    .div_trunc, .div_exact, .rem => .{ .i_, .div },
-                    else => unreachable,
-                },
-                .unsigned => switch (tag) {
-                    .mul, .mul_wrap => .{ ._, .mul },
-                    .div_trunc, .div_exact, .rem => .{ ._, .div },
-                    else => unreachable,
-                },
-            }, ty, lhs_mcv, rhs_mcv);
-
-            switch (tag) {
-                .mul, .rem, .div_trunc, .div_exact => {},
-                .mul_wrap => if (dst_ty.intInfo(zcu).bits < 8 * dst_abi_size) try self.truncateRegister(
-                    dst_ty,
-                    if (dst_abi_size <= 8) .rax else .rdx,
-                ),
-                else => unreachable,
-            }
-
-            if (dst_abi_size <= 8) return .{ .register = registerAlias(switch (tag) {
-                .mul, .mul_wrap, .div_trunc, .div_exact => .rax,
-                .rem => .rdx,
-                else => unreachable,
-            }, dst_abi_size) };
-
-            const dst_mcv = try self.allocRegOrMemAdvanced(dst_ty, maybe_inst, false);
-            try self.asmMemoryRegister(.{ ._, .mov }, .{
-                .base = .{ .frame = dst_mcv.load_frame.index },
-                .mod = .{ .rm = .{
-                    .size = .qword,
-                    .disp = dst_mcv.load_frame.off,
-                } },
-            }, .rax);
-            try self.asmMemoryRegister(.{ ._, .mov }, .{
-                .base = .{ .frame = dst_mcv.load_frame.index },
-                .mod = .{ .rm = .{
-                    .size = .qword,
-                    .disp = dst_mcv.load_frame.off + 8,
-                } },
-            }, .rdx);
-            return dst_mcv;
-        },
-
-        .mod => {
-            try self.register_manager.getKnownReg(.rax, null);
-            try self.register_manager.getKnownReg(
-                .rdx,
-                if (signedness == .unsigned) maybe_inst else null,
-            );
-
-            switch (signedness) {
-                .signed => {
-                    const lhs_lock = switch (lhs_mcv) {
-                        .register => |reg| self.register_manager.lockReg(reg),
-                        else => null,
-                    };
-                    defer if (lhs_lock) |lock| self.register_manager.unlockReg(lock);
-                    const rhs_lock = switch (rhs_mcv) {
-                        .register => |reg| self.register_manager.lockReg(reg),
-                        else => null,
-                    };
-                    defer if (rhs_lock) |lock| self.register_manager.unlockReg(lock);
-
-                    // hack around hazard between rhs and div_floor by copying rhs to another register
-                    const rhs_copy = try self.copyToTmpRegister(ty, rhs_mcv);
-                    const rhs_copy_lock = self.register_manager.lockRegAssumeUnused(rhs_copy);
-                    defer self.register_manager.unlockReg(rhs_copy_lock);
-
-                    const div_floor = try self.genInlineIntDivFloor(ty, lhs_mcv, rhs_mcv);
-                    try self.genIntMulComplexOpMir(ty, div_floor, .{ .register = rhs_copy });
-                    const div_floor_lock = self.register_manager.lockReg(div_floor.register);
-                    defer if (div_floor_lock) |lock| self.register_manager.unlockReg(lock);
-
-                    const result: MCValue = if (maybe_inst) |inst|
-                        try self.copyToRegisterWithInstTracking(inst, ty, lhs_mcv)
-                    else
-                        .{ .register = try self.copyToTmpRegister(ty, lhs_mcv) };
-                    try self.genBinOpMir(.{ ._, .sub }, ty, result, div_floor);
-
-                    return result;
-                },
-                .unsigned => {
-                    try self.genIntMulDivOpMir(.{ ._, .div }, ty, lhs_mcv, rhs_mcv);
-                    return .{ .register = registerAlias(.rdx, abi_size) };
-                },
-            }
-        },
-
-        .div_floor => {
-            try self.register_manager.getKnownReg(
-                .rax,
-                if (signedness == .unsigned) maybe_inst else null,
-            );
-            try self.register_manager.getKnownReg(.rdx, null);
-
-            const lhs_lock: ?RegisterLock = switch (lhs_mcv) {
-                .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
-                else => null,
-            };
-            defer if (lhs_lock) |lock| self.register_manager.unlockReg(lock);
-
-            const actual_rhs_mcv: MCValue = blk: {
-                switch (signedness) {
-                    .signed => {
-                        const rhs_lock: ?RegisterLock = switch (rhs_mcv) {
-                            .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
-                            else => null,
-                        };
-                        defer if (rhs_lock) |lock| self.register_manager.unlockReg(lock);
-
-                        if (maybe_inst) |inst| {
-                            break :blk try self.copyToRegisterWithInstTracking(inst, ty, rhs_mcv);
-                        }
-                        break :blk MCValue{ .register = try self.copyToTmpRegister(ty, rhs_mcv) };
-                    },
-                    .unsigned => break :blk rhs_mcv,
-                }
-            };
-            const rhs_lock: ?RegisterLock = switch (actual_rhs_mcv) {
-                .register => |reg| self.register_manager.lockReg(reg),
-                else => null,
-            };
-            defer if (rhs_lock) |lock| self.register_manager.unlockReg(lock);
-
-            switch (signedness) {
-                .signed => return try self.genInlineIntDivFloor(ty, lhs_mcv, actual_rhs_mcv),
-                .unsigned => {
-                    try self.genIntMulDivOpMir(.{ ._, .div }, ty, lhs_mcv, actual_rhs_mcv);
-                    return .{ .register = registerAlias(.rax, abi_size) };
-                },
-            }
-        },
-
-        else => unreachable,
-    }
-}
-
 fn genBinOp(
     self: *CodeGen,
     maybe_inst: ?Air.Inst.Index,
@@ -170904,7 +175637,7 @@ fn genBinOp(
     const abi_size: u32 = @intCast(lhs_ty.abiSize(zcu));
 
     if (lhs_ty.isRuntimeFloat()) libcall: {
-        const float_bits = lhs_ty.floatBits(self.target.*);
+        const float_bits = lhs_ty.floatBits(self.target);
         const type_needs_libcall = switch (float_bits) {
             16 => !self.hasFeature(.f16c),
             32, 64 => false,
@@ -171083,7 +175816,7 @@ fn genBinOp(
         },
     };
     if (sse_op and ((lhs_ty.scalarType(zcu).isRuntimeFloat() and
-        lhs_ty.scalarType(zcu).floatBits(self.target.*) == 80) or
+        lhs_ty.scalarType(zcu).floatBits(self.target) == 80) or
         lhs_ty.abiSize(zcu) > self.vectorSize(.float)))
         return self.fail("TODO implement genBinOp for {s} {}", .{ @tagName(air_tag), lhs_ty.fmt(pt) });
 
@@ -171403,6 +176136,7 @@ fn genBinOp(
                         .register_offset,
                         .register_overflow,
                         .register_mask,
+                        .indirect_load_frame,
                         .lea_frame,
                         .load_nav,
                         .lea_nav,
@@ -171474,7 +176208,7 @@ fn genBinOp(
     const dst_reg = registerAlias(dst_mcv.getReg().?, abi_size);
     const mir_tag = @as(?Mir.Inst.FixedTag, switch (lhs_ty.zigTypeTag(zcu)) {
         else => unreachable,
-        .float => switch (lhs_ty.floatBits(self.target.*)) {
+        .float => switch (lhs_ty.floatBits(self.target)) {
             16 => {
                 assert(self.hasFeature(.f16c));
                 const lhs_reg = if (copied_to_dst) dst_reg else registerAlias(lhs_mcv.getReg().?, abi_size);
@@ -171917,7 +176651,7 @@ fn genBinOp(
                 },
                 else => null,
             },
-            .float => switch (lhs_ty.childType(zcu).floatBits(self.target.*)) {
+            .float => switch (lhs_ty.childType(zcu).floatBits(self.target)) {
                 16 => tag: {
                     assert(self.hasFeature(.f16c));
                     const lhs_reg = if (copied_to_dst) dst_reg else registerAlias(lhs_mcv.getReg().?, abi_size);
@@ -172238,7 +176972,7 @@ fn genBinOp(
                 lhs_reg,
                 try src_mcv.mem(self, .{ .size = switch (lhs_ty.zigTypeTag(zcu)) {
                     else => .fromSize(abi_size),
-                    .vector => .fromBitSize(dst_reg.bitSize()),
+                    .vector => dst_reg.size(),
                 } }),
             ) else try self.asmRegisterRegisterRegister(
                 mir_tag,
@@ -172256,7 +176990,7 @@ fn genBinOp(
                 dst_reg,
                 try src_mcv.mem(self, .{ .size = switch (lhs_ty.zigTypeTag(zcu)) {
                     else => .fromSize(abi_size),
-                    .vector => .fromBitSize(dst_reg.bitSize()),
+                    .vector => dst_reg.size(),
                 } }),
             ) else try self.asmRegisterRegister(
                 mir_tag,
@@ -172284,7 +177018,7 @@ fn genBinOp(
                     lhs_reg,
                     try src_mcv.mem(self, .{ .size = switch (lhs_ty.zigTypeTag(zcu)) {
                         else => .fromSize(abi_size),
-                        .vector => .fromBitSize(dst_reg.bitSize()),
+                        .vector => dst_reg.size(),
                     } }),
                     imm,
                 ) else try self.asmRegisterRegisterRegisterImmediate(
@@ -172304,7 +177038,7 @@ fn genBinOp(
                     dst_reg,
                     try src_mcv.mem(self, .{ .size = switch (lhs_ty.zigTypeTag(zcu)) {
                         else => .fromSize(abi_size),
-                        .vector => .fromBitSize(dst_reg.bitSize()),
+                        .vector => dst_reg.size(),
                     } }),
                     imm,
                 ) else try self.asmRegisterRegisterImmediate(
@@ -172321,29 +177055,20 @@ fn genBinOp(
     }
 
     switch (air_tag) {
-        .add, .add_wrap, .sub, .sub_wrap, .mul, .mul_wrap, .div_float, .div_exact => {},
-        .div_trunc, .div_floor => try self.genRound(lhs_ty, dst_reg, .{ .register = dst_reg }, .{
-            .direction = switch (air_tag) {
-                .div_trunc => .zero,
-                .div_floor => .down,
-                else => unreachable,
-            },
-            .precision = .inexact,
-        }),
         .bit_and, .bit_or, .xor => {},
         .max, .min => if (maybe_mask_reg) |mask_reg| if (self.hasFeature(.avx)) {
             const rhs_copy_reg = registerAlias(src_mcv.getReg().?, abi_size);
 
             try self.asmRegisterRegisterRegisterImmediate(
                 @as(?Mir.Inst.FixedTag, switch (lhs_ty.zigTypeTag(zcu)) {
-                    .float => switch (lhs_ty.floatBits(self.target.*)) {
+                    .float => switch (lhs_ty.floatBits(self.target)) {
                         32 => .{ .v_ss, .cmp },
                         64 => .{ .v_sd, .cmp },
                         16, 80, 128 => null,
                         else => unreachable,
                     },
                     .vector => switch (lhs_ty.childType(zcu).zigTypeTag(zcu)) {
-                        .float => switch (lhs_ty.childType(zcu).floatBits(self.target.*)) {
+                        .float => switch (lhs_ty.childType(zcu).floatBits(self.target)) {
                             32 => switch (lhs_ty.vectorLen(zcu)) {
                                 1 => .{ .v_ss, .cmp },
                                 2...8 => .{ .v_ps, .cmp },
@@ -172370,14 +177095,14 @@ fn genBinOp(
             );
             try self.asmRegisterRegisterRegisterRegister(
                 @as(?Mir.Inst.FixedTag, switch (lhs_ty.zigTypeTag(zcu)) {
-                    .float => switch (lhs_ty.floatBits(self.target.*)) {
+                    .float => switch (lhs_ty.floatBits(self.target)) {
                         32 => .{ .v_ps, .blendv },
                         64 => .{ .v_pd, .blendv },
                         16, 80, 128 => null,
                         else => unreachable,
                     },
                     .vector => switch (lhs_ty.childType(zcu).zigTypeTag(zcu)) {
-                        .float => switch (lhs_ty.childType(zcu).floatBits(self.target.*)) {
+                        .float => switch (lhs_ty.childType(zcu).floatBits(self.target)) {
                             32 => switch (lhs_ty.vectorLen(zcu)) {
                                 1...8 => .{ .v_ps, .blendv },
                                 else => null,
@@ -172404,14 +177129,14 @@ fn genBinOp(
             const has_blend = self.hasFeature(.sse4_1);
             try self.asmRegisterRegisterImmediate(
                 @as(?Mir.Inst.FixedTag, switch (lhs_ty.zigTypeTag(zcu)) {
-                    .float => switch (lhs_ty.floatBits(self.target.*)) {
+                    .float => switch (lhs_ty.floatBits(self.target)) {
                         32 => .{ ._ss, .cmp },
                         64 => .{ ._sd, .cmp },
                         16, 80, 128 => null,
                         else => unreachable,
                     },
                     .vector => switch (lhs_ty.childType(zcu).zigTypeTag(zcu)) {
-                        .float => switch (lhs_ty.childType(zcu).floatBits(self.target.*)) {
+                        .float => switch (lhs_ty.childType(zcu).floatBits(self.target)) {
                             32 => switch (lhs_ty.vectorLen(zcu)) {
                                 1 => .{ ._ss, .cmp },
                                 2...4 => .{ ._ps, .cmp },
@@ -172437,14 +177162,14 @@ fn genBinOp(
             );
             if (has_blend) try self.asmRegisterRegisterRegister(
                 @as(?Mir.Inst.FixedTag, switch (lhs_ty.zigTypeTag(zcu)) {
-                    .float => switch (lhs_ty.floatBits(self.target.*)) {
+                    .float => switch (lhs_ty.floatBits(self.target)) {
                         32 => .{ ._ps, .blendv },
                         64 => .{ ._pd, .blendv },
                         16, 80, 128 => null,
                         else => unreachable,
                     },
                     .vector => switch (lhs_ty.childType(zcu).zigTypeTag(zcu)) {
-                        .float => switch (lhs_ty.childType(zcu).floatBits(self.target.*)) {
+                        .float => switch (lhs_ty.childType(zcu).floatBits(self.target)) {
                             32 => switch (lhs_ty.vectorLen(zcu)) {
                                 1...4 => .{ ._ps, .blendv },
                                 else => null,
@@ -172467,14 +177192,14 @@ fn genBinOp(
                 mask_reg,
             ) else {
                 const mir_fixes = @as(?Mir.Inst.Fixes, switch (lhs_ty.zigTypeTag(zcu)) {
-                    .float => switch (lhs_ty.floatBits(self.target.*)) {
+                    .float => switch (lhs_ty.floatBits(self.target)) {
                         32 => ._ps,
                         64 => ._pd,
                         16, 80, 128 => null,
                         else => unreachable,
                     },
                     .vector => switch (lhs_ty.childType(zcu).zigTypeTag(zcu)) {
-                        .float => switch (lhs_ty.childType(zcu).floatBits(self.target.*)) {
+                        .float => switch (lhs_ty.childType(zcu).floatBits(self.target)) {
                             32 => switch (lhs_ty.vectorLen(zcu)) {
                                 1...4 => ._ps,
                                 else => null,
@@ -172596,6 +177321,7 @@ fn genBinOpMir(
         .lea_uav,
         .lea_lazy_sym,
         .lea_extern_func,
+        .indirect_load_frame,
         .elementwise_args,
         .reserved_frame,
         .air_ref,
@@ -172632,6 +177358,7 @@ fn genBinOpMir(
                     .undef,
                     .register_overflow,
                     .register_mask,
+                    .indirect_load_frame,
                     .elementwise_args,
                     .reserved_frame,
                     => unreachable,
@@ -172803,6 +177530,7 @@ fn genBinOpMir(
                 .undef,
                 .register_overflow,
                 .register_mask,
+                .indirect_load_frame,
                 .elementwise_args,
                 .reserved_frame,
                 .air_ref,
@@ -172906,6 +177634,7 @@ fn genBinOpMir(
                     .undef,
                     .register_overflow,
                     .register_mask,
+                    .indirect_load_frame,
                     .elementwise_args,
                     .reserved_frame,
                     .air_ref,
@@ -173036,6 +177765,7 @@ fn genIntMulComplexOpMir(self: *CodeGen, dst_ty: Type, dst_mcv: MCValue, src_mcv
         .register_offset,
         .register_overflow,
         .register_mask,
+        .indirect_load_frame,
         .lea_frame,
         .lea_nav,
         .lea_uav,
@@ -173073,6 +177803,7 @@ fn genIntMulComplexOpMir(self: *CodeGen, dst_ty: Type, dst_mcv: MCValue, src_mcv
                 .register_quadruple,
                 .register_overflow,
                 .register_mask,
+                .indirect_load_frame,
                 .elementwise_args,
                 .reserved_frame,
                 .air_ref,
@@ -173195,11 +177926,20 @@ fn airArg(self: *CodeGen, inst: Air.Inst.Index) !void {
                 break :result src_mcv;
             },
             .indirect => |reg_off| {
-                self.register_manager.getRegAssumeFree(reg_off.reg, inst);
+                self.register_manager.getRegAssumeFree(reg_off.reg, null);
                 const dst_mcv = try self.allocRegOrMem(inst, false);
                 try self.genCopy(arg_ty, dst_mcv, src_mcv, .{});
                 break :result dst_mcv;
             },
+            .indirect_load_frame => |frame_addr| {
+                const dst_mcv = try self.allocRegOrMem(inst, false);
+                const ptr_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);
+                const ptr_lock = self.register_manager.lockRegAssumeUnused(ptr_reg);
+                defer self.register_manager.unlockReg(ptr_lock);
+                try self.genSetReg(ptr_reg, .usize, .{ .load_frame = frame_addr }, .{});
+                try self.genCopy(arg_ty, dst_mcv, .{ .indirect = .{ .reg = ptr_reg } }, .{});
+                break :result dst_mcv;
+            },
             .elementwise_args => |regs_frame_addr| {
                 try self.spillEflagsIfOccupied();
 
@@ -173398,18 +178138,6 @@ fn genLocalDebugInfo(cg: *CodeGen, air_tag: Air.Inst.Tag, ty: Type, mcv: MCValue
     };
 }
 
-fn airRetAddr(self: *CodeGen, inst: Air.Inst.Index) !void {
-    const dst_mcv = try self.allocRegOrMem(inst, true);
-    try self.genCopy(.usize, dst_mcv, .{ .load_frame = .{ .index = .ret_addr } }, .{});
-    return self.finishAir(inst, dst_mcv, .{ .none, .none, .none });
-}
-
-fn airFrameAddress(self: *CodeGen, inst: Air.Inst.Index) !void {
-    const dst_mcv = try self.allocRegOrMem(inst, true);
-    try self.genCopy(.usize, dst_mcv, .{ .lea_frame = .{ .index = .base_ptr } }, .{});
-    return self.finishAir(inst, dst_mcv, .{ .none, .none, .none });
-}
-
 fn airCall(self: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModifier, opts: CopyOptions) !void {
     if (modifier == .always_tail) return self.fail("TODO implement tail calls for x86_64", .{});
 
@@ -173541,7 +178269,7 @@ fn genCall(self: *CodeGen, info: union(enum) {
             },
             .load_frame => {
                 try self.genCopy(arg_ty, dst_arg, src_arg, opts);
-                try self.freeValue(src_arg);
+                try self.freeValue(src_arg, .{});
             },
             .elementwise_args => |regs_frame_addr| {
                 const index_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);
@@ -173832,7 +178560,7 @@ fn airCmp(self: *CodeGen, inst: Air.Inst.Index, op: std.math.CompareOperator) !v
 
         switch (ty.zigTypeTag(zcu)) {
             .float => {
-                const float_bits = ty.floatBits(self.target.*);
+                const float_bits = ty.floatBits(self.target);
                 if (!switch (float_bits) {
                     16 => self.hasFeature(.f16c),
                     32 => self.hasFeature(.sse),
@@ -174188,7 +178916,7 @@ fn airCmp(self: *CodeGen, inst: Air.Inst.Index, op: std.math.CompareOperator) !v
                 defer if (dst_lock) |lock| self.register_manager.unlockReg(lock);
                 const src_mcv = if (flipped) lhs_mcv else rhs_mcv;
 
-                switch (ty.floatBits(self.target.*)) {
+                switch (ty.floatBits(self.target)) {
                     16 => {
                         assert(self.hasFeature(.f16c));
                         const tmp1_reg =
@@ -174265,39 +178993,6 @@ fn airCmpVector(self: *CodeGen, inst: Air.Inst.Index) !void {
     return self.finishAir(inst, dst_mcv, .{ extra.lhs, extra.rhs, .none });
 }
 
-fn airCmpLtErrorsLen(self: *CodeGen, inst: Air.Inst.Index) !void {
-    const pt = self.pt;
-    const zcu = pt.zcu;
-    const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
-
-    const addr_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);
-    const addr_lock = self.register_manager.lockRegAssumeUnused(addr_reg);
-    defer self.register_manager.unlockReg(addr_lock);
-    const anyerror_lazy_sym: link.File.LazySymbol = .{ .kind = .const_data, .ty = .anyerror_type };
-    try self.genLazySymbolRef(.lea, addr_reg, anyerror_lazy_sym);
-
-    try self.spillEflagsIfOccupied();
-
-    const op_ty = self.typeOf(un_op);
-    const op_abi_size: u32 = @intCast(op_ty.abiSize(zcu));
-    const op_mcv = try self.resolveInst(un_op);
-    const dst_reg = switch (op_mcv) {
-        .register => |reg| reg,
-        else => try self.copyToTmpRegister(op_ty, op_mcv),
-    };
-    try self.asmRegisterMemory(
-        .{ ._, .cmp },
-        registerAlias(dst_reg, op_abi_size),
-        .{
-            .base = .{ .reg = addr_reg },
-            .mod = .{ .rm = .{ .size = .fromSize(op_abi_size) } },
-        },
-    );
-
-    self.eflags_inst = inst;
-    return self.finishAir(inst, .{ .eflags = .b }, .{ un_op, .none, .none });
-}
-
 fn airTry(self: *CodeGen, inst: Air.Inst.Index) !void {
     const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
     const extra = self.air.extraData(Air.Try, pl_op.payload);
@@ -174335,12 +179030,12 @@ fn genTry(
     const reloc = try self.genCondBrMir(.anyerror, is_err_mcv);
 
     if (self.liveness.operandDies(inst, 0)) {
-        if (operand.toIndex()) |operand_inst| try self.processDeath(operand_inst);
+        if (operand.toIndex()) |operand_inst| try self.processDeath(operand_inst, .{});
     }
 
     const state = try self.saveState();
 
-    for (liveness_cond_br.else_deaths) |death| try self.processDeath(death);
+    for (liveness_cond_br.else_deaths) |death| try self.processDeath(death, .{});
     try self.genBodyBlock(body);
     try self.restoreState(state, &.{}, .{
         .emit_instructions = false,
@@ -174351,7 +179046,7 @@ fn genTry(
 
     self.performReloc(reloc);
 
-    for (liveness_cond_br.then_deaths) |death| try self.processDeath(death);
+    for (liveness_cond_br.then_deaths) |death| try self.processDeath(death, .{});
 
     const result = if (self.liveness.isUnused(inst))
         .unreach
@@ -174362,33 +179057,6 @@ fn genTry(
     return result;
 }
 
-fn airDbgVar(cg: *CodeGen, inst: Air.Inst.Index) !void {
-    if (cg.mod.strip) return;
-    const air_tag = cg.air.instructions.items(.tag)[@intFromEnum(inst)];
-    const pl_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
-    const air_name: Air.NullTerminatedString = @enumFromInt(pl_op.payload);
-    const op_ty = cg.typeOf(pl_op.operand);
-    const local_ty = switch (air_tag) {
-        else => unreachable,
-        .dbg_var_ptr => op_ty.childType(cg.pt.zcu),
-        .dbg_var_val, .dbg_arg_inline => op_ty,
-    };
-
-    try cg.mir_locals.append(cg.gpa, .{
-        .name = switch (air_name) {
-            .none => switch (air_tag) {
-                else => unreachable,
-                .dbg_arg_inline => .none,
-            },
-            else => try cg.addString(air_name.toSlice(cg.air)),
-        },
-        .type = local_ty.toIntern(),
-    });
-
-    try cg.genLocalDebugInfo(air_tag, local_ty, try cg.resolveInst(pl_op.operand));
-    return cg.finishAir(inst, .unreach, .{ pl_op.operand, .none, .none });
-}
-
 fn genCondBrMir(self: *CodeGen, ty: Type, mcv: MCValue) !Mir.Inst.Index {
     const pt = self.pt;
     const abi_size = ty.abiSize(pt.zcu);
@@ -174431,13 +179099,13 @@ fn airCondBr(self: *CodeGen, inst: Air.Inst.Index) !void {
     // that death now instead of later as this has an effect on
     // whether it needs to be spilled in the branches
     if (self.liveness.operandDies(inst, 0)) {
-        if (pl_op.operand.toIndex()) |op_inst| try self.processDeath(op_inst);
+        if (pl_op.operand.toIndex()) |op_inst| try self.processDeath(op_inst, .{});
     }
 
     const state = try self.saveState();
     const reloc = try self.genCondBrMir(cond_ty, cond);
 
-    for (liveness_cond_br.then_deaths) |death| try self.processDeath(death);
+    for (liveness_cond_br.then_deaths) |death| try self.processDeath(death, .{});
     try self.genBodyBlock(then_body);
     try self.restoreState(state, &.{}, .{
         .emit_instructions = false,
@@ -174448,7 +179116,7 @@ fn airCondBr(self: *CodeGen, inst: Air.Inst.Index) !void {
 
     self.performReloc(reloc);
 
-    for (liveness_cond_br.else_deaths) |death| try self.processDeath(death);
+    for (liveness_cond_br.else_deaths) |death| try self.processDeath(death, .{});
     try self.genBodyBlock(else_body);
     try self.restoreState(state, &.{}, .{
         .emit_instructions = false,
@@ -174460,177 +179128,6 @@ fn airCondBr(self: *CodeGen, inst: Air.Inst.Index) !void {
     // We already took care of pl_op.operand earlier, so there's nothing left to do.
 }
 
-fn isNull(self: *CodeGen, inst: Air.Inst.Index, opt_ty: Type, opt_mcv: MCValue) !MCValue {
-    const pt = self.pt;
-    const zcu = pt.zcu;
-    switch (opt_mcv) {
-        .register_overflow => |ro| return .{ .eflags = ro.eflags.negate() },
-        else => {},
-    }
-
-    try self.spillEflagsIfOccupied();
-
-    const pl_ty = opt_ty.optionalChild(zcu);
-
-    const some_info: struct { off: u31, ty: Type } = if (opt_ty.optionalReprIsPayload(zcu))
-        .{ .off = 0, .ty = if (pl_ty.isSlice(zcu)) pl_ty.slicePtrFieldType(zcu) else pl_ty }
-    else
-        .{ .off = @intCast(pl_ty.abiSize(zcu)), .ty = .bool };
-
-    self.eflags_inst = inst;
-    switch (opt_mcv) {
-        .none,
-        .unreach,
-        .dead,
-        .undef,
-        .immediate,
-        .eflags,
-        .register_triple,
-        .register_quadruple,
-        .register_offset,
-        .register_overflow,
-        .register_mask,
-        .lea_nav,
-        .lea_uav,
-        .lea_lazy_sym,
-        .lea_extern_func,
-        .elementwise_args,
-        .reserved_frame,
-        .air_ref,
-        => unreachable,
-
-        .lea_frame => {
-            self.eflags_inst = null;
-            return .{ .immediate = @intFromBool(false) };
-        },
-
-        .register => |opt_reg| {
-            if (some_info.off == 0) {
-                const some_abi_size: u32 = @intCast(some_info.ty.abiSize(zcu));
-                const alias_reg = registerAlias(opt_reg, some_abi_size);
-                assert(some_abi_size * 8 == alias_reg.bitSize());
-                try self.asmRegisterRegister(.{ ._, .@"test" }, alias_reg, alias_reg);
-                return .{ .eflags = .z };
-            }
-            assert(some_info.ty.ip_index == .bool_type);
-            const opt_abi_size: u32 = @intCast(opt_ty.abiSize(zcu));
-            try self.asmRegisterImmediate(
-                .{ ._, .bt },
-                registerAlias(opt_reg, opt_abi_size),
-                .u(@as(u6, @intCast(some_info.off * 8))),
-            );
-            return .{ .eflags = .nc };
-        },
-
-        .register_pair => |opt_regs| {
-            if (some_info.off == 0) {
-                const some_abi_size: u32 = @intCast(some_info.ty.abiSize(zcu));
-                const alias_reg = registerAlias(opt_regs[0], some_abi_size);
-                assert(some_abi_size * 8 == alias_reg.bitSize());
-                try self.asmRegisterRegister(.{ ._, .@"test" }, alias_reg, alias_reg);
-                return .{ .eflags = .z };
-            }
-            assert(some_info.ty.ip_index == .bool_type);
-            const opt_abi_size: u32 = @intCast(opt_ty.abiSize(zcu));
-            try self.asmRegisterImmediate(
-                .{ ._, .bt },
-                registerAlias(opt_regs[some_info.off / 8], opt_abi_size),
-                .u(@as(u6, @truncate(some_info.off * 8))),
-            );
-            return .{ .eflags = .nc };
-        },
-
-        .memory,
-        .load_nav,
-        .load_uav,
-        .load_lazy_sym,
-        .load_extern_func,
-        => {
-            const addr_reg = (try self.register_manager.allocReg(null, abi.RegisterClass.gp)).to64();
-            const addr_reg_lock = self.register_manager.lockRegAssumeUnused(addr_reg);
-            defer self.register_manager.unlockReg(addr_reg_lock);
-
-            try self.genSetReg(addr_reg, .usize, opt_mcv.address(), .{});
-            const some_abi_size: u32 = @intCast(some_info.ty.abiSize(zcu));
-            try self.asmMemoryImmediate(
-                .{ ._, .cmp },
-                .{
-                    .base = .{ .reg = addr_reg },
-                    .mod = .{ .rm = .{
-                        .size = .fromSize(some_abi_size),
-                        .disp = some_info.off,
-                    } },
-                },
-                .u(0),
-            );
-            return .{ .eflags = .e };
-        },
-
-        .indirect, .load_frame => {
-            const some_abi_size: u32 = @intCast(some_info.ty.abiSize(zcu));
-            try self.asmMemoryImmediate(
-                .{ ._, .cmp },
-                switch (opt_mcv) {
-                    .indirect => |reg_off| .{
-                        .base = .{ .reg = reg_off.reg },
-                        .mod = .{ .rm = .{
-                            .size = .fromSize(some_abi_size),
-                            .disp = reg_off.off + some_info.off,
-                        } },
-                    },
-                    .load_frame => |frame_addr| .{
-                        .base = .{ .frame = frame_addr.index },
-                        .mod = .{ .rm = .{
-                            .size = .fromSize(some_abi_size),
-                            .disp = frame_addr.off + some_info.off,
-                        } },
-                    },
-                    else => unreachable,
-                },
-                .u(0),
-            );
-            return .{ .eflags = .e };
-        },
-    }
-}
-
-fn isNullPtr(self: *CodeGen, inst: Air.Inst.Index, ptr_ty: Type, ptr_mcv: MCValue) !MCValue {
-    const pt = self.pt;
-    const zcu = pt.zcu;
-    const opt_ty = ptr_ty.childType(zcu);
-    const pl_ty = opt_ty.optionalChild(zcu);
-
-    try self.spillEflagsIfOccupied();
-
-    const some_info: struct { off: i32, ty: Type } = if (opt_ty.optionalReprIsPayload(zcu))
-        .{ .off = 0, .ty = if (pl_ty.isSlice(zcu)) pl_ty.slicePtrFieldType(zcu) else pl_ty }
-    else
-        .{ .off = @intCast(pl_ty.abiSize(zcu)), .ty = .bool };
-
-    const ptr_reg = switch (ptr_mcv) {
-        .register => |reg| reg,
-        else => try self.copyToTmpRegister(ptr_ty, ptr_mcv),
-    };
-    const ptr_lock = self.register_manager.lockReg(ptr_reg);
-    defer if (ptr_lock) |lock| self.register_manager.unlockReg(lock);
-
-    const some_abi_size: u32 = @intCast(some_info.ty.abiSize(zcu));
-    try self.asmMemoryImmediate(
-        .{ ._, .cmp },
-        .{
-            .base = .{ .reg = ptr_reg },
-            .mod = .{ .rm = .{
-                .size = .fromSize(some_abi_size),
-                .disp = some_info.off,
-            } },
-        },
-        .u(0),
-    );
-
-    self.eflags_inst = inst;
-    return .{ .eflags = .e };
-}
-
 fn isErr(self: *CodeGen, maybe_inst: ?Air.Inst.Index, eu_ty: Type, eu_mcv: MCValue) !MCValue {
     const pt = self.pt;
     const zcu = pt.zcu;
@@ -174708,124 +179205,6 @@ fn isErrPtr(self: *CodeGen, maybe_inst: ?Air.Inst.Index, ptr_ty: Type, ptr_mcv:
     return MCValue{ .eflags = .a };
 }
 
-fn isNonErr(self: *CodeGen, inst: Air.Inst.Index, eu_ty: Type, eu_mcv: MCValue) !MCValue {
-    const is_err_res = try self.isErr(inst, eu_ty, eu_mcv);
-    switch (is_err_res) {
-        .eflags => |cc| {
-            assert(cc == .a);
-            return MCValue{ .eflags = cc.negate() };
-        },
-        .immediate => |imm| {
-            assert(imm == 0);
-            return MCValue{ .immediate = @intFromBool(imm == 0) };
-        },
-        else => unreachable,
-    }
-}
-
-fn isNonErrPtr(self: *CodeGen, inst: Air.Inst.Index, ptr_ty: Type, ptr_mcv: MCValue) !MCValue {
-    const is_err_res = try self.isErrPtr(inst, ptr_ty, ptr_mcv);
-    switch (is_err_res) {
-        .eflags => |cc| {
-            assert(cc == .a);
-            return MCValue{ .eflags = cc.negate() };
-        },
-        .immediate => |imm| {
-            assert(imm == 0);
-            return MCValue{ .immediate = @intFromBool(imm == 0) };
-        },
-        else => unreachable,
-    }
-}
-
-fn airIsNull(self: *CodeGen, inst: Air.Inst.Index) !void {
-    const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
-    const operand = try self.resolveInst(un_op);
-    const ty = self.typeOf(un_op);
-    const result = try self.isNull(inst, ty, operand);
-    return self.finishAir(inst, result, .{ un_op, .none, .none });
-}
-
-fn airIsNullPtr(self: *CodeGen, inst: Air.Inst.Index) !void {
-    const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
-    const operand = try self.resolveInst(un_op);
-    const ty = self.typeOf(un_op);
-    const result = try self.isNullPtr(inst, ty, operand);
-    return self.finishAir(inst, result, .{ un_op, .none, .none });
-}
-
-fn airIsNonNull(self: *CodeGen, inst: Air.Inst.Index) !void {
-    const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
-    const operand = try self.resolveInst(un_op);
-    const ty = self.typeOf(un_op);
-    const result: MCValue = switch (try self.isNull(inst, ty, operand)) {
-        .immediate => |imm| .{ .immediate = @intFromBool(imm == 0) },
-        .eflags => |cc| .{ .eflags = cc.negate() },
-        else => unreachable,
-    };
-    return self.finishAir(inst, result, .{ un_op, .none, .none });
-}
-
-fn airIsNonNullPtr(self: *CodeGen, inst: Air.Inst.Index) !void {
-    const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
-    const operand = try self.resolveInst(un_op);
-    const ty = self.typeOf(un_op);
-    const result: MCValue = switch (try self.isNullPtr(inst, ty, operand)) {
-        .eflags => |cc| .{ .eflags = cc.negate() },
-        else => unreachable,
-    };
-    return self.finishAir(inst, result, .{ un_op, .none, .none });
-}
-
-fn airIsErr(self: *CodeGen, inst: Air.Inst.Index) !void {
-    const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
-    const operand = try self.resolveInst(un_op);
-    const ty = self.typeOf(un_op);
-    const result = try self.isErr(inst, ty, operand);
-    return self.finishAir(inst, result, .{ un_op, .none, .none });
-}
-
-fn airIsErrPtr(self: *CodeGen, inst: Air.Inst.Index) !void {
-    const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
-    const operand = try self.resolveInst(un_op);
-    const ty = self.typeOf(un_op);
-    const result = try self.isErrPtr(inst, ty, operand);
-    return self.finishAir(inst, result, .{ un_op, .none, .none });
-}
-
-fn airIsNonErr(self: *CodeGen, inst: Air.Inst.Index) !void {
-    const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
-    const operand = try self.resolveInst(un_op);
-    const ty = self.typeOf(un_op);
-    const result = try self.isNonErr(inst, ty, operand);
-    return self.finishAir(inst, result, .{ un_op, .none, .none });
-}
-
-fn airIsNonErrPtr(self: *CodeGen, inst: Air.Inst.Index) !void {
-    const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
-    const operand = try self.resolveInst(un_op);
-    const ty = self.typeOf(un_op);
-    const result = try self.isNonErrPtr(inst, ty, operand);
-    return self.finishAir(inst, result, .{ un_op, .none, .none });
-}
-
-fn airLoop(self: *CodeGen, inst: Air.Inst.Index) !void {
-    // A loop is a setup to be able to jump back to the beginning.
-    const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
-    const loop = self.air.extraData(Air.Block, ty_pl.payload);
-    const body: []const Air.Inst.Index = @ptrCast(self.air.extra.items[loop.end..][0..loop.data.body_len]);
-
-    const state = try self.saveState();
-
-    try self.loops.putNoClobber(self.gpa, inst, .{
-        .state = state,
-        .target = @intCast(self.mir_instructions.len),
-    });
-    defer assert(self.loops.remove(inst));
-
-    try self.genBodyBlock(body);
-}
-
 fn lowerBlock(self: *CodeGen, inst: Air.Inst.Index, body: []const Air.Inst.Index) !void {
     // A block is a setup to be able to jump to the end.
     const inst_tracking_i = self.inst_tracking.count();
@@ -174860,7 +179239,7 @@ fn lowerBlock(self: *CodeGen, inst: Air.Inst.Index, body: []const Air.Inst.Index
 
     if (std.debug.runtime_safety) assert(self.inst_tracking.getIndex(inst).? == inst_tracking_i);
     const tracking = &self.inst_tracking.values()[inst_tracking_i];
-    if (self.liveness.isUnused(inst)) try tracking.die(self, inst);
+    if (self.liveness.isUnused(inst)) try tracking.die(self, inst, .{});
     self.getValueIfFree(tracking.short, inst);
 }
 
@@ -175019,7 +179398,7 @@ fn lowerSwitchBr(
                 }
             }
 
-            for (liveness.deaths[case.idx]) |operand| try cg.processDeath(operand);
+            for (liveness.deaths[case.idx]) |operand| try cg.processDeath(operand, .{});
 
             try cg.genBodyBlock(case.body);
             try cg.restoreState(state, &.{}, .{
@@ -175033,7 +179412,7 @@ fn lowerSwitchBr(
             const else_body = cases_it.elseBody();
 
             const else_deaths = liveness.deaths.len - 1;
-            for (liveness.deaths[else_deaths]) |operand| try cg.processDeath(operand);
+            for (liveness.deaths[else_deaths]) |operand| try cg.processDeath(operand, .{});
 
             cg.performReloc(else_reloc);
             if (is_loop) {
@@ -175151,7 +179530,7 @@ fn lowerSwitchBr(
         // The jump to skip this case if the conditions all failed.
         const skip_case_reloc = try cg.asmJmpReloc(undefined);
 
-        for (liveness.deaths[case.idx]) |operand| try cg.processDeath(operand);
+        for (liveness.deaths[case.idx]) |operand| try cg.processDeath(operand, .{});
 
         // Relocate all success cases to the body we're about to generate.
         for (relocs) |reloc| cg.performReloc(reloc);
@@ -175170,7 +179549,7 @@ fn lowerSwitchBr(
         const else_body = cases_it.elseBody();
 
         const else_deaths = liveness.deaths.len - 1;
-        for (liveness.deaths[else_deaths]) |operand| try cg.processDeath(operand);
+        for (liveness.deaths[else_deaths]) |operand| try cg.processDeath(operand, .{});
 
         try cg.genBodyBlock(else_body);
         try cg.restoreState(state, &.{}, .{
@@ -175191,7 +179570,7 @@ fn airSwitchBr(self: *CodeGen, inst: Air.Inst.Index) !void {
     // whether it needs to be spilled in the branches
     const condition_dies = self.liveness.operandDies(inst, 0);
     if (condition_dies) {
-        if (switch_br.operand.toIndex()) |op_inst| try self.processDeath(op_inst);
+        if (switch_br.operand.toIndex()) |op_inst| try self.processDeath(op_inst, .{});
     }
     try self.lowerSwitchBr(inst, switch_br, condition, condition_dies, false);
 
@@ -175216,7 +179595,7 @@ fn airLoopSwitchBr(self: *CodeGen, inst: Air.Inst.Index) !void {
     // that death now instead of later as this has an effect on
     // whether it needs to be spilled in the branches
     if (self.liveness.operandDies(inst, 0)) {
-        if (switch_br.operand.toIndex()) |op_inst| try self.processDeath(op_inst);
+        if (switch_br.operand.toIndex()) |op_inst| try self.processDeath(op_inst, .{});
     }
 
     // Ensure a register is available for dispatch.
@@ -175231,11 +179610,11 @@ fn airLoopSwitchBr(self: *CodeGen, inst: Air.Inst.Index) !void {
     defer assert(self.loops.remove(inst));
 
     // Stop tracking block result without forgetting tracking info
-    try self.freeValue(mat_cond);
+    try self.freeValue(mat_cond, .{});
 
     try self.lowerSwitchBr(inst, switch_br, mat_cond, true, true);
 
-    try self.processDeath(inst);
+    try self.processDeath(inst, .{});
 }
 
 fn airSwitchDispatch(self: *CodeGen, inst: Air.Inst.Index) !void {
@@ -175262,7 +179641,7 @@ fn airSwitchDispatch(self: *CodeGen, inst: Air.Inst.Index) !void {
 
     // Process operand death so that it is properly accounted for in the State below.
     if (self.liveness.operandDies(inst, 0)) {
-        if (br.operand.toIndex()) |op_inst| try self.processDeath(op_inst);
+        if (br.operand.toIndex()) |op_inst| try self.processDeath(op_inst, .{});
     }
 
     try self.restoreState(loop_data.state, &.{}, .{
@@ -175340,7 +179719,7 @@ fn airSwitchDispatch(self: *CodeGen, inst: Air.Inst.Index) !void {
     _ = try self.asmJmpReloc(loop_data.target);
 
     // Stop tracking block result without forgetting tracking info
-    try self.freeValue(block_tracking.short);
+    try self.freeValue(block_tracking.short, .{ .emit_instructions = false });
 }
 
 fn performReloc(self: *CodeGen, reloc: Mir.Inst.Index) void {
@@ -175389,10 +179768,14 @@ fn airBr(self: *CodeGen, inst: Air.Inst.Index) !void {
             if (first_br) break :result src_mcv;
 
             try self.getValue(block_tracking.short, br.block_inst);
-            // .long = .none to avoid merging operand and block result stack frames.
-            const current_tracking: InstTracking = .{ .long = .none, .short = src_mcv };
-            try current_tracking.materializeUnsafe(self, br.block_inst, block_tracking.*);
-            for (current_tracking.getRegs()) |src_reg| self.register_manager.freeReg(src_reg);
+            try InstTracking.materializeUnsafe(
+                // .long = .none to avoid merging operand and block result stack frames.
+                .{ .long = .none, .short = src_mcv },
+                self,
+                br.block_inst,
+                block_tracking.*,
+            );
+            try self.freeValue(src_mcv, .{});
             break :result block_tracking.short;
         }
 
@@ -175406,7 +179789,7 @@ fn airBr(self: *CodeGen, inst: Air.Inst.Index) !void {
 
     // Process operand death so that it is properly accounted for in the State below.
     if (self.liveness.operandDies(inst, 0)) {
-        if (br.operand.toIndex()) |op_inst| try self.processDeath(op_inst);
+        if (br.operand.toIndex()) |op_inst| try self.processDeath(op_inst, .{});
     }
 
     if (first_br) {
@@ -175425,7 +179808,7 @@ fn airBr(self: *CodeGen, inst: Air.Inst.Index) !void {
     try block_data.relocs.append(self.gpa, jmp_reloc);
 
     // Stop tracking block result without forgetting tracking info
-    try self.freeValue(block_tracking.short);
+    try self.freeValue(block_tracking.short, .{ .emit_instructions = false });
 }
 
 fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void {
@@ -175802,7 +180185,7 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void {
                         } },
                     } };
                 } else {
-                    if (mnem_size.use()) |size| if (reg.bitSize() != size.bitSize(self.target))
+                    if (mnem_size.use()) |size| if (reg.size().bitSize(self.target) != size.bitSize(self.target))
                         return self.fail("invalid register size: '{s}'", .{op_str});
                     op.* = .{ .reg = reg };
                 }
@@ -176181,7 +180564,7 @@ const MoveStrategy = union(enum) {
                 if (tag[0] == ._ps and tag[1] == .movl) try cg.asmRegisterRegister(.{ ._ps, .xor }, dst_reg, dst_reg);
                 try cg.asmRegisterMemory(tag, switch (tag[1]) {
                     else => dst_reg,
-                    .lea => if (dst_reg.bitSize() >= 32) dst_reg else dst_reg.to32(),
+                    .lea => if (dst_reg.size().bitSize(cg.target) >= 32) dst_reg else dst_reg.to32(),
                 }, src_mem);
             },
             .load_store_x87 => if (dst_reg != .st0 and cg.register_manager.isKnownRegFree(.st7)) {
@@ -176335,7 +180718,7 @@ fn moveStrategy(cg: *CodeGen, ty: Type, class: Register.Class, aligned: bool) !M
                     else => {},
                 }
             },
-            .float => switch (ty.floatBits(cg.target.*)) {
+            .float => switch (ty.floatBits(cg.target)) {
                 16 => return if (cg.hasFeature(.avx)) .{ .vex_insert_extract = .{
                     .insert = .{ .vp_w, .insr },
                     .extract = .{ .vp_w, .extr },
@@ -176482,7 +180865,7 @@ fn moveStrategy(cg: *CodeGen, ty: Type, class: Register.Class, aligned: bool) !M
                     }
                 else
                     unreachable,
-                .float => switch (ty.childType(zcu).floatBits(cg.target.*)) {
+                .float => switch (ty.childType(zcu).floatBits(cg.target)) {
                     16 => switch (ty.vectorLen(zcu)) {
                         1...8 => return .{ .load_store = if (cg.hasFeature(.avx))
                             .{ if (aligned) .v_dqa else .v_dqu, .mov }
@@ -176554,6 +180937,7 @@ fn genCopy(self: *CodeGen, ty: Type, dst_mcv: MCValue, src_mcv: MCValue, opts: C
         .eflags,
         .register_overflow,
         .register_mask,
+        .indirect_load_frame,
         .lea_frame,
         .lea_nav,
         .lea_uav,
@@ -176750,12 +181134,13 @@ fn genSetReg(
     const zcu = pt.zcu;
     const abi_size: u32 = @intCast(ty.abiSize(zcu));
     const dst_alias = registerAlias(dst_reg, abi_size);
-    if (ty.bitSize(zcu) > dst_alias.bitSize())
+    if (ty.bitSize(zcu) > dst_alias.size().bitSize(self.target))
         return self.fail("genSetReg called with a value larger than dst_reg", .{});
     switch (src_mcv) {
         .none,
         .unreach,
         .dead,
+        .indirect_load_frame,
         .elementwise_args,
         .reserved_frame,
         => unreachable,
@@ -177017,7 +181402,7 @@ fn genSetReg(
                             17...32 => if (self.hasFeature(.avx)) .{ .v_dqa, .mov } else null,
                             else => null,
                         },
-                        .float => switch (ty.scalarType(zcu).floatBits(self.target.*)) {
+                        .float => switch (ty.scalarType(zcu).floatBits(self.target)) {
                             16, 128 => switch (abi_size) {
                                 2...16 => if (self.hasFeature(.avx))
                                     .{ .v_dqa, .mov }
@@ -177112,7 +181497,7 @@ fn genSetReg(
                 ty,
                 dst_reg.class(),
                 self.getFrameAddrAlignment(frame_addr).compare(.gte, .fromLog2Units(
-                    std.math.log2_int_ceil(u10, @divExact(dst_reg.bitSize(), 8)),
+                    std.math.log2_int_ceil(u64, @divExact(dst_reg.size().bitSize(self.target), 8)),
                 )),
             ),
             .lea_frame => .{ .load_store = .{ ._, .lea } },
@@ -177318,6 +181703,7 @@ fn genSetMem(
         .none,
         .unreach,
         .dead,
+        .indirect_load_frame,
         .elementwise_args,
         .reserved_frame,
         => unreachable,
@@ -177382,43 +181768,37 @@ fn genSetMem(
                     const frame_abi_size = self.frame_allocs.items(.abi_size)[@intFromEnum(base_fi)];
                     const frame_spill_pad = self.frame_allocs.items(.spill_pad)[@intFromEnum(base_fi)];
                     assert(frame_abi_size - frame_spill_pad - disp >= abi_size);
-                    break :mem_size if (frame_abi_size - frame_spill_pad - disp == abi_size)
-                        frame_abi_size
-                    else
-                        abi_size;
+                    break :mem_size if (frame_abi_size - frame_spill_pad - disp == abi_size) frame_abi_size else abi_size;
                 },
                 else => abi_size,
             };
             const src_alias = registerAlias(src_reg, @intCast(self.unalignedSize(ty)));
             const src_class = src_alias.class();
-            const src_size: u32 = switch (src_class) {
-                .general_purpose, .gphi, .segment, .ip, .cr, .dr => @intCast(@divExact(src_alias.bitSize(), 8)),
-                .mmx, .sse => abi_size,
+            const src_size: Memory.Size = switch (src_class) {
+                .general_purpose, .gphi, .segment, .ip, .cr, .dr => src_alias.size(),
+                .mmx, .sse => .fromSize(abi_size),
                 .x87 => switch (abi.classifySystemV(ty, zcu, self.target, .other)[0]) {
                     else => unreachable,
-                    .float, .float_combine => 4,
-                    .sse => 8,
-                    .x87 => 10,
+                    .float => .dword,
+                    .float_combine, .sse => .qword,
+                    .x87 => .tbyte,
                 },
             };
-            const src_align: InternPool.Alignment = .fromNonzeroByteUnits(
-                std.math.ceilPowerOfTwoAssert(u32, src_size),
-            );
-            if (src_size > mem_size) {
+            const src_bit_size = src_size.bitSize(self.target);
+            const src_align: InternPool.Alignment = .fromNonzeroByteUnits(std.math.ceilPowerOfTwoAssert(u64, src_bit_size));
+            const src_byte_size = @divExact(src_bit_size, 8);
+            if (src_byte_size > mem_size) {
                 const frame_index = try self.allocFrameIndex(.init(.{
-                    .size = src_size,
+                    .size = src_byte_size,
                     .alignment = src_align,
                 }));
                 const frame_mcv: MCValue = .{ .load_frame = .{ .index = frame_index } };
-                try (try self.moveStrategy(ty, src_class, true)).write(
-                    self,
-                    .{ .base = .{ .frame = frame_index }, .mod = .{ .rm = .{
-                        .size = .fromSize(src_size),
-                    } } },
-                    src_alias,
-                );
+                try (try self.moveStrategy(ty, src_class, true)).write(self, .{
+                    .base = .{ .frame = frame_index },
+                    .mod = .{ .rm = .{ .size = src_size } },
+                }, src_alias);
                 try self.genSetMem(base, disp, ty, frame_mcv, opts);
-                try self.freeValue(frame_mcv);
+                try self.freeValue(frame_mcv, .{});
             } else try (try self.moveStrategy(ty, src_class, switch (base) {
                 .none => src_align.check(@as(u32, @bitCast(disp))),
                 .reg => |reg| switch (reg) {
@@ -177432,17 +181812,10 @@ fn genSetMem(
                 .table, .rip_inst, .lazy_sym, .extern_func => unreachable,
                 .nav => |nav| ip.getNav(nav).getAlignment().compare(.gte, src_align),
                 .uav => |uav| Type.fromInterned(uav.orig_ty).ptrAlignment(zcu).compare(.gte, src_align),
-            })).write(
-                self,
-                .{ .base = base, .mod = .{ .rm = .{
-                    .size = .fromBitSize(@min(
-                        self.memSize(ty).bitSize(self.target),
-                        src_alias.bitSize(),
-                    )),
-                    .disp = disp,
-                } } },
-                src_alias,
-            );
+            })).write(self, .{
+                .base = base,
+                .mod = .{ .rm = .{ .size = src_size, .disp = disp } },
+            }, src_alias);
         },
         inline .register_pair, .register_triple, .register_quadruple => |src_regs| {
             var part_disp: i32 = disp;
@@ -177776,7 +182149,7 @@ fn airFloatFromInt(self: *CodeGen, inst: Air.Inst.Index) !void {
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
 
     const dst_ty = self.typeOfIndex(inst);
-    const dst_bits = dst_ty.floatBits(self.target.*);
+    const dst_bits = dst_ty.floatBits(self.target);
 
     const src_ty = self.typeOf(ty_op.operand);
     const src_bits: u32 = @intCast(src_ty.bitSize(zcu));
@@ -177828,7 +182201,7 @@ fn airFloatFromInt(self: *CodeGen, inst: Air.Inst.Index) !void {
         defer self.register_manager.unlockReg(dst_lock);
 
         const mir_tag = @as(?Mir.Inst.FixedTag, switch (dst_ty.zigTypeTag(zcu)) {
-            .float => switch (dst_ty.floatBits(self.target.*)) {
+            .float => switch (dst_ty.floatBits(self.target)) {
                 32 => if (self.hasFeature(.avx)) .{ .v_ss, .cvtsi2 } else .{ ._ss, .cvtsi2 },
                 64 => if (self.hasFeature(.avx)) .{ .v_sd, .cvtsi2 } else .{ ._sd, .cvtsi2 },
                 16, 80, 128 => null,
@@ -177865,7 +182238,7 @@ fn airIntFromFloat(self: *CodeGen, inst: Air.Inst.Index) !void {
     }, 32), 8) catch unreachable;
 
     const src_ty = self.typeOf(ty_op.operand);
-    const src_bits = src_ty.floatBits(self.target.*);
+    const src_bits = src_ty.floatBits(self.target);
 
     const result = result: {
         if (switch (src_bits) {
@@ -178136,22 +182509,22 @@ fn atomicOp(
             }
             if (rmw_op) |op| if (use_sse) {
                 const mir_tag = @as(?Mir.Inst.FixedTag, switch (op) {
-                    .Add => switch (val_ty.floatBits(self.target.*)) {
+                    .Add => switch (val_ty.floatBits(self.target)) {
                         32 => if (self.hasFeature(.avx)) .{ .v_ss, .add } else .{ ._ss, .add },
                         64 => if (self.hasFeature(.avx)) .{ .v_sd, .add } else .{ ._sd, .add },
                         else => null,
                     },
-                    .Sub => switch (val_ty.floatBits(self.target.*)) {
+                    .Sub => switch (val_ty.floatBits(self.target)) {
                         32 => if (self.hasFeature(.avx)) .{ .v_ss, .sub } else .{ ._ss, .sub },
                         64 => if (self.hasFeature(.avx)) .{ .v_sd, .sub } else .{ ._sd, .sub },
                         else => null,
                     },
-                    .Min => switch (val_ty.floatBits(self.target.*)) {
+                    .Min => switch (val_ty.floatBits(self.target)) {
                         32 => if (self.hasFeature(.avx)) .{ .v_ss, .min } else .{ ._ss, .min },
                         64 => if (self.hasFeature(.avx)) .{ .v_sd, .min } else .{ ._sd, .min },
                         else => null,
                     },
-                    .Max => switch (val_ty.floatBits(self.target.*)) {
+                    .Max => switch (val_ty.floatBits(self.target)) {
                         32 => if (self.hasFeature(.avx)) .{ .v_ss, .max } else .{ ._ss, .max },
                         64 => if (self.hasFeature(.avx)) .{ .v_sd, .max } else .{ ._sd, .max },
                         else => null,
@@ -178582,271 +182955,6 @@ fn airMemset(self: *CodeGen, inst: Air.Inst.Index, safety: bool) !void {
     return self.finishAir(inst, .unreach, .{ bin_op.lhs, bin_op.rhs, .none });
 }
 
-fn airMemcpy(self: *CodeGen, inst: Air.Inst.Index) !void {
-    const pt = self.pt;
-    const zcu = pt.zcu;
-    const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
-
-    try self.spillRegisters(&.{ .rdi, .rsi, .rcx });
-    const reg_locks = self.register_manager.lockRegsAssumeUnused(3, .{ .rdi, .rsi, .rcx });
-    defer for (reg_locks) |lock| self.register_manager.unlockReg(lock);
-
-    const dst = try self.resolveInst(bin_op.lhs);
-    const dst_ty = self.typeOf(bin_op.lhs);
-    const dst_locks: [2]?RegisterLock = switch (dst) {
-        .register => |dst_reg| .{ self.register_manager.lockRegAssumeUnused(dst_reg), null },
-        .register_pair => |dst_regs| .{
-            self.register_manager.lockRegAssumeUnused(dst_regs[0]),
-            self.register_manager.lockReg(dst_regs[1]),
-        },
-        else => @splat(null),
-    };
-    for (dst_locks) |dst_lock| if (dst_lock) |lock| self.register_manager.unlockReg(lock);
-
-    const src = try self.resolveInst(bin_op.rhs);
-    const src_locks: [2]?RegisterLock = switch (src) {
-        .register => |src_reg| .{ self.register_manager.lockReg(src_reg), null },
-        .register_pair => |src_regs| .{
-            self.register_manager.lockRegAssumeUnused(src_regs[0]),
-            self.register_manager.lockRegAssumeUnused(src_regs[1]),
-        },
-        else => @splat(null),
-    };
-    for (src_locks) |src_lock| if (src_lock) |lock| self.register_manager.unlockReg(lock);
-
-    const len: MCValue = switch (dst_ty.ptrSize(zcu)) {
-        .slice => len: {
-            const len_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);
-            const len_lock = self.register_manager.lockRegAssumeUnused(len_reg);
-            defer self.register_manager.unlockReg(len_lock);
-
-            switch (dst) {
-                .register_pair => |dst_regs| try self.asmRegisterRegisterImmediate(
-                    .{ .i_, .mul },
-                    len_reg,
-                    dst_regs[1],
-                    .s(@intCast(dst_ty.childType(zcu).abiSize(zcu))),
-                ),
-                else => try self.asmRegisterMemoryImmediate(
-                    .{ .i_, .mul },
-                    len_reg,
-                    try dst.address().offset(8).deref().mem(self, .{ .size = .qword }),
-                    .s(@intCast(dst_ty.childType(zcu).abiSize(zcu))),
-                ),
-            }
-            break :len .{ .register = len_reg };
-        },
-        .one => len: {
-            const array_ty = dst_ty.childType(zcu);
-            break :len .{ .immediate = array_ty.arrayLen(zcu) * array_ty.childType(zcu).abiSize(zcu) };
-        },
-        .c, .many => unreachable,
-    };
-    const len_lock: ?RegisterLock = switch (len) {
-        .register => |reg| self.register_manager.lockReg(reg),
-        else => null,
-    };
-    defer if (len_lock) |lock| self.register_manager.unlockReg(lock);
-
-    const dst_ptr: MCValue = switch (dst) {
-        .register_pair => |dst_regs| .{ .register = dst_regs[0] },
-        else => dst,
-    };
-    const src_ptr: MCValue = switch (src) {
-        .register_pair => |src_regs| .{ .register = src_regs[0] },
-        else => src,
-    };
-
-    try self.genInlineMemcpy(dst_ptr, src_ptr, len, .{ .no_alias = true });
-
-    return self.finishAir(inst, .unreach, .{ bin_op.lhs, bin_op.rhs, .none });
-}
-
-fn airTagName(self: *CodeGen, inst: Air.Inst.Index, only_safety: bool) !void {
-    const pt = self.pt;
-    const zcu = pt.zcu;
-    const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
-    const inst_ty = self.typeOfIndex(inst);
-    const enum_ty = self.typeOf(un_op);
-
-    // We need a properly aligned and sized call frame to be able to call this function.
-    {
-        const needed_call_frame: FrameAlloc = .init(.{
-            .size = inst_ty.abiSize(zcu),
-            .alignment = inst_ty.abiAlignment(zcu),
-        });
-        const frame_allocs_slice = self.frame_allocs.slice();
-        const stack_frame_size =
-            &frame_allocs_slice.items(.abi_size)[@intFromEnum(FrameIndex.call_frame)];
-        stack_frame_size.* = @max(stack_frame_size.*, needed_call_frame.abi_size);
-        const stack_frame_align =
-            &frame_allocs_slice.items(.abi_align)[@intFromEnum(FrameIndex.call_frame)];
-        stack_frame_align.* = stack_frame_align.max(needed_call_frame.abi_align);
-    }
-
-    var param_gpr = abi.getCAbiIntParamRegs(.auto);
-    const err_ret_trace_reg = if (zcu.comp.config.any_error_tracing) err_ret_trace_reg: {
-        defer param_gpr = param_gpr[0 .. param_gpr.len - 1];
-        break :err_ret_trace_reg param_gpr[param_gpr.len - 1];
-    } else .none;
-
-    try self.spillEflagsIfOccupied();
-    try self.spillCallerPreservedRegs(.auto, err_ret_trace_reg);
-
-    const operand = try self.resolveInst(un_op);
-    try self.genSetReg(param_gpr[0], enum_ty, operand, .{});
-
-    const enum_lazy_sym: link.File.LazySymbol = .{ .kind = .code, .ty = enum_ty.toIntern() };
-    try self.genLazySymbolRef(.call, abi.getCAbiLinkerScratchReg(.auto), enum_lazy_sym);
-
-    const tag_name_regs = param_gpr[0..2].*;
-    const dst_mcv: MCValue = if (only_safety) result: {
-        try self.asmRegisterRegister(.{ ._, .@"test" }, tag_name_regs[0].to64(), tag_name_regs[0].to64());
-        break :result .{ .eflags = .nz };
-    } else .{ .register_pair = tag_name_regs };
-    return self.finishAir(inst, dst_mcv, .{ un_op, .none, .none });
-}
-
-fn airErrorName(self: *CodeGen, inst: Air.Inst.Index) !void {
-    const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
-
-    const err_ty = self.typeOf(un_op);
-    const err_mcv = try self.resolveInst(un_op);
-    const err_reg = try self.copyToTmpRegister(err_ty, err_mcv);
-    const err_lock = self.register_manager.lockRegAssumeUnused(err_reg);
-    defer self.register_manager.unlockReg(err_lock);
-
-    const addr_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);
-    const addr_lock = self.register_manager.lockRegAssumeUnused(addr_reg);
-    defer self.register_manager.unlockReg(addr_lock);
-    const anyerror_lazy_sym: link.File.LazySymbol = .{ .kind = .const_data, .ty = .anyerror_type };
-    try self.genLazySymbolRef(.lea, addr_reg, anyerror_lazy_sym);
-
-    const start_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);
-    const start_lock = self.register_manager.lockRegAssumeUnused(start_reg);
-    defer self.register_manager.unlockReg(start_lock);
-
-    const end_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);
-    const end_lock = self.register_manager.lockRegAssumeUnused(end_reg);
-    defer self.register_manager.unlockReg(end_lock);
-
-    try self.truncateRegister(err_ty, err_reg.to32());
-
-    try self.asmRegisterMemory(
-        .{ ._, .mov },
-        start_reg.to32(),
-        .{
-            .base = .{ .reg = addr_reg.to64() },
-            .mod = .{ .rm = .{
-                .size = .dword,
-                .index = err_reg.to64(),
-                .scale = .@"4",
-                .disp = (1 - 1) * 4,
-            } },
-        },
-    );
-    try self.asmRegisterMemory(
-        .{ ._, .mov },
-        end_reg.to32(),
-        .{
-            .base = .{ .reg = addr_reg.to64() },
-            .mod = .{ .rm = .{
-                .size = .dword,
-                .index = err_reg.to64(),
-                .scale = .@"4",
-                .disp = (2 - 1) * 4,
-            } },
-        },
-    );
-    try self.asmRegisterRegister(.{ ._, .sub }, end_reg.to32(), start_reg.to32());
-    try self.asmRegisterMemory(
-        .{ ._, .lea },
-        start_reg.to64(),
-        .{
-            .base = .{ .reg = addr_reg.to64() },
-            .mod = .{ .rm = .{ .index = start_reg.to64() } },
-        },
-    );
-    try self.asmRegisterMemory(
-        .{ ._, .lea },
-        end_reg.to32(),
-        .{
-            .base = .{ .reg = end_reg.to64() },
-            .mod = .{ .rm = .{ .disp = -1 } },
-        },
-    );
-
-    const dst_mcv = try self.allocRegOrMem(inst, false);
-    try self.asmMemoryRegister(
-        .{ ._, .mov },
-        .{
-            .base = .{ .frame = dst_mcv.load_frame.index },
-            .mod = .{ .rm = .{
-                .size = .qword,
-                .disp = dst_mcv.load_frame.off,
-            } },
-        },
-        start_reg.to64(),
-    );
-    try self.asmMemoryRegister(
-        .{ ._, .mov },
-        .{
-            .base = .{ .frame = dst_mcv.load_frame.index },
-            .mod = .{ .rm = .{
-                .size = .qword,
-                .disp = dst_mcv.load_frame.off + 8,
-            } },
-        },
-        end_reg.to64(),
-    );
-
-    return self.finishAir(inst, dst_mcv, .{ un_op, .none, .none });
-}
-
-fn airErrorSetHasValue(self: *CodeGen, inst: Air.Inst.Index) !void {
-    const pt = self.pt;
-    const zcu = pt.zcu;
-    const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
-    const inst_ty = self.typeOfIndex(inst);
-    const err_ty = ty_op.ty.toType();
-
-    // We need a properly aligned and sized call frame to be able to call this function.
-    {
-        const needed_call_frame: FrameAlloc = .init(.{
-            .size = inst_ty.abiSize(zcu),
-            .alignment = inst_ty.abiAlignment(zcu),
-        });
-        const frame_allocs_slice = self.frame_allocs.slice();
-        const stack_frame_size =
-            &frame_allocs_slice.items(.abi_size)[@intFromEnum(FrameIndex.call_frame)];
-        stack_frame_size.* = @max(stack_frame_size.*, needed_call_frame.abi_size);
-        const stack_frame_align =
-            &frame_allocs_slice.items(.abi_align)[@intFromEnum(FrameIndex.call_frame)];
-        stack_frame_align.* = stack_frame_align.max(needed_call_frame.abi_align);
-    }
-
-    var param_gpr = abi.getCAbiIntParamRegs(.auto);
-    const err_ret_trace_reg = if (zcu.comp.config.any_error_tracing) err_ret_trace_reg: {
-        defer param_gpr = param_gpr[0 .. param_gpr.len - 1];
-        break :err_ret_trace_reg param_gpr[param_gpr.len - 1];
-    } else .none;
-
-    try self.spillEflagsIfOccupied();
-    try self.spillCallerPreservedRegs(.auto, err_ret_trace_reg);
-
-    const operand = try self.resolveInst(ty_op.operand);
-    try self.genSetReg(param_gpr[0], err_ty, operand, .{});
-
-    const enum_lazy_sym: link.File.LazySymbol = .{ .kind = .code, .ty = err_ty.toIntern() };
-    try self.genLazySymbolRef(.call, abi.getCAbiLinkerScratchReg(.auto), enum_lazy_sym);
-
-    const res_reg = param_gpr[0];
-    try self.asmRegisterRegister(.{ ._, .@"test" }, res_reg.to32(), res_reg.to32());
-
-    const dst_mcv: MCValue = .{ .eflags = .nz };
-    return self.finishAir(inst, dst_mcv, .{ ty_op.operand, .none, .none });
-}
-
 fn airSplat(self: *CodeGen, inst: Air.Inst.Index) !void {
     const pt = self.pt;
     const zcu = pt.zcu;
@@ -178988,7 +183096,7 @@ fn airSplat(self: *CodeGen, inst: Air.Inst.Index) !void {
                 );
                 break :result .{ .register = dst_reg };
             },
-            .float => switch (scalar_ty.floatBits(self.target.*)) {
+            .float => switch (scalar_ty.floatBits(self.target)) {
                 32 => switch (vector_len) {
                     1 => {
                         const src_mcv = try self.resolveInst(ty_op.operand);
@@ -179581,7 +183689,7 @@ fn airSelect(self: *CodeGen, inst: Air.Inst.Index) !void {
                     null,
                 else => null,
             },
-            .float => switch (elem_ty.floatBits(self.target.*)) {
+            .float => switch (elem_ty.floatBits(self.target)) {
                 else => unreachable,
                 16, 80, 128 => null,
                 32 => switch (vec_len) {
@@ -180308,7 +184416,7 @@ fn airShuffle(self: *CodeGen, inst: Air.Inst.Index) !void {
             defer self.register_manager.unlockReg(mask_lock);
 
             const mir_fixes: Mir.Inst.Fixes = if (elem_ty.isRuntimeFloat())
-                switch (elem_ty.floatBits(self.target.*)) {
+                switch (elem_ty.floatBits(self.target)) {
                     16, 80, 128 => .p_,
                     32 => ._ps,
                     64 => ._pd,
@@ -180414,7 +184522,7 @@ fn airShuffle(self: *CodeGen, inst: Air.Inst.Index) !void {
                 .{ switch (elem_ty.zigTypeTag(zcu)) {
                     else => break :result null,
                     .int => .vp_,
-                    .float => switch (elem_ty.floatBits(self.target.*)) {
+                    .float => switch (elem_ty.floatBits(self.target)) {
                         32 => .v_ps,
                         64 => .v_pd,
                         16, 80, 128 => break :result null,
@@ -180428,7 +184536,7 @@ fn airShuffle(self: *CodeGen, inst: Air.Inst.Index) !void {
                 .{ switch (elem_ty.zigTypeTag(zcu)) {
                     else => break :result null,
                     .int => .p_,
-                    .float => switch (elem_ty.floatBits(self.target.*)) {
+                    .float => switch (elem_ty.floatBits(self.target)) {
                         32 => ._ps,
                         64 => ._pd,
                         16, 80, 128 => break :result null,
@@ -180451,120 +184559,6 @@ fn airShuffle(self: *CodeGen, inst: Air.Inst.Index) !void {
     return self.finishAir(inst, result, .{ extra.a, extra.b, .none });
 }
 
-fn airReduce(self: *CodeGen, inst: Air.Inst.Index) !void {
-    const pt = self.pt;
-    const zcu = pt.zcu;
-    const reduce = self.air.instructions.items(.data)[@intFromEnum(inst)].reduce;
-
-    const result: MCValue = result: {
-        const operand_ty = self.typeOf(reduce.operand);
-        if (operand_ty.isVector(zcu) and operand_ty.childType(zcu).toIntern() == .bool_type) {
-            try self.spillEflagsIfOccupied();
-
-            const abi_size: u32 = @intCast(operand_ty.abiSize(zcu));
-            const operand_mcv = try self.resolveInst(reduce.operand);
-            const mask_len = operand_ty.vectorLen(zcu);
-            const mask_len_minus_one = (std.math.cast(u6, mask_len - 1) orelse {
-                const acc_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);
-                const acc_lock = self.register_manager.lockRegAssumeUnused(acc_reg);
-                defer self.register_manager.unlockReg(acc_lock);
-                var limb_offset: i31 = @intCast((mask_len - 1) / 64 * 8);
-                const need_mask = mask_len % 64 != 0;
-                if (need_mask) try self.asmRegisterImmediate(
-                    .{ ._, .mov },
-                    if (mask_len % 64 <= 32) acc_reg.to32() else acc_reg.to64(),
-                    .u((@as(u64, std.math.maxInt(u64)) >> @truncate(-%mask_len))),
-                );
-                const operand_mem_mcv: MCValue = if (!operand_mcv.isBase()) operand_mem: {
-                    const frame_index = try self.allocFrameIndex(.initSpill(operand_ty, zcu));
-                    try self.genSetMem(.{ .frame = frame_index }, 0, operand_ty, operand_mcv, .{});
-                    break :operand_mem .{ .load_frame = .{ .index = frame_index } };
-                } else operand_mcv;
-                var first = true;
-                while (true) : (limb_offset -= 8) {
-                    try self.asmRegisterMemory(
-                        .{ ._, if (first) if (need_mask) .@"and" else .mov else switch (reduce.operation) {
-                            .Or => .@"or",
-                            .And => .@"and",
-                            else => return self.fail("TODO implement airReduce for {}", .{operand_ty.fmt(pt)}),
-                        } },
-                        acc_reg.to64(),
-                        try operand_mem_mcv.mem(self, .{
-                            .size = .qword,
-                            .disp = limb_offset,
-                        }),
-                    );
-                    if (limb_offset == 0) break;
-                    first = false;
-                }
-                switch (reduce.operation) {
-                    .Or => {
-                        try self.asmRegisterRegister(.{ ._, .@"test" }, acc_reg.to64(), acc_reg.to64());
-                        break :result .{ .eflags = .nz };
-                    },
-                    .And => {
-                        try self.asmRegisterImmediate(.{ ._, .cmp }, acc_reg.to64(), .s(-1));
-                        break :result .{ .eflags = .z };
-                    },
-                    else => unreachable,
-                }
-            });
-            const mask = @as(u64, std.math.maxInt(u64)) >> ~mask_len_minus_one;
-            switch (reduce.operation) {
-                .Or => {
-                    if (operand_mcv.isBase()) try self.asmMemoryImmediate(
-                        .{ ._, .@"test" },
-                        try operand_mcv.mem(self, .{ .size = .fromSize(abi_size) }),
-                        if (mask_len < abi_size * 8)
-                            .u(mask)
-                        else
-                            .s(-1),
-                    ) else {
-                        const operand_reg = registerAlias(operand_reg: {
-                            if (operand_mcv.isRegister()) {
-                                const operand_reg = operand_mcv.getReg().?;
-                                if (operand_reg.isClass(.general_purpose)) break :operand_reg operand_reg;
-                            }
-                            break :operand_reg try self.copyToTmpRegister(operand_ty, operand_mcv);
-                        }, abi_size);
-                        const operand_lock = self.register_manager.lockReg(operand_reg);
-                        defer if (operand_lock) |lock| self.register_manager.unlockReg(lock);
-
-                        if (mask_len < abi_size * 8) try self.asmRegisterImmediate(
-                            .{ ._, .@"test" },
-                            operand_reg,
-                            .u(mask),
-                        ) else try self.asmRegisterRegister(
-                            .{ ._, .@"test" },
-                            operand_reg,
-                            operand_reg,
-                        );
-                    }
-                    break :result .{ .eflags = .nz };
-                },
-                .And => {
-                    const tmp_reg = registerAlias(
-                        try self.copyToTmpRegister(operand_ty, operand_mcv),
-                        abi_size,
-                    );
-                    const tmp_lock = self.register_manager.lockRegAssumeUnused(tmp_reg);
-                    defer self.register_manager.unlockReg(tmp_lock);
-
-                    try self.asmRegister(.{ ._, .not }, tmp_reg);
-                    if (mask_len < abi_size * 8)
-                        try self.asmRegisterImmediate(.{ ._, .@"test" }, tmp_reg, .u(mask))
-                    else
-                        try self.asmRegisterRegister(.{ ._, .@"test" }, tmp_reg, tmp_reg);
-                    break :result .{ .eflags = .z };
-                },
-                else => return self.fail("TODO implement airReduce for {}", .{operand_ty.fmt(pt)}),
-            }
-        }
-        return self.fail("TODO implement airReduce for {}", .{operand_ty.fmt(pt)});
-    };
-    return self.finishAir(inst, result, .{ reduce.operand, .none, .none });
-}
-
 fn airAggregateInit(self: *CodeGen, inst: Air.Inst.Index) !void {
     const pt = self.pt;
     const zcu = pt.zcu;
@@ -180800,7 +184794,7 @@ fn airMulAdd(self: *CodeGen, inst: Air.Inst.Index) !void {
 
     const ops = [3]Air.Inst.Ref{ extra.lhs, extra.rhs, pl_op.operand };
     const result = result: {
-        if (switch (ty.scalarType(zcu).floatBits(self.target.*)) {
+        if (switch (ty.scalarType(zcu).floatBits(self.target)) {
             16, 80, 128 => true,
             32, 64 => !self.hasFeature(.fma),
             else => unreachable,
@@ -180855,14 +184849,14 @@ fn airMulAdd(self: *CodeGen, inst: Air.Inst.Index) !void {
         const mir_tag = @as(?Mir.Inst.FixedTag, if (std.mem.eql(u2, &order, &.{ 1, 3, 2 }) or
             std.mem.eql(u2, &order, &.{ 3, 1, 2 }))
             switch (ty.zigTypeTag(zcu)) {
-                .float => switch (ty.floatBits(self.target.*)) {
+                .float => switch (ty.floatBits(self.target)) {
                     32 => .{ .v_ss, .fmadd132 },
                     64 => .{ .v_sd, .fmadd132 },
                     16, 80, 128 => null,
                     else => unreachable,
                 },
                 .vector => switch (ty.childType(zcu).zigTypeTag(zcu)) {
-                    .float => switch (ty.childType(zcu).floatBits(self.target.*)) {
+                    .float => switch (ty.childType(zcu).floatBits(self.target)) {
                         32 => switch (ty.vectorLen(zcu)) {
                             1 => .{ .v_ss, .fmadd132 },
                             2...8 => .{ .v_ps, .fmadd132 },
@@ -180882,14 +184876,14 @@ fn airMulAdd(self: *CodeGen, inst: Air.Inst.Index) !void {
             }
         else if (std.mem.eql(u2, &order, &.{ 2, 1, 3 }) or std.mem.eql(u2, &order, &.{ 1, 2, 3 }))
             switch (ty.zigTypeTag(zcu)) {
-                .float => switch (ty.floatBits(self.target.*)) {
+                .float => switch (ty.floatBits(self.target)) {
                     32 => .{ .v_ss, .fmadd213 },
                     64 => .{ .v_sd, .fmadd213 },
                     16, 80, 128 => null,
                     else => unreachable,
                 },
                 .vector => switch (ty.childType(zcu).zigTypeTag(zcu)) {
-                    .float => switch (ty.childType(zcu).floatBits(self.target.*)) {
+                    .float => switch (ty.childType(zcu).floatBits(self.target)) {
                         32 => switch (ty.vectorLen(zcu)) {
                             1 => .{ .v_ss, .fmadd213 },
                             2...8 => .{ .v_ps, .fmadd213 },
@@ -180909,14 +184903,14 @@ fn airMulAdd(self: *CodeGen, inst: Air.Inst.Index) !void {
             }
         else if (std.mem.eql(u2, &order, &.{ 2, 3, 1 }) or std.mem.eql(u2, &order, &.{ 3, 2, 1 }))
             switch (ty.zigTypeTag(zcu)) {
-                .float => switch (ty.floatBits(self.target.*)) {
+                .float => switch (ty.floatBits(self.target)) {
                     32 => .{ .v_ss, .fmadd231 },
                     64 => .{ .v_sd, .fmadd231 },
                     16, 80, 128 => null,
                     else => unreachable,
                 },
                 .vector => switch (ty.childType(zcu).zigTypeTag(zcu)) {
-                    .float => switch (ty.childType(zcu).floatBits(self.target.*)) {
+                    .float => switch (ty.childType(zcu).floatBits(self.target)) {
                         32 => switch (ty.vectorLen(zcu)) {
                             1 => .{ .v_ss, .fmadd231 },
                             2...8 => .{ .v_ps, .fmadd231 },
@@ -181278,14 +185272,16 @@ const CallMCValues = struct {
     }
 };
 
+const win64_shadow_space = 8 * 4;
+
 /// Caller must call `CallMCValues.deinit`.
 fn resolveCallingConventionValues(
-    self: *CodeGen,
+    cg: *CodeGen,
     fn_info: InternPool.Key.FuncType,
     var_args: []const Type,
     stack_frame_base: FrameIndex,
 ) !CallMCValues {
-    const pt = self.pt;
+    const pt = cg.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     const cc = fn_info.cc;
@@ -181294,7 +185290,7 @@ fn resolveCallingConventionValues(
         param_types: [32][@sizeOf(Type)]u8 align(@alignOf(Type)),
     };
     var stack align(@max(@alignOf(ExpectedContents), @alignOf(std.heap.StackFallbackAllocator(0)))) =
-        std.heap.stackFallback(@sizeOf(ExpectedContents), self.gpa);
+        std.heap.stackFallback(@sizeOf(ExpectedContents), cg.gpa);
     const allocator = stack.get();
 
     const param_types = try allocator.alloc(Type, fn_info.param_types.len + var_args.len);
@@ -181303,10 +185299,10 @@ fn resolveCallingConventionValues(
     for (param_types[0..fn_info.param_types.len], fn_info.param_types.get(ip)) |*param_ty, arg_ty|
         param_ty.* = .fromInterned(arg_ty);
     for (param_types[fn_info.param_types.len..], var_args) |*param_ty, arg_ty|
-        param_ty.* = self.promoteVarArg(arg_ty);
+        param_ty.* = cg.promoteVarArg(arg_ty);
 
     var result: CallMCValues = .{
-        .args = try self.gpa.alloc(MCValue, param_types.len),
+        .args = try cg.gpa.alloc(MCValue, param_types.len),
         .air_arg_count = 0,
         // These undefined values must be populated before returning from this function.
         .return_value = undefined,
@@ -181316,29 +185312,30 @@ fn resolveCallingConventionValues(
         .fp_count = 0,
         .err_ret_trace_reg = .none,
     };
-    errdefer self.gpa.free(result.args);
+    errdefer cg.gpa.free(result.args);
 
     const ret_ty: Type = .fromInterned(fn_info.return_type);
     switch (cc) {
         .naked => {
             assert(result.args.len == 0);
             result.return_value = .init(.unreach);
-            result.stack_align = switch (self.target.cpu.arch) {
+            result.stack_align = switch (cg.target.cpu.arch) {
                 else => unreachable,
                 .x86 => .@"4",
                 .x86_64 => .@"8",
             };
         },
         .x86_64_sysv, .x86_64_win => |cc_opts| {
-            var ret_int_reg_i: u32 = 0;
-            var ret_sse_reg_i: u32 = 0;
-            var param_int_reg_i: u32 = 0;
-            var param_sse_reg_i: u32 = 0;
+            const param_gpr = abi.getCAbiIntParamRegs(cc);
+            var param_gpr_index: u32 = 0;
+            const param_sse = abi.getCAbiSseParamRegs(cc, cg.target);
+            var param_sse_index: u32 = 0;
+
             result.stack_align = .fromByteUnits(cc_opts.incoming_stack_alignment orelse 16);
 
             switch (cc) {
                 .x86_64_sysv => {},
-                .x86_64_win => result.stack_byte_count += @intCast(4 * 8),
+                .x86_64_win => result.stack_byte_count += @intCast(win64_shadow_space),
                 else => unreachable,
             }
 
@@ -181350,62 +185347,56 @@ fn resolveCallingConventionValues(
                 result.return_value = .init(.none);
             } else {
                 var ret_tracking: [4]InstTracking = undefined;
-                var ret_tracking_i: usize = 0;
+                var ret_tracking_len: u32 = 0;
+                var ret_gpr = abi.getCAbiIntReturnRegs(cc);
+                var ret_sse = abi.getCAbiSseReturnRegs(cc);
+                var ret_x87 = abi.getCAbiX87ReturnRegs(cc);
 
                 const classes = switch (cc) {
-                    .x86_64_sysv => std.mem.sliceTo(&abi.classifySystemV(ret_ty, zcu, self.target, .ret), .none),
-                    .x86_64_win => &.{abi.classifyWindows(ret_ty, zcu)},
+                    .x86_64_sysv => std.mem.sliceTo(&abi.classifySystemV(ret_ty, zcu, cg.target, .ret), .none),
+                    .x86_64_win => &.{abi.classifyWindows(ret_ty, zcu, cg.target)},
                     else => unreachable,
                 };
                 for (classes) |class| switch (class) {
                     .integer => {
-                        const ret_int_reg = registerAlias(
-                            abi.getCAbiIntReturnRegs(cc)[ret_int_reg_i],
+                        ret_tracking[ret_tracking_len] = .init(.{ .register = registerAlias(
+                            ret_gpr[0],
                             @intCast(@min(ret_ty.abiSize(zcu), 8)),
-                        );
-                        ret_int_reg_i += 1;
-
-                        ret_tracking[ret_tracking_i] = .init(.{ .register = ret_int_reg });
-                        ret_tracking_i += 1;
+                        ) });
+                        ret_tracking_len += 1;
+                        ret_gpr = ret_gpr[1..];
                     },
                     .sse, .float, .float_combine, .win_i128 => {
-                        const ret_sse_regs = abi.getCAbiSseReturnRegs(cc);
                         const abi_size: u32 = @intCast(ret_ty.abiSize(zcu));
-                        const reg_size = @min(abi_size, self.vectorSize(.float));
+                        const reg_size = @min(abi_size, cg.vectorSize(.float));
                         var byte_offset: u32 = 0;
                         while (byte_offset < abi_size) : (byte_offset += reg_size) {
-                            const ret_sse_reg = registerAlias(ret_sse_regs[ret_sse_reg_i], reg_size);
-                            ret_sse_reg_i += 1;
+                            const ret_sse_reg = registerAlias(ret_sse[0], reg_size);
+                            ret_sse = ret_sse[1..];
 
-                            ret_tracking[ret_tracking_i] = .init(.{ .register = ret_sse_reg });
-                            ret_tracking_i += 1;
+                            ret_tracking[ret_tracking_len] = .init(.{ .register = ret_sse_reg });
+                            ret_tracking_len += 1;
                         }
                     },
-                    .sseup => assert(ret_tracking[ret_tracking_i - 1].short.register.isClass(.sse)),
+                    .sseup => assert(ret_tracking[ret_tracking_len - 1].short.register.isClass(.sse)),
                     .x87 => {
-                        ret_tracking[ret_tracking_i] = .init(.{ .register = abi.getCAbiX87ReturnRegs(cc)[0] });
-                        ret_tracking_i += 1;
-                    },
-                    .x87up => assert(ret_tracking[ret_tracking_i - 1].short.register.isClass(.x87)),
-                    .complex_x87 => {
-                        ret_tracking[ret_tracking_i] = .init(.{ .register_pair = abi.getCAbiX87ReturnRegs(cc)[0..2].* });
-                        ret_tracking_i += 1;
-                    },
-                    .memory => {
-                        const ret_int_reg = abi.getCAbiIntReturnRegs(cc)[ret_int_reg_i].to64();
-                        ret_int_reg_i += 1;
-                        const ret_indirect_reg = abi.getCAbiIntParamRegs(cc)[param_int_reg_i];
-                        param_int_reg_i += 1;
-
-                        ret_tracking[ret_tracking_i] = .{
-                            .short = .{ .indirect = .{ .reg = ret_int_reg } },
-                            .long = .{ .indirect = .{ .reg = ret_indirect_reg } },
+                        ret_tracking[ret_tracking_len] = .init(.{ .register = ret_x87[0] });
+                        ret_tracking_len += 1;
+                        ret_x87 = ret_x87[1..];
+                    },
+                    .x87up => assert(ret_tracking[ret_tracking_len - 1].short.register.isClass(.x87)),
+                    .memory, .integer_per_element => {
+                        ret_tracking[ret_tracking_len] = .{
+                            .short = .{ .indirect = .{ .reg = ret_gpr[0].to64() } },
+                            .long = .{ .indirect = .{ .reg = param_gpr[param_gpr_index].to64() } },
                         };
-                        ret_tracking_i += 1;
+                        ret_tracking_len += 1;
+                        ret_gpr = ret_gpr[1..];
+                        param_gpr_index += 1;
                     },
-                    .none, .integer_per_element => unreachable,
+                    .none => unreachable,
                 };
-                result.return_value = switch (ret_tracking_i) {
+                result.return_value = switch (ret_tracking_len) {
                     else => unreachable,
                     1 => ret_tracking[0],
                     2 => .init(.{ .register_pair = .{
@@ -181427,97 +185418,96 @@ fn resolveCallingConventionValues(
             }
 
             // Input params
-            for (param_types, result.args) |ty, *arg| {
+            params: for (param_types, result.args) |ty, *arg| {
                 assert(ty.hasRuntimeBitsIgnoreComptime(zcu));
                 result.air_arg_count += 1;
                 switch (cc) {
                     .x86_64_sysv => {},
                     .x86_64_win => {
-                        param_int_reg_i = @max(param_int_reg_i, param_sse_reg_i);
-                        param_sse_reg_i = param_int_reg_i;
+                        param_gpr_index = @max(param_gpr_index, param_sse_index);
+                        param_sse_index = param_gpr_index;
                     },
                     else => unreachable,
                 }
 
                 var arg_mcv: [4]MCValue = undefined;
-                var arg_mcv_i: usize = 0;
+                var arg_mcv_len: u32 = 0;
 
                 const classes = switch (cc) {
-                    .x86_64_sysv => std.mem.sliceTo(&abi.classifySystemV(ty, zcu, self.target, .arg), .none),
-                    .x86_64_win => &.{abi.classifyWindows(ty, zcu)},
+                    .x86_64_sysv => std.mem.sliceTo(&abi.classifySystemV(ty, zcu, cg.target, .arg), .none),
+                    .x86_64_win => &.{abi.classifyWindows(ty, zcu, cg.target)},
                     else => unreachable,
                 };
                 classes: for (classes) |class| switch (class) {
                     .integer => {
-                        const param_int_regs = abi.getCAbiIntParamRegs(cc);
-                        if (param_int_reg_i >= param_int_regs.len) break;
-
-                        const param_int_reg =
-                            registerAlias(param_int_regs[param_int_reg_i], @intCast(@min(ty.abiSize(zcu), 8)));
-                        param_int_reg_i += 1;
-
-                        arg_mcv[arg_mcv_i] = .{ .register = param_int_reg };
-                        arg_mcv_i += 1;
+                        if (param_gpr_index >= param_gpr.len) break;
+                        arg_mcv[arg_mcv_len] = .{
+                            .register = registerAlias(param_gpr[param_gpr_index], @intCast(@min(ty.abiSize(zcu), 8))),
+                        };
+                        arg_mcv_len += 1;
+                        param_gpr_index += 1;
                     },
                     .sse, .float, .float_combine => {
-                        const param_sse_regs = abi.getCAbiSseParamRegs(cc, self.target);
                         const abi_size: u32 = @intCast(ty.abiSize(zcu));
-                        const reg_size = @min(abi_size, self.vectorSize(.float));
+                        const reg_size = @min(abi_size, cg.vectorSize(.float));
                         var byte_offset: u32 = 0;
                         while (byte_offset < abi_size) : (byte_offset += reg_size) {
-                            if (param_sse_reg_i >= param_sse_regs.len) break :classes;
+                            if (param_sse_index >= param_sse.len) break :classes;
 
-                            const param_sse_reg = registerAlias(param_sse_regs[param_sse_reg_i], reg_size);
-                            param_sse_reg_i += 1;
+                            const param_sse_reg = registerAlias(param_sse[param_sse_index], reg_size);
+                            param_sse_index += 1;
 
-                            arg_mcv[arg_mcv_i] = .{ .register = param_sse_reg };
-                            arg_mcv_i += 1;
+                            arg_mcv[arg_mcv_len] = .{ .register = param_sse_reg };
+                            arg_mcv_len += 1;
                         }
                     },
-                    .sseup => assert(arg_mcv[arg_mcv_i - 1].register.isClass(.sse)),
-                    .x87, .x87up, .complex_x87, .memory, .win_i128 => switch (cc) {
+                    .sseup => assert(arg_mcv[arg_mcv_len - 1].register.isClass(.sse)),
+                    .x87, .x87up, .memory, .win_i128 => switch (cc) {
                         .x86_64_sysv => switch (class) {
-                            .x87, .x87up, .complex_x87, .memory => break,
+                            .x87, .x87up, .memory => break,
                             else => unreachable,
                         },
                         .x86_64_win => if (ty.abiSize(zcu) > 8) {
-                            const param_int_reg = abi.getCAbiIntParamRegs(cc)[param_int_reg_i].to64();
-                            param_int_reg_i += 1;
-
-                            arg_mcv[arg_mcv_i] = .{ .indirect = .{ .reg = param_int_reg } };
-                            arg_mcv_i += 1;
+                            if (param_gpr_index < param_gpr.len) {
+                                arg_mcv[arg_mcv_len] = .{ .indirect = .{ .reg = param_gpr[param_gpr_index].to64() } };
+                                arg_mcv_len += 1;
+                                param_gpr_index += 1;
+                            } else {
+                                assert(arg_mcv_len == 0);
+                                const param_align = Type.usize.abiAlignment(zcu);
+                                result.stack_byte_count = @intCast(param_align.forward(result.stack_byte_count));
+                                result.stack_align = result.stack_align.max(param_align);
+                                arg.* = .{ .indirect_load_frame = .{
+                                    .index = stack_frame_base,
+                                    .off = result.stack_byte_count,
+                                } };
+                                result.stack_byte_count += @intCast(Type.usize.abiSize(zcu));
+                                continue :params;
+                            }
                         } else break,
                         else => unreachable,
                     },
                     .none => unreachable,
                     .integer_per_element => {
-                        const param_int_regs_len: u32 =
-                            @intCast(abi.getCAbiIntParamRegs(cc).len);
-                        const remaining_param_int_regs: u3 =
-                            @intCast(param_int_regs_len - param_int_reg_i);
-                        param_int_reg_i = param_int_regs_len;
+                        const remaining_param_gpr_len: u3 = @intCast(param_gpr.len - param_gpr_index);
+                        param_gpr_index = @intCast(param_gpr.len);
 
                         const frame_elem_align = 8;
-                        const frame_elems_len = ty.vectorLen(zcu) - remaining_param_int_regs;
-                        const frame_elem_size = std.mem.alignForward(
-                            u64,
-                            ty.childType(zcu).abiSize(zcu),
-                            frame_elem_align,
-                        );
+                        const frame_elems_len = ty.vectorLen(zcu) - remaining_param_gpr_len;
+                        const frame_elem_size = std.mem.alignForward(u64, ty.childType(zcu).abiSize(zcu), frame_elem_align);
                         const frame_size: u31 = @intCast(frame_elems_len * frame_elem_size);
 
-                        result.stack_byte_count =
-                            std.mem.alignForward(u31, result.stack_byte_count, frame_elem_align);
-                        arg_mcv[arg_mcv_i] = .{ .elementwise_args = .{
-                            .regs = remaining_param_int_regs,
+                        result.stack_byte_count = std.mem.alignForward(u31, result.stack_byte_count, frame_elem_align);
+                        arg_mcv[arg_mcv_len] = .{ .elementwise_args = .{
+                            .regs = remaining_param_gpr_len,
                             .frame_off = @intCast(result.stack_byte_count),
                             .frame_index = stack_frame_base,
                         } };
-                        arg_mcv_i += 1;
+                        arg_mcv_len += 1;
                         result.stack_byte_count += frame_size;
                     },
                 } else {
-                    arg.* = switch (arg_mcv_i) {
+                    arg.* = switch (arg_mcv_len) {
                         else => unreachable,
                         1 => arg_mcv[0],
                         2 => .{ .register_pair = .{
@@ -181548,17 +185538,17 @@ fn resolveCallingConventionValues(
                 } };
                 result.stack_byte_count += @intCast(ty.abiSize(zcu));
             }
-            assert(param_int_reg_i <= 6);
-            result.gp_count = param_int_reg_i;
-            assert(param_sse_reg_i <= 16);
-            result.fp_count = param_sse_reg_i;
+            assert(param_gpr_index <= 6);
+            result.gp_count = param_gpr_index;
+            assert(param_sse_index <= 16);
+            result.fp_count = param_sse_index;
         },
         .auto => {
-            result.stack_align = abi.zigcc.stack_align orelse .fromByteUnits(self.vectorSize(.float));
+            result.stack_align = abi.zigcc.stack_align orelse .fromByteUnits(cg.vectorSize(.float));
 
             var param_gpr = abi.getCAbiIntParamRegs(cc);
             var param_x87 = abi.getCAbiX87ParamRegs(cc);
-            var param_sse = abi.getCAbiSseParamRegs(cc, self.target);
+            var param_sse = abi.getCAbiSseParamRegs(cc, cg.target);
 
             if (zcu.comp.config.any_error_tracing) {
                 result.err_ret_trace_reg = param_gpr[param_gpr.len - 1];
@@ -181573,8 +185563,8 @@ fn resolveCallingConventionValues(
             else return_value: {
                 const ret_gpr = abi.getCAbiIntReturnRegs(cc);
                 const ret_size: u31 = @intCast(ret_ty.abiSize(zcu));
-                if (abi.zigcc.return_in_regs) switch (self.regClassForType(ret_ty)) {
-                    .general_purpose, .gphi => if (ret_size <= @as(u4, switch (self.target.cpu.arch) {
+                if (abi.zigcc.return_in_regs) switch (cg.regClassForType(ret_ty)) {
+                    .general_purpose, .gphi => if (ret_size <= @as(u4, switch (cg.target.cpu.arch) {
                         else => unreachable,
                         .x86 => 4,
                         .x86_64 => 8,
@@ -181584,7 +185574,7 @@ fn resolveCallingConventionValues(
                         break :return_value .init(.{ .register_pair = ret_gpr[0..2].* }),
                     .segment, .mmx, .ip, .cr, .dr => unreachable,
                     .x87 => if (ret_size <= 16) break :return_value .init(.{ .register = .st0 }),
-                    .sse => if (ret_size <= self.vectorSize(.float)) break :return_value .init(.{
+                    .sse => if (ret_size <= cg.vectorSize(.float)) break :return_value .init(.{
                         .register = registerAlias(abi.getCAbiSseReturnRegs(cc)[0], @max(ret_size, 16)),
                     }),
                 };
@@ -181604,8 +185594,8 @@ fn resolveCallingConventionValues(
                 }
                 result.air_arg_count += 1;
                 const param_size: u31 = @intCast(param_ty.abiSize(zcu));
-                if (abi.zigcc.params_in_regs) switch (self.regClassForType(param_ty)) {
-                    .general_purpose, .gphi => if (param_gpr.len >= 1 and param_size <= @as(u4, switch (self.target.cpu.arch) {
+                if (abi.zigcc.params_in_regs) switch (cg.regClassForType(param_ty)) {
+                    .general_purpose, .gphi => if (param_gpr.len >= 1 and param_size <= @as(u4, switch (cg.target.cpu.arch) {
                         else => unreachable,
                         .x86 => 4,
                         .x86_64 => 8,
@@ -181624,7 +185614,7 @@ fn resolveCallingConventionValues(
                         param_x87 = param_x87[1..];
                         continue;
                     },
-                    .sse => if (param_sse.len >= 1 and param_size <= self.vectorSize(.float)) {
+                    .sse => if (param_sse.len >= 1 and param_size <= cg.vectorSize(.float)) {
                         arg.* = .{
                             .register = registerAlias(param_sse[0], @max(param_size, 16)),
                         };
@@ -181642,27 +185632,27 @@ fn resolveCallingConventionValues(
                 result.stack_byte_count += param_size;
             }
         },
-        else => return self.fail("TODO implement function parameters and return values for {} on x86_64", .{cc}),
+        else => return cg.fail("TODO implement function parameters and return values for {} on x86_64", .{cc}),
     }
 
     result.stack_byte_count = @intCast(result.stack_align.forward(result.stack_byte_count));
     return result;
 }
 
-fn fail(self: *CodeGen, comptime format: []const u8, args: anytype) error{ OutOfMemory, CodegenFail } {
+fn fail(cg: *CodeGen, comptime format: []const u8, args: anytype) error{ OutOfMemory, CodegenFail } {
     @branchHint(.cold);
-    const zcu = self.pt.zcu;
-    switch (self.owner) {
+    const zcu = cg.pt.zcu;
+    switch (cg.owner) {
         .nav_index => |i| return zcu.codegenFail(i, format, args),
         .lazy_sym => |s| return zcu.codegenFailType(s.ty, format, args),
     }
     return error.CodegenFail;
 }
 
-fn failMsg(self: *CodeGen, msg: *Zcu.ErrorMsg) error{ OutOfMemory, CodegenFail } {
+fn failMsg(cg: *CodeGen, msg: *Zcu.ErrorMsg) error{ OutOfMemory, CodegenFail } {
     @branchHint(.cold);
-    const zcu = self.pt.zcu;
-    switch (self.owner) {
+    const zcu = cg.pt.zcu;
+    switch (cg.owner) {
         .nav_index => |i| return zcu.codegenFailMsg(i, msg),
         .lazy_sym => |s| return zcu.codegenFailTypeMsg(s.ty, msg),
     }
@@ -181979,7 +185969,7 @@ fn promoteInt(self: *CodeGen, ty: Type) Type {
 
 fn promoteVarArg(self: *CodeGen, ty: Type) Type {
     if (!ty.isRuntimeFloat()) return self.promoteInt(ty);
-    switch (ty.floatBits(self.target.*)) {
+    switch (ty.floatBits(self.target)) {
         32, 64 => return .f64,
         else => |float_bits| {
             assert(float_bits == self.target.cTypeBitSize(.longdouble));
@@ -182080,7 +186070,7 @@ fn intInfo(cg: *CodeGen, ty: Type) ?std.builtin.Type.Int {
 }
 
 fn floatBits(cg: *CodeGen, ty: Type) ?u16 {
-    return if (ty.isRuntimeFloat()) ty.floatBits(cg.target.*) else null;
+    return if (ty.isRuntimeFloat()) ty.floatBits(cg.target) else null;
 }
 
 const Temp = struct {
@@ -182127,6 +186117,7 @@ const Temp = struct {
                 .register_mask,
                 .memory,
                 .indirect,
+                .indirect_load_frame,
                 .lea_frame,
                 .load_nav,
                 .lea_nav,
@@ -182200,7 +186191,7 @@ const Temp = struct {
                 switch (temp_tracking.short) {
                     else => {},
                     .register => |reg| {
-                        try cg.freeValue(temp_tracking.long);
+                        try cg.freeValue(temp_tracking.long, .{});
                         temp_tracking.* = .init(.{ .register_offset = .{
                             .reg = reg,
                             .off = off,
@@ -182208,7 +186199,7 @@ const Temp = struct {
                         return;
                     },
                     .register_offset => |reg_off| {
-                        try cg.freeValue(temp_tracking.long);
+                        try cg.freeValue(temp_tracking.long, .{});
                         temp_tracking.* = .init(.{ .register_offset = .{
                             .reg = reg_off.reg,
                             .off = reg_off.off + off,
@@ -182598,6 +186589,7 @@ const Temp = struct {
             .register_quadruple,
             .register_overflow,
             .register_mask,
+            .indirect_load_frame,
             .elementwise_args,
             .reserved_frame,
             .air_ref,
@@ -182675,7 +186667,7 @@ const Temp = struct {
             .register_quadruple,
             => |val_regs| for (val_regs) |val_reg| {
                 try ptr.loadReg(val_ty, val_reg, cg);
-                try ptr.toOffset(@divExact(val_reg.bitSize(), 8), cg);
+                try ptr.toOffset(@intCast(@divExact(val_reg.size().bitSize(cg.target), 8)), cg);
                 while (try ptr.toLea(cg)) {}
             },
             .register_offset => |val_reg_off| switch (val_reg_off.off) {
@@ -182820,7 +186812,7 @@ const Temp = struct {
                 var disp = opts.disp;
                 for (val_regs) |val_reg| {
                     try src.readReg(disp, val_ty, val_reg, cg);
-                    disp += @divExact(val_reg.bitSize(), 8);
+                    disp += @intCast(@divExact(val_reg.size().bitSize(cg.target), 8));
                 }
             },
             .register_offset => |val_reg_off| switch (val_reg_off.off) {
@@ -182950,25 +186942,59 @@ const Temp = struct {
                 while (try ptr.toRegClass(false, .general_purpose, cg)) {},
         }
         try strat.read(cg, dst_reg, try ptr.tracking(cg).short.deref().mem(cg, .{
-            .size = .fromBitSize(@min(8 * dst_ty.abiSize(cg.pt.zcu), dst_reg.bitSize())),
+            .size = cg.memSize(dst_ty),
         }));
     }
 
     fn storeRegs(ptr: *Temp, src_ty: Type, src_regs: []const Register, cg: *CodeGen) InnerError!void {
+        const zcu = cg.pt.zcu;
+        const ip = &zcu.intern_pool;
         var part_disp: u31 = 0;
         var deferred_disp: u31 = 0;
         var src_abi_size: u32 = @intCast(src_ty.abiSize(cg.pt.zcu));
-        for (src_regs) |src_reg| {
+        for (src_regs, 0..) |src_reg, part_index| {
+            const part_ty: Type = if (src_regs.len == 1)
+                src_ty
+            else if (cg.intInfo(src_ty)) |int_info| part_ty: {
+                assert(src_regs.len == std.math.divCeil(u16, int_info.bits, 64) catch unreachable);
+                break :part_ty .u64;
+            } else part_ty: switch (ip.indexToKey(src_ty.toIntern())) {
+                else => std.debug.panic("{s}: {}\n", .{ @src().fn_name, src_ty.fmt(cg.pt) }),
+                .ptr_type => |ptr_info| {
+                    assert(ptr_info.flags.size == .slice);
+                    assert(src_regs.len == 2);
+                    break :part_ty .usize;
+                },
+                .array_type => {
+                    assert(src_regs.len - part_index == std.math.divCeil(u32, src_abi_size, 8) catch unreachable);
+                    break :part_ty try cg.pt.intType(.unsigned, @as(u16, 8) * @min(src_abi_size, 8));
+                },
+                .opt_type => |opt_child| switch (ip.indexToKey(opt_child)) {
+                    else => std.debug.panic("{s}: {}\n", .{ @src().fn_name, src_ty.fmt(cg.pt) }),
+                    .ptr_type => |ptr_info| {
+                        assert(ptr_info.flags.size == .slice);
+                        assert(src_regs.len == 2);
+                        break :part_ty .usize;
+                    },
+                },
+                .struct_type => {
+                    assert(src_regs.len - part_index == std.math.divCeil(u32, src_abi_size, 8) catch unreachable);
+                    break :part_ty .u64;
+                },
+            };
+            const part_size: u31 = @intCast(part_ty.abiSize(zcu));
             const src_rc = src_reg.class();
-            const part_bit_size = @min(8 * src_abi_size, src_reg.bitSize());
-            const part_size = @divExact(part_bit_size, 8);
+            const part_bit_size = switch (src_rc) {
+                else => 8 * part_size,
+                .x87 => part_ty.bitSize(zcu),
+            };
             if (src_rc == .x87 or std.math.isPowerOfTwo(part_size)) {
                 // hack around linker relocation bugs
                 switch (ptr.tracking(cg).short) {
                     else => {},
                     .lea_nav, .lea_uav, .lea_lazy_sym => while (try ptr.toRegClass(false, .general_purpose, cg)) {},
                 }
-                const strat = try cg.moveStrategy(src_ty, src_rc, false);
+                const strat = try cg.moveStrategy(part_ty, src_rc, false);
                 try strat.write(cg, try ptr.tracking(cg).short.deref().mem(cg, .{
                     .size = .fromBitSize(part_bit_size),
                     .disp = part_disp,
@@ -182979,7 +187005,7 @@ const Temp = struct {
                     .size = frame_size,
                     .alignment = .fromNonzeroByteUnits(frame_size),
                 }));
-                const strat = try cg.moveStrategy(src_ty, src_rc, true);
+                const strat = try cg.moveStrategy(part_ty, src_rc, true);
                 try strat.write(cg, .{
                     .base = .{ .frame = frame_index },
                     .mod = .{ .rm = .{ .size = .fromSize(frame_size) } },
@@ -183001,7 +187027,7 @@ const Temp = struct {
     fn readReg(src: Temp, disp: i32, dst_ty: Type, dst_reg: Register, cg: *CodeGen) InnerError!void {
         const strat = try cg.moveStrategy(dst_ty, dst_reg.class(), false);
         try strat.read(cg, dst_reg, try src.tracking(cg).short.mem(cg, .{
-            .size = .fromBitSize(@min(8 * dst_ty.abiSize(cg.pt.zcu), dst_reg.bitSize())),
+            .size = cg.memSize(dst_ty),
             .disp = disp,
         }));
     }
@@ -183012,7 +187038,7 @@ const Temp = struct {
         if (src_rc == .x87 or std.math.isPowerOfTwo(src_abi_size)) {
             const strat = try cg.moveStrategy(src_ty, src_rc, false);
             try strat.write(cg, try dst.tracking(cg).short.mem(cg, .{
-                .size = .fromBitSize(@min(8 * src_abi_size, src_reg.bitSize())),
+                .size = cg.memSize(src_ty),
                 .disp = disp,
             }), registerAlias(src_reg, src_abi_size));
         } else {
@@ -183050,14 +187076,14 @@ const Temp = struct {
                 .integer, .memory, .float, .float_combine => class_index + 1,
                 .sse => std.mem.indexOfNonePos(abi.Class, classes, class_index + 1, &.{.sseup}) orelse classes.len,
                 .x87 => std.mem.indexOfNonePos(abi.Class, classes, class_index + 1, &.{.x87up}) orelse classes.len,
-                .sseup, .x87up, .complex_x87, .none, .win_i128, .integer_per_element => unreachable,
+                .sseup, .x87up, .none, .win_i128, .integer_per_element => unreachable,
             });
             const part_size = switch (class) {
                 .integer, .sse, .memory => @min(8 * @as(u7, next_class_index - class_index), remaining_abi_size),
                 .x87 => 16,
                 .float => 4,
                 .float_combine => 8,
-                .sseup, .x87up, .complex_x87, .none, .win_i128, .integer_per_element => unreachable,
+                .sseup, .x87up, .none, .win_i128, .integer_per_element => unreachable,
             };
             try dst.writeReg(part_disp, switch (class) {
                 .integer => .u64,
@@ -183070,7 +187096,7 @@ const Temp = struct {
                 .x87 => .f80,
                 .float => .f32,
                 .float_combine => .vector_2_f32,
-                .sseup, .x87up, .complex_x87, .memory, .none, .win_i128, .integer_per_element => unreachable,
+                .sseup, .x87up, .memory, .none, .win_i128, .integer_per_element => unreachable,
             }, src_reg, cg);
             part_disp += part_size;
             remaining_abi_size -= part_size;
@@ -186718,12 +190744,12 @@ const Temp = struct {
                 .{ ._, ._, .div, .src1q, ._, ._, ._ },
             } },
         }, .{
-            .required_features = .{ .@"64bit", null, null, null },
+            .required_cc_abi = .sysv64,
             .src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any },
             .patterns = &.{
                 .{ .src = .{
-                    .{ .to_param_gpr_pair = .{ .cc = .ccc, .at = 0 } },
-                    .{ .to_param_gpr_pair = .{ .cc = .ccc, .at = 2 } },
+                    .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                    .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 2, .at = 2 } },
                     .none,
                 } },
             },
@@ -186741,18 +190767,46 @@ const Temp = struct {
                 .unused,
                 .unused,
             },
-            .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .at = 0 } }, .unused },
+            .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
             .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
             .each = .{ .once = &.{
                 .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
             } },
         }, .{
-            .required_features = .{ .@"64bit", null, null, null },
+            .required_cc_abi = .win64,
+            .required_features = .{ .sse, null, null, null },
+            .src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any },
+            .patterns = &.{
+                .{ .src = .{ .to_mem, .to_mem, .none } },
+            },
+            .call_frame = .{ .alignment = .@"16" },
+            .extra_temps = .{
+                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                .{ .type = .usize, .kind = .{ .extern_func = "__divti3" } },
+                .unused,
+                .unused,
+                .unused,
+                .unused,
+                .unused,
+                .unused,
+                .unused,
+                .unused,
+            },
+            .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
+            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+            .each = .{ .once = &.{
+                .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
+                .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
+                .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+            } },
+        }, .{
+            .required_cc_abi = .sysv64,
             .src_constraints = .{ .{ .unsigned_int = .xword }, .{ .unsigned_int = .xword }, .any },
             .patterns = &.{
                 .{ .src = .{
-                    .{ .to_param_gpr_pair = .{ .cc = .ccc, .at = 0 } },
-                    .{ .to_param_gpr_pair = .{ .cc = .ccc, .at = 2 } },
+                    .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } },
+                    .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 2, .at = 2 } },
                     .none,
                 } },
             },
@@ -186770,12 +190824,40 @@ const Temp = struct {
                 .unused,
                 .unused,
             },
-            .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .at = 0 } }, .unused },
+            .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
             .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
             .each = .{ .once = &.{
                 .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
             } },
         }, .{
+            .required_cc_abi = .win64,
+            .required_features = .{ .sse, null, null, null },
+            .src_constraints = .{ .{ .unsigned_int = .xword }, .{ .unsigned_int = .xword }, .any },
+            .patterns = &.{
+                .{ .src = .{ .to_mem, .to_mem, .none } },
+            },
+            .call_frame = .{ .alignment = .@"16" },
+            .extra_temps = .{
+                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                .{ .type = .usize, .kind = .{ .extern_func = "__udivti3" } },
+                .unused,
+                .unused,
+                .unused,
+                .unused,
+                .unused,
+                .unused,
+                .unused,
+                .unused,
+            },
+            .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
+            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+            .each = .{ .once = &.{
+                .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
+                .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
+                .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+            } },
+        }, .{
             .required_features = .{ .@"64bit", null, null, null },
             .src_constraints = .{
                 .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } },
@@ -186787,10 +190869,10 @@ const Temp = struct {
             },
             .call_frame = .{ .alignment = .@"16" },
             .extra_temps = .{
-                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 0 } } },
-                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 1 } } },
-                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 2 } } },
-                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } },
+                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
+                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                 .{ .type = .usize, .kind = .{ .extern_func = "__divei4" } },
                 .unused,
                 .unused,
@@ -186820,10 +190902,10 @@ const Temp = struct {
             },
             .call_frame = .{ .alignment = .@"16" },
             .extra_temps = .{
-                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 0 } } },
-                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 1 } } },
-                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 2 } } },
-                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } },
+                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
+                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                 .{ .type = .usize, .kind = .{ .extern_func = "__udivei4" } },
                 .unused,
                 .unused,
@@ -187172,7 +191254,7 @@ const Temp = struct {
                 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
             } },
         }, .{
-            .required_features = .{ .@"64bit", null, null, null },
+            .required_cc_abi = .sysv64,
             .src_constraints = .{
                 .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } },
                 .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } },
@@ -187184,12 +191266,12 @@ const Temp = struct {
             .call_frame = .{ .alignment = .@"16" },
             .extra_temps = .{
                 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 0 } } },
-                .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 1 } } },
-                .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 2 } } },
-                .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } },
+                .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
+                .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                 .{ .type = .usize, .kind = .{ .extern_func = "__divti3" } },
-                .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .at = 0 } } },
+                .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                 .unused,
                 .unused,
                 .unused,
@@ -187210,7 +191292,115 @@ const Temp = struct {
                 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
             } },
         }, .{
-            .required_features = .{ .@"64bit", null, null, null },
+            .required_cc_abi = .win64,
+            .required_features = .{ .avx, null, null, null },
+            .src_constraints = .{
+                .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } },
+                .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } },
+                .any,
+            },
+            .patterns = &.{
+                .{ .src = .{ .to_mem, .to_mem, .none } },
+            },
+            .call_frame = .{ .alignment = .@"16" },
+            .extra_temps = .{
+                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                .{ .type = .usize, .kind = .{ .extern_func = "__divti3" } },
+                .{ .type = .i128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                .unused,
+                .unused,
+                .unused,
+                .unused,
+                .unused,
+                .unused,
+            },
+            .dst_temps = .{ .mem, .unused },
+            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+            .each = .{ .once = &.{
+                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
+                .{ ._, ._, .lea, .tmp2p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ },
+                .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
+                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+            } },
+        }, .{
+            .required_cc_abi = .win64,
+            .required_features = .{ .sse2, null, null, null },
+            .src_constraints = .{
+                .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } },
+                .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } },
+                .any,
+            },
+            .patterns = &.{
+                .{ .src = .{ .to_mem, .to_mem, .none } },
+            },
+            .call_frame = .{ .alignment = .@"16" },
+            .extra_temps = .{
+                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                .{ .type = .usize, .kind = .{ .extern_func = "__divti3" } },
+                .{ .type = .i128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                .unused,
+                .unused,
+                .unused,
+                .unused,
+                .unused,
+                .unused,
+            },
+            .dst_temps = .{ .mem, .unused },
+            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+            .each = .{ .once = &.{
+                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
+                .{ ._, ._, .lea, .tmp2p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ },
+                .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
+                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+            } },
+        }, .{
+            .required_cc_abi = .win64,
+            .required_features = .{ .sse, null, null, null },
+            .src_constraints = .{
+                .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } },
+                .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } },
+                .any,
+            },
+            .patterns = &.{
+                .{ .src = .{ .to_mem, .to_mem, .none } },
+            },
+            .call_frame = .{ .alignment = .@"16" },
+            .extra_temps = .{
+                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                .{ .type = .usize, .kind = .{ .extern_func = "__divti3" } },
+                .{ .type = .i128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                .unused,
+                .unused,
+                .unused,
+                .unused,
+                .unused,
+                .unused,
+            },
+            .dst_temps = .{ .mem, .unused },
+            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+            .each = .{ .once = &.{
+                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
+                .{ ._, ._, .lea, .tmp2p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ },
+                .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
+                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+            } },
+        }, .{
+            .required_cc_abi = .sysv64,
             .src_constraints = .{
                 .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } },
                 .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } },
@@ -187222,12 +191412,12 @@ const Temp = struct {
             .call_frame = .{ .alignment = .@"16" },
             .extra_temps = .{
                 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 0 } } },
-                .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 1 } } },
-                .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 2 } } },
-                .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } },
+                .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
+                .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                 .{ .type = .usize, .kind = .{ .extern_func = "__udivti3" } },
-                .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .at = 0 } } },
+                .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                 .unused,
                 .unused,
                 .unused,
@@ -187248,6 +191438,114 @@ const Temp = struct {
                 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
             } },
         }, .{
+            .required_cc_abi = .win64,
+            .required_features = .{ .avx, null, null, null },
+            .src_constraints = .{
+                .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } },
+                .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } },
+                .any,
+            },
+            .patterns = &.{
+                .{ .src = .{ .to_mem, .to_mem, .none } },
+            },
+            .call_frame = .{ .alignment = .@"16" },
+            .extra_temps = .{
+                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                .{ .type = .usize, .kind = .{ .extern_func = "__udivti3" } },
+                .{ .type = .u128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                .unused,
+                .unused,
+                .unused,
+                .unused,
+                .unused,
+                .unused,
+            },
+            .dst_temps = .{ .mem, .unused },
+            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+            .each = .{ .once = &.{
+                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
+                .{ ._, ._, .lea, .tmp2p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ },
+                .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
+                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+            } },
+        }, .{
+            .required_cc_abi = .win64,
+            .required_features = .{ .sse2, null, null, null },
+            .src_constraints = .{
+                .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } },
+                .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } },
+                .any,
+            },
+            .patterns = &.{
+                .{ .src = .{ .to_mem, .to_mem, .none } },
+            },
+            .call_frame = .{ .alignment = .@"16" },
+            .extra_temps = .{
+                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                .{ .type = .usize, .kind = .{ .extern_func = "__udivti3" } },
+                .{ .type = .u128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                .unused,
+                .unused,
+                .unused,
+                .unused,
+                .unused,
+                .unused,
+            },
+            .dst_temps = .{ .mem, .unused },
+            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+            .each = .{ .once = &.{
+                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
+                .{ ._, ._, .lea, .tmp2p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ },
+                .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
+                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+            } },
+        }, .{
+            .required_cc_abi = .win64,
+            .required_features = .{ .sse, null, null, null },
+            .src_constraints = .{
+                .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } },
+                .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } },
+                .any,
+            },
+            .patterns = &.{
+                .{ .src = .{ .to_mem, .to_mem, .none } },
+            },
+            .call_frame = .{ .alignment = .@"16" },
+            .extra_temps = .{
+                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                .{ .type = .usize, .kind = .{ .extern_func = "__udivti3" } },
+                .{ .type = .u128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                .unused,
+                .unused,
+                .unused,
+                .unused,
+                .unused,
+                .unused,
+            },
+            .dst_temps = .{ .mem, .unused },
+            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+            .each = .{ .once = &.{
+                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
+                .{ ._, ._, .lea, .tmp2p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ },
+                .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
+                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+            } },
+        }, .{
             .required_features = .{ .@"64bit", null, null, null },
             .src_constraints = .{
                 .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } },
@@ -187260,10 +191558,10 @@ const Temp = struct {
             .call_frame = .{ .alignment = .@"16" },
             .extra_temps = .{
                 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 0 } } },
-                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 1 } } },
-                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 2 } } },
-                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } },
+                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
+                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                 .{ .type = .usize, .kind = .{ .extern_func = "__divei4" } },
                 .unused,
                 .unused,
@@ -187296,10 +191594,10 @@ const Temp = struct {
             .call_frame = .{ .alignment = .@"16" },
             .extra_temps = .{
                 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 0 } } },
-                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 1 } } },
-                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 2 } } },
-                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } },
+                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
+                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
+                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
+                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                 .{ .type = .usize, .kind = .{ .extern_func = "__udivei4" } },
                 .unused,
                 .unused,
@@ -187337,14 +191635,21 @@ const Temp = struct {
             if (op_temp.tracking(cg).short != .dead) try op_temp.die(cg);
             if (tomb_bits & @as(Air.Liveness.Bpi, 1) << @intCast(op_index) == 0) continue;
             if (cg.reused_operands.isSet(op_index)) continue;
-            try cg.processDeath(op_ref.toIndexAllowNone() orelse continue);
+            try cg.processDeath(op_ref.toIndexAllowNone() orelse continue, .{});
         }
         if (cg.liveness.isUnused(inst)) try temp.die(cg) else {
             switch (temp.unwrap(cg)) {
                 .ref, .err_ret_trace => {
                     const temp_mcv = temp.tracking(cg).short;
                     const result = result: switch (temp_mcv) {
-                        .none, .unreach, .dead, .elementwise_args, .reserved_frame, .air_ref => unreachable,
+                        .none,
+                        .unreach,
+                        .dead,
+                        .indirect_load_frame,
+                        .elementwise_args,
+                        .reserved_frame,
+                        .air_ref,
+                        => unreachable,
                         .undef, .immediate, .lea_frame => temp_mcv,
                         .eflags,
                         .register,
@@ -187386,14 +191691,14 @@ const Temp = struct {
             if (op_temp.index != temp.index) continue;
             if (tomb_bits & @as(Air.Liveness.Bpi, 1) << @intCast(op_index) == 0) continue;
             if (cg.reused_operands.isSet(op_index)) continue;
-            try cg.processDeath(op_ref.toIndexAllowNone() orelse continue);
+            try cg.processDeath(op_ref.toIndexAllowNone() orelse continue, .{});
         }
     }
 
     fn die(temp: Temp, cg: *CodeGen) InnerError!void {
         switch (temp.unwrap(cg)) {
             .ref, .err_ret_trace => {},
-            .temp => |temp_index| try temp_index.tracking(cg).die(cg, temp_index.toIndex()),
+            .temp => |temp_index| try temp_index.tracking(cg).die(cg, temp_index.toIndex(), .{}),
         }
     }
 
@@ -187779,6 +192084,8 @@ const Select = struct {
     }
 
     const Case = struct {
+        required_abi: enum { any, gnu, msvc } = .any,
+        required_cc_abi: enum { any, sysv64, win64 } = .any,
         required_features: [4]?std.Target.x86.Feature = @splat(null),
         src_constraints: [@intFromEnum(Select.Operand.Ref.none) - @intFromEnum(Select.Operand.Ref.src0)]Constraint = @splat(.any),
         dst_constraints: [@intFromEnum(Select.Operand.Ref.src0) - @intFromEnum(Select.Operand.Ref.dst0)]Constraint = @splat(.any),
@@ -188151,6 +192458,7 @@ const Select = struct {
             to_reg_pair: [2]Register,
             to_param_gpr: TempSpec.Kind.CallConvRegSpec,
             to_param_gpr_pair: TempSpec.Kind.CallConvRegSpec,
+            to_param_sse: TempSpec.Kind.CallConvRegSpec,
             to_ret_gpr: TempSpec.Kind.CallConvRegSpec,
             to_ret_gpr_pair: TempSpec.Kind.CallConvRegSpec,
             mem,
@@ -188238,7 +192546,7 @@ const Select = struct {
                     .mem => temp.tracking(cg).short.isMemory(),
                     .to_mem, .to_mut_mem => true,
                     .mut_mem => temp.isMut(cg) and temp.tracking(cg).short.isMemory(),
-                    .to_reg, .to_reg_pair, .to_param_gpr, .to_param_gpr_pair, .to_ret_gpr, .to_ret_gpr_pair => true,
+                    .to_reg, .to_reg_pair, .to_param_gpr, .to_param_gpr_pair, .to_param_sse, .to_ret_gpr, .to_ret_gpr_pair => true,
                     .gpr => temp.typeOf(cg).abiSize(cg.pt.zcu) <= 8 and switch (temp.tracking(cg).short) {
                         .register => |reg| reg.isClass(.general_purpose),
                         .register_offset => |reg_off| reg_off.reg.isClass(.general_purpose) and reg_off.off == 0,
@@ -188343,10 +192651,11 @@ const Select = struct {
                     .mut_mem, .to_mut_mem => try temp.toBase(true, cg),
                     .to_reg => |reg| try temp.toReg(reg, cg),
                     .to_reg_pair => |regs| try temp.toRegPair(regs, cg),
-                    .to_param_gpr => |param_spec| try temp.toReg(abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.at], cg),
-                    .to_param_gpr_pair => |param_spec| try temp.toRegPair(abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.at..][0..2].*, cg),
-                    .to_ret_gpr => |ret_spec| try temp.toReg(abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.at], cg),
-                    .to_ret_gpr_pair => |ret_spec| try temp.toRegPair(abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.at..][0..2].*, cg),
+                    .to_param_gpr => |param_spec| try temp.toReg(abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.index(cg)], cg),
+                    .to_param_gpr_pair => |param_spec| try temp.toRegPair(abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.index(cg)..][0..2].*, cg),
+                    .to_param_sse => |param_spec| try temp.toReg(abi.getCAbiSseParamRegs(param_spec.tag(cg), cg.target)[param_spec.index(cg)], cg),
+                    .to_ret_gpr => |ret_spec| try temp.toReg(abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index(cg)], cg),
+                    .to_ret_gpr_pair => |ret_spec| try temp.toRegPair(abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index(cg)..][0..2].*, cg),
                     .gpr, .immut_gpr, .to_gpr => try temp.toRegClass(false, .general_purpose, cg),
                     .mut_gpr, .to_mut_gpr => try temp.toRegClass(true, .general_purpose, cg),
                     .to_gphi => try temp.toRegClass(false, .gphi, cg),
@@ -188381,8 +192690,10 @@ const Select = struct {
             reg_pair: [2]Register,
             param_gpr: CallConvRegSpec,
             param_gpr_pair: CallConvRegSpec,
+            param_sse: CallConvRegSpec,
             ret_gpr: CallConvRegSpec,
             ret_gpr_pair: CallConvRegSpec,
+            ret_sse: CallConvRegSpec,
             rc: Register.Class,
             rc_pair: Register.Class,
             mut_rc: struct { ref: Select.Operand.Ref, rc: Register.Class },
@@ -188422,6 +192733,7 @@ const Select = struct {
 
             const CallConvRegSpec = struct {
                 cc: Case.CallConv,
+                after: u2,
                 at: u2,
 
                 fn tag(spec: CallConvRegSpec, cg: *const CodeGen) std.builtin.CallingConvention.Tag {
@@ -188431,6 +192743,14 @@ const Select = struct {
                         .zigcc => .auto,
                     };
                 }
+
+                fn index(spec: CallConvRegSpec, cg: *const CodeGen) u2 {
+                    return switch (spec.tag(cg)) {
+                        .auto, .x86_64_sysv => spec.after,
+                        .x86_64_win => spec.at,
+                        else => unreachable,
+                    };
+                }
             };
 
             fn lock(kind: Kind, cg: *CodeGen) ![2]?RegisterLock {
@@ -188439,10 +192759,12 @@ const Select = struct {
                     else => return reg_locks,
                     .reg => |reg| .{ reg, .none },
                     .reg_pair => |regs| regs,
-                    .param_gpr => |param_spec| abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.at..][0..1].* ++ .{.none},
-                    .param_gpr_pair => |param_spec| abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.at..][0..2].*,
-                    .ret_gpr => |ret_spec| abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.at..][0..1].* ++ .{.none},
-                    .ret_gpr_pair => |ret_spec| abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.at..][0..2].*,
+                    .param_gpr => |param_spec| abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.index(cg)..][0..1].* ++ .{.none},
+                    .param_gpr_pair => |param_spec| abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.index(cg)..][0..2].*,
+                    .param_sse => |param_spec| abi.getCAbiSseParamRegs(param_spec.tag(cg), cg.target)[param_spec.index(cg)..][0..1].* ++ .{.none},
+                    .ret_gpr => |ret_spec| abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index(cg)..][0..1].* ++ .{.none},
+                    .ret_gpr_pair => |ret_spec| abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index(cg)..][0..2].*,
+                    .ret_sse => |ret_spec| abi.getCAbiSseReturnRegs(ret_spec.tag(cg))[ret_spec.index(cg)..][0..1].* ++ .{.none},
                 };
                 for (regs, &reg_locks) |reg, *reg_lock| {
                     if (reg == .none) continue;
@@ -188476,16 +192798,22 @@ const Select = struct {
                 .reg => |reg| .{ try cg.tempInit(spec.type, .{ .register = reg }), true },
                 .reg_pair => |regs| .{ try cg.tempInit(spec.type, .{ .register_pair = regs }), true },
                 .param_gpr => |param_spec| .{ try cg.tempInit(spec.type, .{
-                    .register = abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.at],
+                    .register = abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.index(cg)],
                 }), true },
                 .param_gpr_pair => |param_spec| .{ try cg.tempInit(spec.type, .{
-                    .register_pair = abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.at..][0..2].*,
+                    .register_pair = abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.index(cg)..][0..2].*,
+                }), true },
+                .param_sse => |param_spec| .{ try cg.tempInit(spec.type, .{
+                    .register = abi.getCAbiSseParamRegs(param_spec.tag(cg), cg.target)[param_spec.index(cg)],
                 }), true },
                 .ret_gpr => |ret_spec| .{ try cg.tempInit(spec.type, .{
-                    .register = abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.at],
+                    .register = abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index(cg)],
                 }), true },
                 .ret_gpr_pair => |ret_spec| .{ try cg.tempInit(spec.type, .{
-                    .register_pair = abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.at..][0..2].*,
+                    .register_pair = abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index(cg)..][0..2].*,
+                }), true },
+                .ret_sse => |ret_spec| .{ try cg.tempInit(spec.type, .{
+                    .register = abi.getCAbiSseReturnRegs(ret_spec.tag(cg))[ret_spec.index(cg)],
                 }), true },
                 .rc => |rc| .{ try cg.tempAllocReg(spec.type, regSetForRegClass(rc)), true },
                 .rc_pair => |rc| .{ try cg.tempAllocRegPair(spec.type, regSetForRegClass(rc)), true },
@@ -188842,7 +193170,17 @@ const Select = struct {
                         .storage = .{ .elems = elems },
                     } }))), true };
                 },
-                .frame => |frame_index| .{ try cg.tempInit(spec.type, .{ .load_frame = .{ .index = frame_index } }), true },
+                .frame => |frame_index| .{ try cg.tempInit(spec.type, .{ .load_frame = .{
+                    .index = frame_index,
+                    .off = switch (frame_index) {
+                        .call_frame => switch (cg.target.cCallingConvention().?) {
+                            .x86_64_sysv => 0,
+                            .x86_64_win => win64_shadow_space,
+                            else => unreachable,
+                        },
+                        else => 0,
+                    },
+                } }), true },
                 .lazy_sym => |lazy_symbol_spec| {
                     const ip = &pt.zcu.intern_pool;
                     const ty = if (lazy_symbol_spec.ref == .none) spec.type else lazy_symbol_spec.ref.typeOf(s);
@@ -188997,6 +193335,7 @@ const Select = struct {
             const add_src0_elem_size_mul_src1: Adjust = .{ .sign = .pos, .lhs = .src0_elem_size_mul_src1, .op = .mul, .rhs = .@"1" };
             const sub_src0_elem_size_mul_src1: Adjust = .{ .sign = .neg, .lhs = .src0_elem_size_mul_src1, .op = .mul, .rhs = .@"1" };
             const add_dst0_elem_size: Adjust = .{ .sign = .pos, .lhs = .dst0_elem_size, .op = .mul, .rhs = .@"1" };
+            const sub_dst0_elem_size: Adjust = .{ .sign = .neg, .lhs = .dst0_elem_size, .op = .mul, .rhs = .@"1" };
             const add_src1_div_8_down_4: Adjust = .{ .sign = .pos, .lhs = .src1, .op = .div_8_down, .rhs = .@"4" };
             const add_src1_rem_32: Adjust = .{ .sign = .pos, .lhs = .src1, .op = .rem_8_mul, .rhs = .@"4" };
             const add_src1_rem_64: Adjust = .{ .sign = .pos, .lhs = .src1, .op = .rem_8_mul, .rhs = .@"8" };
@@ -189287,7 +193626,11 @@ const Select = struct {
         const tmp0t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0t } };
         const tmp0x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0x } };
         const tmp0y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0y } };
+        const tmp0w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0w }, .imm = 1 };
+        const tmp0d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0d }, .imm = 1 };
         const tmp0q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0q }, .imm = 1 };
+        const tmp0w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0w }, .imm = 2 };
+        const tmp0d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0d }, .imm = 2 };
         const tmp0q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0q }, .imm = 2 };
 
         const tmp1l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1l } };
@@ -189301,7 +193644,11 @@ const Select = struct {
         const tmp1t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1t } };
         const tmp1x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1x } };
         const tmp1y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1y } };
+        const tmp1w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1w }, .imm = 1 };
+        const tmp1d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1d }, .imm = 1 };
         const tmp1q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1q }, .imm = 1 };
+        const tmp1w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1w }, .imm = 2 };
+        const tmp1d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1d }, .imm = 2 };
         const tmp1q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1q }, .imm = 2 };
 
         const tmp2l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2l } };
@@ -189315,7 +193662,11 @@ const Select = struct {
         const tmp2t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2t } };
         const tmp2x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2x } };
         const tmp2y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2y } };
+        const tmp2w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2w }, .imm = 1 };
+        const tmp2d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2d }, .imm = 1 };
         const tmp2q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2q }, .imm = 1 };
+        const tmp2w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2w }, .imm = 2 };
+        const tmp2d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2d }, .imm = 2 };
         const tmp2q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2q }, .imm = 2 };
 
         const tmp3l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3l } };
@@ -189329,7 +193680,11 @@ const Select = struct {
         const tmp3t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3t } };
         const tmp3x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3x } };
         const tmp3y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3y } };
+        const tmp3w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3w }, .imm = 1 };
+        const tmp3d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3d }, .imm = 1 };
         const tmp3q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3q }, .imm = 1 };
+        const tmp3w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3w }, .imm = 2 };
+        const tmp3d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3d }, .imm = 2 };
         const tmp3q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3q }, .imm = 2 };
 
         const tmp4l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4l } };
@@ -189343,7 +193698,11 @@ const Select = struct {
         const tmp4t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4t } };
         const tmp4x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4x } };
         const tmp4y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4y } };
+        const tmp4w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4w }, .imm = 1 };
+        const tmp4d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4d }, .imm = 1 };
         const tmp4q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4q }, .imm = 1 };
+        const tmp4w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4w }, .imm = 2 };
+        const tmp4d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4d }, .imm = 2 };
         const tmp4q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4q }, .imm = 2 };
 
         const tmp5l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5l } };
@@ -189357,7 +193716,11 @@ const Select = struct {
         const tmp5t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5t } };
         const tmp5x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5x } };
         const tmp5y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5y } };
+        const tmp5w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5w }, .imm = 1 };
+        const tmp5d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5d }, .imm = 1 };
         const tmp5q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5q }, .imm = 1 };
+        const tmp5w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5w }, .imm = 2 };
+        const tmp5d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5d }, .imm = 2 };
         const tmp5q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5q }, .imm = 2 };
 
         const tmp6l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6l } };
@@ -189371,7 +193734,11 @@ const Select = struct {
         const tmp6t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6t } };
         const tmp6x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6x } };
         const tmp6y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6y } };
+        const tmp6w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6w }, .imm = 1 };
+        const tmp6d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6d }, .imm = 1 };
         const tmp6q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6q }, .imm = 1 };
+        const tmp6w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6w }, .imm = 2 };
+        const tmp6d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6d }, .imm = 2 };
         const tmp6q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6q }, .imm = 2 };
 
         const tmp7l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7l } };
@@ -189385,7 +193752,11 @@ const Select = struct {
         const tmp7t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7t } };
         const tmp7x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7x } };
         const tmp7y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7y } };
+        const tmp7w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7w }, .imm = 1 };
+        const tmp7d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7d }, .imm = 1 };
         const tmp7q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7q }, .imm = 1 };
+        const tmp7w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7w }, .imm = 2 };
+        const tmp7d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7d }, .imm = 2 };
         const tmp7q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7q }, .imm = 2 };
 
         const tmp8l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8l } };
@@ -189399,7 +193770,11 @@ const Select = struct {
         const tmp8t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8t } };
         const tmp8x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8x } };
         const tmp8y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8y } };
+        const tmp8w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8w }, .imm = 1 };
+        const tmp8d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8d }, .imm = 1 };
         const tmp8q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8q }, .imm = 1 };
+        const tmp8w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8w }, .imm = 2 };
+        const tmp8d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8d }, .imm = 2 };
         const tmp8q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8q }, .imm = 2 };
 
         const tmp9l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9l } };
@@ -189413,7 +193788,11 @@ const Select = struct {
         const tmp9t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9t } };
         const tmp9x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9x } };
         const tmp9y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9y } };
+        const tmp9w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9w }, .imm = 1 };
+        const tmp9d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9d }, .imm = 1 };
         const tmp9q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9q }, .imm = 1 };
+        const tmp9w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9w }, .imm = 2 };
+        const tmp9d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9d }, .imm = 2 };
         const tmp9q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9q }, .imm = 2 };
 
         const tmp10l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10l } };
@@ -189427,7 +193806,11 @@ const Select = struct {
         const tmp10t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10t } };
         const tmp10x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10x } };
         const tmp10y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10y } };
+        const tmp10w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10w }, .imm = 1 };
+        const tmp10d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10d }, .imm = 1 };
         const tmp10q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10q }, .imm = 1 };
+        const tmp10w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10w }, .imm = 2 };
+        const tmp10d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10d }, .imm = 2 };
         const tmp10q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10q }, .imm = 2 };
 
         const dst0l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0l } };
@@ -189441,7 +193824,11 @@ const Select = struct {
         const dst0t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0t } };
         const dst0x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0x } };
         const dst0y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0y } };
+        const dst0w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0w }, .imm = 1 };
+        const dst0d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0d }, .imm = 1 };
         const dst0q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0q }, .imm = 1 };
+        const dst0w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0w }, .imm = 2 };
+        const dst0d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0d }, .imm = 2 };
         const dst0q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0q }, .imm = 2 };
 
         const dst1l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1l } };
@@ -189455,7 +193842,11 @@ const Select = struct {
         const dst1t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1t } };
         const dst1x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1x } };
         const dst1y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1y } };
+        const dst1w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1w }, .imm = 1 };
+        const dst1d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1d }, .imm = 1 };
         const dst1q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1q }, .imm = 1 };
+        const dst1w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1w }, .imm = 2 };
+        const dst1d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1d }, .imm = 2 };
         const dst1q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1q }, .imm = 2 };
 
         const src0l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0l } };
@@ -189469,7 +193860,11 @@ const Select = struct {
         const src0t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0t } };
         const src0x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0x } };
         const src0y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0y } };
+        const src0w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0w }, .imm = 1 };
+        const src0d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0d }, .imm = 1 };
         const src0q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0q }, .imm = 1 };
+        const src0w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0w }, .imm = 2 };
+        const src0d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0d }, .imm = 2 };
         const src0q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0q }, .imm = 2 };
 
         const src1l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1l } };
@@ -189483,7 +193878,11 @@ const Select = struct {
         const src1t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1t } };
         const src1x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1x } };
         const src1y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1y } };
+        const src1w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1w }, .imm = 1 };
+        const src1d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1d }, .imm = 1 };
         const src1q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1q }, .imm = 1 };
+        const src1w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1w }, .imm = 2 };
+        const src1d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1d }, .imm = 2 };
         const src1q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1q }, .imm = 2 };
 
         const src2l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2l } };
@@ -189497,7 +193896,11 @@ const Select = struct {
         const src2t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2t } };
         const src2x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2x } };
         const src2y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2y } };
+        const src2w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2w }, .imm = 1 };
+        const src2d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2d }, .imm = 1 };
         const src2q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2q }, .imm = 1 };
+        const src2w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2w }, .imm = 2 };
+        const src2d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2d }, .imm = 2 };
         const src2q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2q }, .imm = 2 };
 
         fn si(imm: i32) Select.Operand {
@@ -189956,6 +194359,22 @@ fn select(
 ) Select.Error!void {
     @setEvalBranchQuota(33_500);
     cases: for (cases) |case| {
+        switch (case.required_abi) {
+            .any => {},
+            .gnu => if (switch (cg.target.abi) {
+                .none, .msvc, .itanium => cg.target.os.tag == .windows,
+                else => false,
+            }) continue :cases,
+            .msvc => if (switch (cg.target.abi) {
+                .none, .msvc, .itanium => cg.target.os.tag != .windows,
+                else => true,
+            }) continue :cases,
+        }
+        switch (case.required_cc_abi) {
+            .any => {},
+            .sysv64 => if (cg.target.cCallingConvention().? != .x86_64_sysv) continue :cases,
+            .win64 => if (cg.target.cCallingConvention().? != .x86_64_win) continue :cases,
+        }
         for (case.required_features) |required_feature| if (required_feature) |feature| if (!cg.hasFeature(feature)) continue :cases;
         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;
         for (case.dst_constraints[0..dst_temps.len], dst_tys) |dst_constraint, dst_ty| if (!dst_constraint.accepts(dst_ty, cg)) continue :cases;
@@ -189972,7 +194391,11 @@ fn select(
                 const frame_allocs_slice = cg.frame_allocs.slice();
                 const stack_frame_size =
                     &frame_allocs_slice.items(.abi_size)[@intFromEnum(FrameIndex.call_frame)];
-                stack_frame_size.* = @max(stack_frame_size.*, case.call_frame.size);
+                stack_frame_size.* = @max(stack_frame_size.*, switch (cg.target.cCallingConvention().?) {
+                    .x86_64_sysv => case.call_frame.size,
+                    .x86_64_win => win64_shadow_space + case.call_frame.size,
+                    else => unreachable,
+                });
                 const stack_frame_align =
                     &frame_allocs_slice.items(.abi_align)[@intFromEnum(FrameIndex.call_frame)];
                 stack_frame_align.* = stack_frame_align.max(case.call_frame.alignment);
diff --git a/src/arch/x86_64/Emit.zig b/src/arch/x86_64/Emit.zig
index e6b4ac26bb..7ba8d460de 100644
--- a/src/arch/x86_64/Emit.zig
+++ b/src/arch/x86_64/Emit.zig
@@ -105,9 +105,9 @@ pub fn emitMir(emit: *Emit) Error!void {
                             emit.pt,
                             emit.lower.src_loc,
                             nav,
-                            emit.lower.target.*,
+                            emit.lower.target,
                         )) {
-                            .mcv => |mcv| mcv.lea_symbol,
+                            .sym_index => |sym_index| sym_index,
                             .fail => |em| {
                                 assert(emit.lower.err_msg == null);
                                 emit.lower.err_msg = em;
@@ -151,7 +151,7 @@ pub fn emitMir(emit: *Emit) Error!void {
                             Type.fromInterned(uav.orig_ty).ptrAlignment(emit.pt.zcu),
                             emit.lower.src_loc,
                         )) {
-                            .mcv => |mcv| mcv.load_symbol,
+                            .sym_index => |sym_index| sym_index,
                             .fail => |em| {
                                 assert(emit.lower.err_msg == null);
                                 emit.lower.err_msg = em;
@@ -186,7 +186,7 @@ pub fn emitMir(emit: *Emit) Error!void {
                         else if (emit.bin_file.cast(.macho)) |macho_file|
                             try macho_file.getGlobalSymbol(extern_func.toSlice(&emit.lower.mir).?, null)
                         else if (emit.bin_file.cast(.coff)) |coff_file|
-                            link.File.Coff.global_symbol_bit | try coff_file.getGlobalSymbol(extern_func.toSlice(&emit.lower.mir).?, null)
+                            try coff_file.getGlobalSymbol(extern_func.toSlice(&emit.lower.mir).?, "compiler_rt")
                         else
                             return emit.fail("external symbols unimplemented for {s}", .{@tagName(emit.bin_file.tag)}),
                         .is_extern = true,
@@ -542,16 +542,13 @@ pub fn emitMir(emit: *Emit) Error!void {
                                                     emit.pt,
                                                     emit.lower.src_loc,
                                                     nav,
-                                                    emit.lower.target.*,
+                                                    emit.lower.target,
                                                 ) catch |err| switch (err) {
                                                     error.CodegenFail,
                                                     => return emit.fail("unable to codegen: {s}", .{@errorName(err)}),
                                                     else => |e| return e,
                                                 }) {
-                                                    .mcv => |mcv| switch (mcv) {
-                                                        else => unreachable,
-                                                        .load_direct, .load_symbol => |sym_index| sym_index,
-                                                    },
+                                                    .sym_index => |sym_index| sym_index,
                                                     .fail => |em| {
                                                         assert(emit.lower.err_msg == null);
                                                         emit.lower.err_msg = em;
@@ -564,10 +561,7 @@ pub fn emitMir(emit: *Emit) Error!void {
                                                     Type.fromInterned(uav.orig_ty).ptrAlignment(emit.pt.zcu),
                                                     emit.lower.src_loc,
                                                 )) {
-                                                    .mcv => |mcv| switch (mcv) {
-                                                        else => unreachable,
-                                                        .load_direct, .load_symbol => |sym_index| sym_index,
-                                                    },
+                                                    .sym_index => |sym_index| sym_index,
                                                     .fail => |em| {
                                                         assert(emit.lower.err_msg == null);
                                                         emit.lower.err_msg = em;
diff --git a/src/arch/x86_64/Encoding.zig b/src/arch/x86_64/Encoding.zig
index 8c019d1882..1b7d5ed3d4 100644
--- a/src/arch/x86_64/Encoding.zig
+++ b/src/arch/x86_64/Encoding.zig
@@ -598,7 +598,7 @@ pub const Op = enum {
                     .rax => .rax,
                     .cl => .cl,
                     .dx => .dx,
-                    else => switch (reg.bitSize()) {
+                    else => switch (reg.size().bitSize(target)) {
                         8 => .r8,
                         16 => .r16,
                         32 => .r32,
@@ -615,7 +615,7 @@ pub const Op = enum {
                 .mmx => .mm,
                 .sse => switch (reg) {
                     .xmm0 => .xmm0,
-                    else => switch (reg.bitSize()) {
+                    else => switch (reg.size().bitSize(target)) {
                         128 => .xmm,
                         256 => .ymm,
                         else => unreachable,
diff --git a/src/arch/x86_64/Mir.zig b/src/arch/x86_64/Mir.zig
index 70f8090685..bc99d871ac 100644
--- a/src/arch/x86_64/Mir.zig
+++ b/src/arch/x86_64/Mir.zig
@@ -12,6 +12,8 @@ extra: []const u32,
 string_bytes: []const u8,
 locals: []const Local,
 table: []const Inst.Index,
+/// Optional data which, when present, can be used to accelerate encoding speed.
+memoized_encodings: []const u0 = &.{},
 frame_locs: std.MultiArrayList(FrameLoc).Slice,
 
 pub const Inst = struct {
@@ -1963,6 +1965,7 @@ pub fn deinit(mir: *Mir, gpa: std.mem.Allocator) void {
     gpa.free(mir.string_bytes);
     gpa.free(mir.locals);
     gpa.free(mir.table);
+    gpa.free(mir.memoized_encodings);
     mir.frame_locs.deinit(gpa);
     mir.* = undefined;
 }
diff --git a/src/arch/x86_64/abi.zig b/src/arch/x86_64/abi.zig
index 8e700eebc6..041eb1632d 100644
--- a/src/arch/x86_64/abi.zig
+++ b/src/arch/x86_64/abi.zig
@@ -1,20 +1,86 @@
 pub const Class = enum {
+    /// INTEGER: This class consists of integral types that fit into one of the general
+    ///     purpose registers.
     integer,
+    /// SSE: The class consists of types that fit into a vector register.
     sse,
+    /// SSEUP: The class consists of types that fit into a vector register and can be passed
+    ///     and returned in the upper bytes of it.
     sseup,
+    /// X87, X87UP: These classes consist of types that will be returned via the
+    ///     x87 FPU.
     x87,
+    /// The 15-bit exponent, 1-bit sign, and 6 bytes of padding of an `f80`.
     x87up,
-    complex_x87,
-    memory,
+    /// NO_CLASS: This class is used as initializer in the algorithms. It will be used for
+    ///     padding and empty structures and unions.
     none,
+    /// MEMORY: This class consists of types that will be passed and returned in mem-
+    ///     ory via the stack.
+    memory,
+    /// Win64 passes 128-bit integers as `Class.memory` but returns them as `Class.sse`.
     win_i128,
+    /// A `Class.sse` containing one `f32`.
     float,
+    /// A `Class.sse` containing two `f32`s.
     float_combine,
+    /// Clang passes each vector element in a separate `Class.integer`, but returns as `Class.memory`.
     integer_per_element,
 
-    fn isX87(class: Class) bool {
+    pub const one_integer: [8]Class = .{
+        .integer, .none, .none, .none,
+        .none,    .none, .none, .none,
+    };
+    pub const two_integers: [8]Class = .{
+        .integer, .integer, .none, .none,
+        .none,    .none,    .none, .none,
+    };
+    pub const three_integers: [8]Class = .{
+        .integer, .integer, .integer, .none,
+        .none,    .none,    .none,    .none,
+    };
+    pub const four_integers: [8]Class = .{
+        .integer, .integer, .integer, .integer,
+        .none,    .none,    .none,    .none,
+    };
+    pub const len_integers: [8]Class = .{
+        .integer_per_element, .none, .none, .none,
+        .none,                .none, .none, .none,
+    };
+
+    pub const @"f16" = @"f64";
+    pub const @"f32": [8]Class = .{
+        .float, .none, .none, .none,
+        .none,  .none, .none, .none,
+    };
+    pub const @"f64": [8]Class = .{
+        .sse,  .none, .none, .none,
+        .none, .none, .none, .none,
+    };
+    pub const @"f80": [8]Class = .{
+        .x87,  .x87up, .none, .none,
+        .none, .none,  .none, .none,
+    };
+    pub const @"f128": [8]Class = .{
+        .sse,  .sseup, .none, .none,
+        .none, .none,  .none, .none,
+    };
+
+    /// COMPLEX_X87: This class consists of types that will be returned via the x87
+    ///     FPU.
+    pub const complex_x87: [8]Class = .{
+        .x87,  .x87up, .x87,  .x87up,
+        .none, .none,  .none, .none,
+    };
+
+    pub const stack: [8]Class = .{
+        .memory, .none, .none, .none,
+        .none,   .none, .none, .none,
+    };
+
+    pub fn isX87(class: Class) bool {
         return switch (class) {
-            .x87, .x87up, .complex_x87 => true,
+            .x87, .x87up => true,
             else => false,
         };
     }
@@ -44,7 +110,7 @@ pub const Class = enum {
     }
 };
 
-pub fn classifyWindows(ty: Type, zcu: *Zcu) Class {
+pub fn classifyWindows(ty: Type, zcu: *Zcu, target: *const std.Target) Class {
     // https://docs.microsoft.com/en-gb/cpp/build/x64-calling-convention?view=vs-2017
     // "There's a strict one-to-one correspondence between a function call's arguments
     // and the registers used for those arguments. Any argument that doesn't fit in 8
@@ -53,7 +119,7 @@ pub fn classifyWindows(ty: Type, zcu: *Zcu) Class {
     // "All floating point operations are done using the 16 XMM registers."
     // "Structs and unions of size 8, 16, 32, or 64 bits, and __m64 types, are passed
     // as if they were integers of the same size."
-    switch (ty.zigTypeTag(zcu)) {
+    return switch (ty.zigTypeTag(zcu)) {
         .pointer,
         .int,
         .bool,
@@ -70,19 +136,23 @@ pub fn classifyWindows(ty: Type, zcu: *Zcu) Class {
         .frame,
         => switch (ty.abiSize(zcu)) {
             0 => unreachable,
-            1, 2, 4, 8 => return .integer,
+            1, 2, 4, 8 => .integer,
             else => switch (ty.zigTypeTag(zcu)) {
-                .int => return .win_i128,
-                .@"struct", .@"union" => if (ty.containerLayout(zcu) == .@"packed") {
-                    return .win_i128;
-                } else {
-                    return .memory;
-                },
-                else => return .memory,
+                .int => .win_i128,
+                .@"struct", .@"union" => if (ty.containerLayout(zcu) == .@"packed")
+                    .win_i128
+                else
+                    .memory,
+                else => .memory,
             },
         },
 
-        .float, .vector => return .sse,
+        .float => switch (ty.floatBits(target)) {
+            16, 32, 64, 128 => .sse,
+            80 => .memory,
+            else => unreachable,
+        },
+        .vector => .sse,
 
         .type,
         .comptime_float,
@@ -93,171 +163,109 @@ pub fn classifyWindows(ty: Type, zcu: *Zcu) Class {
         .@"opaque",
         .enum_literal,
         => unreachable,
-    }
+    };
 }
 
-pub const Context = enum { ret, arg, field, other };
+pub const Context = enum { ret, arg, other };
 
 /// There are a maximum of 8 possible return slots. Returned values are in
 /// the beginning of the array; unused slots are filled with .none.
 pub fn classifySystemV(ty: Type, zcu: *Zcu, target: *const std.Target, ctx: Context) [8]Class {
-    const memory_class = [_]Class{
-        .memory, .none, .none, .none,
-        .none,   .none, .none, .none,
-    };
-    var result = [1]Class{.none} ** 8;
     switch (ty.zigTypeTag(zcu)) {
         .pointer => switch (ty.ptrSize(zcu)) {
-            .slice => {
-                result[0] = .integer;
-                result[1] = .integer;
-                return result;
-            },
-            else => {
-                result[0] = .integer;
-                return result;
-            },
+            .slice => return Class.two_integers,
+            else => return Class.one_integer,
         },
         .int, .@"enum", .error_set => {
             const bits = ty.intInfo(zcu).bits;
-            if (bits <= 64) {
-                result[0] = .integer;
-                return result;
-            }
-            if (bits <= 128) {
-                result[0] = .integer;
-                result[1] = .integer;
-                return result;
-            }
-            if (bits <= 192) {
-                result[0] = .integer;
-                result[1] = .integer;
-                result[2] = .integer;
-                return result;
-            }
-            if (bits <= 256) {
-                result[0] = .integer;
-                result[1] = .integer;
-                result[2] = .integer;
-                result[3] = .integer;
-                return result;
-            }
-            return memory_class;
+            if (bits <= 64 * 1) return Class.one_integer;
+            if (bits <= 64 * 2) return Class.two_integers;
+            if (bits <= 64 * 3) return Class.three_integers;
+            if (bits <= 64 * 4) return Class.four_integers;
+            return Class.stack;
         },
-        .bool, .void, .noreturn => {
-            result[0] = .integer;
-            return result;
-        },
-        .float => switch (ty.floatBits(target.*)) {
+        .bool, .void, .noreturn => return Class.one_integer,
+        .float => switch (ty.floatBits(target)) {
             16 => {
-                if (ctx == .field) {
-                    result[0] = .memory;
-                } else {
-                    // TODO clang doesn't allow __fp16 as .ret or .arg
-                    result[0] = .sse;
-                }
-                return result;
-            },
-            32 => {
-                result[0] = .float;
-                return result;
-            },
-            64 => {
-                result[0] = .sse;
-                return result;
-            },
-            128 => {
-                // "Arguments of types __float128, _Decimal128 and __m128 are
-                // split into two halves.  The least significant ones belong
-                // to class SSE, the most significant one to class SSEUP."
-                result[0] = .sse;
-                result[1] = .sseup;
-                return result;
-            },
-            80 => {
-                // "The 64-bit mantissa of arguments of type long double
-                // belongs to classX87, the 16-bit exponent plus 6 bytes
-                // of padding belongs to class X87UP."
-                result[0] = .x87;
-                result[1] = .x87up;
-                return result;
+                if (ctx == .other) return Class.stack;
+                // TODO clang doesn't allow __fp16 as .ret or .arg
+                return Class.f16;
             },
+            32 => return Class.f32,
+            64 => return Class.f64,
+            // "Arguments of types __float128, _Decimal128 and __m128 are
+            // split into two halves.  The least significant ones belong
+            // to class SSE, the most significant one to class SSEUP."
+            128 => return Class.f128,
+            // "The 64-bit mantissa of arguments of type long double
+            // belongs to class X87, the 16-bit exponent plus 6 bytes
+            // of padding belongs to class X87UP."
+            80 => return Class.f80,
             else => unreachable,
         },
         .vector => {
             const elem_ty = ty.childType(zcu);
             const bits = elem_ty.bitSize(zcu) * ty.arrayLen(zcu);
             if (elem_ty.toIntern() == .bool_type) {
-                if (bits <= 32) return .{
-                    .integer, .none, .none, .none,
-                    .none,    .none, .none, .none,
-                };
-                if (bits <= 64) return .{
-                    .sse,  .none, .none, .none,
-                    .none, .none, .none, .none,
-                };
-                if (ctx == .arg) {
-                    if (bits <= 128) return .{
-                        .integer_per_element, .none, .none, .none,
-                        .none,                .none, .none, .none,
-                    };
-                    if (bits <= 256 and target.cpu.has(.x86, .avx)) return .{
-                        .integer_per_element, .none, .none, .none,
-                        .none,                .none, .none, .none,
-                    };
-                    if (bits <= 512 and target.cpu.has(.x86, .avx512f)) return .{
-                        .integer_per_element, .none, .none, .none,
-                        .none,                .none, .none, .none,
-                    };
-                }
-                return memory_class;
+                if (bits <= 32) return Class.one_integer;
+                if (bits <= 64) return Class.f64;
+                if (ctx == .other) return Class.stack;
+                if (bits <= 128) return Class.len_integers;
+                if (bits <= 256 and target.cpu.has(.x86, .avx)) return Class.len_integers;
+                if (bits <= 512 and target.cpu.has(.x86, .avx512f)) return Class.len_integers;
+                return Class.stack;
+            }
+            if (elem_ty.isRuntimeFloat() and elem_ty.floatBits(target) == 80) {
+                if (bits <= 80 * 1) return Class.f80;
+                if (bits <= 80 * 2) return Class.complex_x87;
+                return Class.stack;
             }
-            if (bits <= 64) return .{
+            if (bits <= 64 * 1) return .{
                 .sse,  .none, .none, .none,
                 .none, .none, .none, .none,
             };
-            if (bits <= 128) return .{
+            if (bits <= 64 * 2) return .{
                 .sse,  .sseup, .none, .none,
                 .none, .none,  .none, .none,
             };
-            if (ctx == .arg and !target.cpu.has(.x86, .avx)) return memory_class;
-            if (bits <= 192) return .{
+            if (ctx == .arg and !target.cpu.has(.x86, .avx)) return Class.stack;
+            if (bits <= 64 * 3) return .{
                 .sse,  .sseup, .sseup, .none,
                 .none, .none,  .none,  .none,
             };
-            if (bits <= 256) return .{
+            if (bits <= 64 * 4) return .{
                 .sse,  .sseup, .sseup, .sseup,
                 .none, .none,  .none,  .none,
             };
-            if (ctx == .arg and !target.cpu.has(.x86, .avx512f)) return memory_class;
-            if (bits <= 320) return .{
+            if (ctx == .arg and !target.cpu.has(.x86, .avx512f)) return Class.stack;
+            if (bits <= 64 * 5) return .{
                 .sse,   .sseup, .sseup, .sseup,
                 .sseup, .none,  .none,  .none,
             };
-            if (bits <= 384) return .{
+            if (bits <= 64 * 6) return .{
                 .sse,   .sseup, .sseup, .sseup,
                 .sseup, .sseup, .none,  .none,
             };
-            if (bits <= 448) return .{
+            if (bits <= 64 * 7) return .{
                 .sse,   .sseup, .sseup, .sseup,
                 .sseup, .sseup, .sseup, .none,
             };
-            if (bits <= 512 or (ctx == .ret and bits <= @as(u64, if (target.cpu.has(.x86, .avx512f))
-                2048
+            if (bits <= 64 * 8 or (ctx == .ret and bits <= @as(u64, if (target.cpu.has(.x86, .avx512f))
+                64 * 32
             else if (target.cpu.has(.x86, .avx))
-                1024
+                64 * 16
             else
-                512))) return .{
+                64 * 8))) return .{
                 .sse,   .sseup, .sseup, .sseup,
                 .sseup, .sseup, .sseup, .sseup,
             };
-            return memory_class;
+            return Class.stack;
         },
         .optional => {
             if (ty.optionalReprIsPayload(zcu)) {
                 return classifySystemV(ty.optionalChild(zcu), zcu, target, ctx);
             }
-            return memory_class;
+            return Class.stack;
         },
         .@"struct", .@"union" => {
             // "If the size of an object is larger than eight eightbytes, or
@@ -269,15 +277,14 @@ pub fn classifySystemV(ty: Type, zcu: *Zcu, target: *const std.Target, ctx: Cont
                 .auto => unreachable,
                 .@"extern" => {},
                 .@"packed" => {
-                    assert(ty_size <= 16);
-                    result[0] = .integer;
-                    if (ty_size > 8) result[1] = .integer;
-                    return result;
+                    if (ty_size <= 8) return Class.one_integer;
+                    if (ty_size <= 16) return Class.two_integers;
+                    unreachable; // frontend should not have allowed this type as extern
                 },
             }
-            if (ty_size > 64)
-                return memory_class;
+            if (ty_size > 64) return Class.stack;
 
+            var result: [8]Class = @splat(.none);
             _ = if (zcu.typeToStruct(ty)) |loaded_struct|
                 classifySystemVStruct(&result, 0, loaded_struct, zcu, target)
             else if (zcu.typeToUnion(ty)) |loaded_union|
@@ -290,15 +297,15 @@ pub fn classifySystemV(ty: Type, zcu: *Zcu, target: *const std.Target, ctx: Cont
             // "If one of the classes is MEMORY, the whole argument is passed in memory"
             // "If X87UP is not preceded by X87, the whole argument is passed in memory."
             for (result, 0..) |class, i| switch (class) {
-                .memory => return memory_class,
-                .x87up => if (i == 0 or result[i - 1] != .x87) return memory_class,
+                .memory => return Class.stack,
+                .x87up => if (i == 0 or result[i - 1] != .x87) return Class.stack,
                 else => continue,
             };
             // "If the size of the aggregate exceeds two eightbytes and the first eight-
             // byte isn’t SSE or any other eightbyte isn’t SSEUP, the whole argument
             // is passed in memory."
             if (ty_size > 16 and (result[0] != .sse or
-                std.mem.indexOfNone(Class, result[1..], &.{ .sseup, .none }) != null)) return memory_class;
+                std.mem.indexOfNone(Class, result[1..], &.{ .sseup, .none }) != null)) return Class.stack;
 
             // "If SSEUP is not preceded by SSE or SSEUP, it is converted to SSE."
             for (&result, 0..) |*item, i| {
@@ -311,16 +318,9 @@ pub fn classifySystemV(ty: Type, zcu: *Zcu, target: *const std.Target, ctx: Cont
         },
         .array => {
             const ty_size = ty.abiSize(zcu);
-            if (ty_size <= 8) {
-                result[0] = .integer;
-                return result;
-            }
-            if (ty_size <= 16) {
-                result[0] = .integer;
-                result[1] = .integer;
-                return result;
-            }
-            return memory_class;
+            if (ty_size <= 8) return Class.one_integer;
+            if (ty_size <= 16) return Class.two_integers;
+            return Class.stack;
         },
         else => unreachable,
     }
@@ -363,7 +363,7 @@ fn classifySystemVStruct(
                 .@"packed" => {},
             }
         }
-        const field_classes = std.mem.sliceTo(&classifySystemV(field_ty, zcu, target, .field), .none);
+        const field_classes = std.mem.sliceTo(&classifySystemV(field_ty, zcu, target, .other), .none);
         for (result[@intCast(byte_offset / 8)..][0..field_classes.len], field_classes) |*result_class, field_class|
             result_class.* = result_class.combineSystemV(field_class);
         byte_offset += field_ty.abiSize(zcu);
@@ -406,7 +406,7 @@ fn classifySystemVUnion(
                 .@"packed" => {},
             }
         }
-        const field_classes = std.mem.sliceTo(&classifySystemV(field_ty, zcu, target, .field), .none);
+        const field_classes = std.mem.sliceTo(&classifySystemV(field_ty, zcu, target, .other), .none);
         for (result[@intCast(starting_byte_offset / 8)..][0..field_classes.len], field_classes) |*result_class, field_class|
             result_class.* = result_class.combineSystemV(field_class);
     }
diff --git a/src/arch/x86_64/bits.zig b/src/arch/x86_64/bits.zig
index c854af91d2..18e7a364cb 100644
--- a/src/arch/x86_64/bits.zig
+++ b/src/arch/x86_64/bits.zig
@@ -465,25 +465,25 @@ pub const Register = enum(u8) {
         return @intCast(@intFromEnum(reg) - base);
     }
 
-    pub fn bitSize(reg: Register) u10 {
+    pub fn size(reg: Register) Memory.Size {
         return switch (@intFromEnum(reg)) {
             // zig fmt: off
-            @intFromEnum(Register.rax)  ... @intFromEnum(Register.r15)   => 64,
-            @intFromEnum(Register.eax)  ... @intFromEnum(Register.r15d)  => 32,
-            @intFromEnum(Register.ax)   ... @intFromEnum(Register.r15w)  => 16,
-            @intFromEnum(Register.al)   ... @intFromEnum(Register.r15b)  => 8,
-            @intFromEnum(Register.ah)   ... @intFromEnum(Register.bh)    => 8,
+            @intFromEnum(Register.rax)  ... @intFromEnum(Register.r15)   => .qword,
+            @intFromEnum(Register.eax)  ... @intFromEnum(Register.r15d)  => .dword,
+            @intFromEnum(Register.ax)   ... @intFromEnum(Register.r15w)  => .word,
+            @intFromEnum(Register.al)   ... @intFromEnum(Register.r15b)  => .byte,
+            @intFromEnum(Register.ah)   ... @intFromEnum(Register.bh)    => .byte,
 
-            @intFromEnum(Register.zmm0) ... @intFromEnum(Register.zmm15) => 512,
-            @intFromEnum(Register.ymm0) ... @intFromEnum(Register.ymm15) => 256,
-            @intFromEnum(Register.xmm0) ... @intFromEnum(Register.xmm15) => 128,
-            @intFromEnum(Register.mm0)  ... @intFromEnum(Register.mm7)   => 64,
-            @intFromEnum(Register.st0)  ... @intFromEnum(Register.st7)   => 80,
+            @intFromEnum(Register.zmm0) ... @intFromEnum(Register.zmm15) => .zword,
+            @intFromEnum(Register.ymm0) ... @intFromEnum(Register.ymm15) => .yword,
+            @intFromEnum(Register.xmm0) ... @intFromEnum(Register.xmm15) => .xword,
+            @intFromEnum(Register.mm0)  ... @intFromEnum(Register.mm7)   => .qword,
+            @intFromEnum(Register.st0)  ... @intFromEnum(Register.st7)   => .tbyte,
 
-            @intFromEnum(Register.es)   ... @intFromEnum(Register.gs)    => 16,
+            @intFromEnum(Register.es)   ... @intFromEnum(Register.gs)    => .word,
 
-            @intFromEnum(Register.cr0)  ... @intFromEnum(Register.cr15)  => 64,
-            @intFromEnum(Register.dr0)  ... @intFromEnum(Register.dr15)  => 64,
+            @intFromEnum(Register.cr0)  ... @intFromEnum(Register.cr15)  => .gpr,
+            @intFromEnum(Register.dr0)  ... @intFromEnum(Register.dr15)  => .gpr,
 
             else => unreachable,
             // zig fmt: on
@@ -549,8 +549,8 @@ pub const Register = enum(u8) {
         };
     }
 
-    pub fn toSize(reg: Register, size: Memory.Size, target: *const std.Target) Register {
-        return switch (size) {
+    pub fn toSize(reg: Register, new_size: Memory.Size, target: *const std.Target) Register {
+        return switch (new_size) {
             .none => unreachable,
             .ptr => reg.toBitSize(target.ptrBitWidth()),
             .gpr => switch (target.cpu.arch) {