authorgravatar for jacobly@ziglang.orgJacob Young <jacobly@ziglang.org> 2025-02-06 08:08:54-05:00
committergravatar for jacobly@ziglang.orgJacob Young <jacobly@ziglang.org> 2025-02-06 16:14:53-05:00
logc2718c480367a691ce2cf4fb25e815f075166980
tree226c771d6424c6f93f5301e18307432bec7a44a8
parent288d3062d0ff4bb2c93a4557fd973bef6c92aa40

x86_64: rewrite float `@mod`

2 files changed, 2131 insertions(+), 3 deletions(-)

src/arch/x86_64/CodeGen.zig+2092-3
...@@ -2414,7 +2414,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void {...@@ -2414,7 +2414,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
2414}2414}
24152415
2416fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {2416fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
2417 @setEvalBranchQuota(9_200);2417 @setEvalBranchQuota(9_600);
2418 const pt = cg.pt;2418 const pt = cg.pt;
2419 const zcu = pt.zcu;2419 const zcu = pt.zcu;
2420 const ip = &zcu.intern_pool;2420 const ip = &zcu.intern_pool;
...@@ -2458,7 +2458,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {...@@ -2458,7 +2458,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
2458 .shl, .shl_exact => try cg.airShlShrBinOp(inst),2458 .shl, .shl_exact => try cg.airShlShrBinOp(inst),
24592459
2460 .mul_wrap,2460 .mul_wrap,
2461 .mod,
2462 => |air_tag| try cg.airMulDivBinOp(inst, air_tag),2461 => |air_tag| try cg.airMulDivBinOp(inst, air_tag),
24632462
2464 .add_sat => try cg.airAddSat(inst),2463 .add_sat => try cg.airAddSat(inst),
...@@ -2522,7 +2521,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {...@@ -2522,7 +2521,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
2522 .intcast_safe,2521 .intcast_safe,
2523 => return cg.fail("TODO implement safety_checked_instructions", .{}),2522 => return cg.fail("TODO implement safety_checked_instructions", .{}),
25242523
2525 .mod_optimized => try cg.airMulDivBinOp(inst, .mod),
2526 .reduce_optimized => try cg.airReduce(inst),2524 .reduce_optimized => try cg.airReduce(inst),
2527 .int_from_float_optimized => try cg.airIntFromFloat(inst),2525 .int_from_float_optimized => try cg.airIntFromFloat(inst),
25282526
...@@ -8983,6 +8981,2096 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {...@@ -8983,6 +8981,2096 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
8983 };8981 };
8984 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);8982 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
8985 },8983 },
8984 .mod, .mod_optimized => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, .mod) else fallback: {
8985 const bin_op = air_datas[@intFromEnum(inst)].bin_op;
8986 if (cg.floatBits(cg.typeOf(bin_op.lhs).scalarType(zcu)) == null) break :fallback try cg.airMulDivBinOp(inst, .mod);
8987 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
8988 var res: [1]Temp = undefined;
8989 cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{
8990 .required_features = .{ .f16c, .fast_imm16, null, null },
8991 .src_constraints = .{
8992 .{ .scalar_float = .{ .of = .word, .is = .word } },
8993 .{ .scalar_float = .{ .of = .word, .is = .word } },
8994 .any,
8995 },
8996 .patterns = &.{
8997 .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
8998 },
8999 .call_frame = .{ .alignment = .@"16" },
9000 .extra_temps = .{
9001 .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
9002 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodh" } } },
9003 .{ .type = .f16, .kind = .{ .reg = .dx } },
9004 .{ .type = .f16, .kind = .{ .reg = .ax } },
9005 .unused,
9006 .unused,
9007 .unused,
9008 .unused,
9009 .unused,
9010 },
9011 .dst_temps = .{.{ .ref = .src0 }},
9012 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9013 .each = .{ .once = &.{
9014 .{ ._, .v_d, .mov, .tmp0d, .src1x, ._, ._ },
9015 .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
9016 .{ ._, .v_d, .mov, .tmp2d, .dst0x, ._, ._ },
9017 .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
9018 .{ ._, ._, .@"and", .tmp3w, .sa(.src0, .add_smin), ._, ._ },
9019 .{ ._, ._, .xor, .tmp3d, .tmp2d, ._, ._ },
9020 .{ ._, ._, .cmp, .tmp3w, .sa(.src0, .add_smin), ._, ._ },
9021 .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
9022 .{ ._, .v_d, .mov, .src1x, .tmp0d, ._, ._ },
9023 .{ ._, .v_ps, .cvtph2, .src0x, .src0q, ._, ._ },
9024 .{ ._, .v_ps, .cvtph2, .src1x, .src1q, ._, ._ },
9025 .{ ._, .v_ss, .add, .dst0x, .src0x, .src1d, ._ },
9026 .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
9027 } },
9028 }, .{
9029 .required_features = .{ .f16c, null, null, null },
9030 .src_constraints = .{
9031 .{ .scalar_float = .{ .of = .word, .is = .word } },
9032 .{ .scalar_float = .{ .of = .word, .is = .word } },
9033 .any,
9034 },
9035 .patterns = &.{
9036 .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
9037 },
9038 .call_frame = .{ .alignment = .@"16" },
9039 .extra_temps = .{
9040 .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
9041 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodh" } } },
9042 .{ .type = .f16, .kind = .{ .reg = .dx } },
9043 .{ .type = .f16, .kind = .{ .reg = .ax } },
9044 .unused,
9045 .unused,
9046 .unused,
9047 .unused,
9048 .unused,
9049 },
9050 .dst_temps = .{.{ .ref = .src0 }},
9051 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9052 .each = .{ .once = &.{
9053 .{ ._, .v_d, .mov, .tmp0d, .src1x, ._, ._ },
9054 .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
9055 .{ ._, .v_d, .mov, .tmp2d, .dst0x, ._, ._ },
9056 .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
9057 .{ ._, ._, .@"and", .tmp3d, .sa(.src0, .add_smin), ._, ._ },
9058 .{ ._, ._, .xor, .tmp3d, .tmp2d, ._, ._ },
9059 .{ ._, ._, .cmp, .tmp3w, .sa(.src0, .add_smin), ._, ._ },
9060 .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
9061 .{ ._, .v_d, .mov, .src1x, .tmp0d, ._, ._ },
9062 .{ ._, .v_ps, .cvtph2, .src0x, .src0q, ._, ._ },
9063 .{ ._, .v_ps, .cvtph2, .src1x, .src1q, ._, ._ },
9064 .{ ._, .v_ss, .add, .dst0x, .src0x, .src1d, ._ },
9065 .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
9066 } },
9067 }, .{
9068 .required_features = .{ .avx, .fast_imm16, null, null },
9069 .src_constraints = .{
9070 .{ .scalar_float = .{ .of = .word, .is = .word } },
9071 .{ .scalar_float = .{ .of = .word, .is = .word } },
9072 .any,
9073 },
9074 .patterns = &.{
9075 .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
9076 },
9077 .call_frame = .{ .alignment = .@"16" },
9078 .extra_temps = .{
9079 .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
9080 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodh" } } },
9081 .{ .type = .f16, .kind = .{ .reg = .dx } },
9082 .{ .type = .f16, .kind = .{ .reg = .ax } },
9083 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__addhf3" } } },
9084 .unused,
9085 .unused,
9086 .unused,
9087 .unused,
9088 },
9089 .dst_temps = .{.{ .ref = .src0 }},
9090 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9091 .each = .{ .once = &.{
9092 .{ ._, .v_d, .mov, .tmp0d, .src1x, ._, ._ },
9093 .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
9094 .{ ._, .v_d, .mov, .tmp2d, .dst0x, ._, ._ },
9095 .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
9096 .{ ._, ._, .@"and", .tmp3w, .sa(.src0, .add_smin), ._, ._ },
9097 .{ ._, ._, .xor, .tmp3d, .tmp2d, ._, ._ },
9098 .{ ._, ._, .cmp, .tmp3w, .sa(.src0, .add_smin), ._, ._ },
9099 .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
9100 .{ ._, .v_d, .mov, .src1x, .tmp0d, ._, ._ },
9101 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
9102 } },
9103 }, .{
9104 .required_features = .{ .avx, null, null, null },
9105 .src_constraints = .{
9106 .{ .scalar_float = .{ .of = .word, .is = .word } },
9107 .{ .scalar_float = .{ .of = .word, .is = .word } },
9108 .any,
9109 },
9110 .patterns = &.{
9111 .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
9112 },
9113 .call_frame = .{ .alignment = .@"16" },
9114 .extra_temps = .{
9115 .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
9116 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodh" } } },
9117 .{ .type = .f16, .kind = .{ .reg = .dx } },
9118 .{ .type = .f16, .kind = .{ .reg = .ax } },
9119 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__addhf3" } } },
9120 .unused,
9121 .unused,
9122 .unused,
9123 .unused,
9124 },
9125 .dst_temps = .{.{ .ref = .src0 }},
9126 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9127 .each = .{ .once = &.{
9128 .{ ._, .v_d, .mov, .tmp0d, .src1x, ._, ._ },
9129 .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
9130 .{ ._, .v_d, .mov, .tmp2d, .dst0x, ._, ._ },
9131 .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
9132 .{ ._, ._, .@"and", .tmp3d, .sa(.src0, .add_smin), ._, ._ },
9133 .{ ._, ._, .xor, .tmp3d, .tmp2d, ._, ._ },
9134 .{ ._, ._, .cmp, .tmp3w, .sa(.src0, .add_smin), ._, ._ },
9135 .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
9136 .{ ._, .v_d, .mov, .src1x, .tmp0d, ._, ._ },
9137 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
9138 } },
9139 }, .{
9140 .required_features = .{ .sse2, .fast_imm16, null, null },
9141 .src_constraints = .{
9142 .{ .scalar_float = .{ .of = .word, .is = .word } },
9143 .{ .scalar_float = .{ .of = .word, .is = .word } },
9144 .any,
9145 },
9146 .patterns = &.{
9147 .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
9148 },
9149 .call_frame = .{ .alignment = .@"16" },
9150 .extra_temps = .{
9151 .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
9152 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodh" } } },
9153 .{ .type = .f16, .kind = .{ .reg = .dx } },
9154 .{ .type = .f16, .kind = .{ .reg = .ax } },
9155 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__addhf3" } } },
9156 .unused,
9157 .unused,
9158 .unused,
9159 .unused,
9160 },
9161 .dst_temps = .{.{ .ref = .src0 }},
9162 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9163 .each = .{ .once = &.{
9164 .{ ._, ._d, .mov, .tmp0d, .src1x, ._, ._ },
9165 .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
9166 .{ ._, ._d, .mov, .tmp2d, .dst0x, ._, ._ },
9167 .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
9168 .{ ._, ._, .@"and", .tmp3w, .sa(.src0, .add_smin), ._, ._ },
9169 .{ ._, ._, .xor, .tmp3d, .tmp2d, ._, ._ },
9170 .{ ._, ._, .cmp, .tmp3w, .sa(.src0, .add_smin), ._, ._ },
9171 .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
9172 .{ ._, ._d, .mov, .src1x, .tmp0d, ._, ._ },
9173 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
9174 } },
9175 }, .{
9176 .required_features = .{ .sse2, null, null, null },
9177 .src_constraints = .{
9178 .{ .scalar_float = .{ .of = .word, .is = .word } },
9179 .{ .scalar_float = .{ .of = .word, .is = .word } },
9180 .any,
9181 },
9182 .patterns = &.{
9183 .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
9184 },
9185 .call_frame = .{ .alignment = .@"16" },
9186 .extra_temps = .{
9187 .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
9188 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodh" } } },
9189 .{ .type = .f16, .kind = .{ .reg = .dx } },
9190 .{ .type = .f16, .kind = .{ .reg = .ax } },
9191 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__addhf3" } } },
9192 .unused,
9193 .unused,
9194 .unused,
9195 .unused,
9196 },
9197 .dst_temps = .{.{ .ref = .src0 }},
9198 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9199 .each = .{ .once = &.{
9200 .{ ._, ._d, .mov, .tmp0d, .src1x, ._, ._ },
9201 .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
9202 .{ ._, ._d, .mov, .tmp2d, .dst0x, ._, ._ },
9203 .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
9204 .{ ._, ._, .@"and", .tmp3d, .sa(.src0, .add_smin), ._, ._ },
9205 .{ ._, ._, .xor, .tmp3d, .tmp2d, ._, ._ },
9206 .{ ._, ._, .cmp, .tmp3w, .sa(.src0, .add_smin), ._, ._ },
9207 .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
9208 .{ ._, ._d, .mov, .src1x, .tmp0d, ._, ._ },
9209 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
9210 } },
9211 }, .{
9212 .required_features = .{ .sse, .fast_imm16, null, null },
9213 .src_constraints = .{
9214 .{ .scalar_float = .{ .of = .word, .is = .word } },
9215 .{ .scalar_float = .{ .of = .word, .is = .word } },
9216 .any,
9217 },
9218 .patterns = &.{
9219 .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
9220 },
9221 .call_frame = .{ .alignment = .@"16" },
9222 .extra_temps = .{
9223 .{ .type = .f32, .kind = .mem },
9224 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodh" } } },
9225 .{ .type = .f32, .kind = .mem },
9226 .{ .type = .f16, .kind = .{ .reg = .ax } },
9227 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__addhf3" } } },
9228 .unused,
9229 .unused,
9230 .unused,
9231 .unused,
9232 },
9233 .dst_temps = .{.{ .ref = .src0 }},
9234 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9235 .each = .{ .once = &.{
9236 .{ ._, ._ss, .mov, .mem(.tmp0d), .src1x, ._, ._ },
9237 .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
9238 .{ ._, ._ss, .mov, .mem(.tmp2d), .dst0x, ._, ._ },
9239 .{ ._, ._, .mov, .tmp3d, .mem(.tmp0d), ._, ._ },
9240 .{ ._, ._, .@"and", .tmp3w, .sa(.src0, .add_smin), ._, ._ },
9241 .{ ._, ._, .xor, .tmp3d, .mem(.tmp2d), ._, ._ },
9242 .{ ._, ._, .cmp, .tmp3w, .sa(.src0, .add_smin), ._, ._ },
9243 .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
9244 .{ ._, ._ss, .mov, .src1x, .mem(.tmp0d), ._, ._ },
9245 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
9246 } },
9247 }, .{
9248 .required_features = .{ .sse, null, null, null },
9249 .src_constraints = .{
9250 .{ .scalar_float = .{ .of = .word, .is = .word } },
9251 .{ .scalar_float = .{ .of = .word, .is = .word } },
9252 .any,
9253 },
9254 .patterns = &.{
9255 .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
9256 },
9257 .call_frame = .{ .alignment = .@"16" },
9258 .extra_temps = .{
9259 .{ .type = .f32, .kind = .mem },
9260 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodh" } } },
9261 .{ .type = .f32, .kind = .mem },
9262 .{ .type = .f16, .kind = .{ .reg = .ax } },
9263 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__addhf3" } } },
9264 .unused,
9265 .unused,
9266 .unused,
9267 .unused,
9268 },
9269 .dst_temps = .{.{ .ref = .src0 }},
9270 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9271 .each = .{ .once = &.{
9272 .{ ._, ._ss, .mov, .mem(.tmp0d), .src1x, ._, ._ },
9273 .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
9274 .{ ._, ._ss, .mov, .mem(.tmp2d), .dst0x, ._, ._ },
9275 .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_smin), ._, ._ },
9276 .{ ._, ._, .@"and", .tmp3d, .mem(.tmp0d), ._, ._ },
9277 .{ ._, ._, .xor, .tmp3d, .mem(.tmp2d), ._, ._ },
9278 .{ ._, ._, .cmp, .tmp3w, .sa(.src0, .add_smin), ._, ._ },
9279 .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
9280 .{ ._, ._ss, .mov, .src1x, .mem(.tmp0d), ._, ._ },
9281 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
9282 } },
9283 }, .{
9284 .required_features = .{ .f16c, .fast_imm16, null, null },
9285 .src_constraints = .{
9286 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
9287 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
9288 .any,
9289 },
9290 .patterns = &.{
9291 .{ .src = .{ .to_mem, .to_mem, .none } },
9292 },
9293 .call_frame = .{ .alignment = .@"16" },
9294 .extra_temps = .{
9295 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
9296 .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
9297 .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
9298 .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
9299 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodh" } } },
9300 .{ .type = .f16, .kind = .{ .reg = .dx } },
9301 .{ .type = .f16, .kind = .{ .reg = .ax } },
9302 .unused,
9303 .unused,
9304 },
9305 .dst_temps = .{.mem},
9306 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9307 .each = .{ .once = &.{
9308 .{ ._, ._, .mov, .tmp0p, .sa(.src0x, .sub_unaligned_size), ._, ._ },
9309 .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
9310 .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
9311 .{ ._, ._, .movzx, .tmp2d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
9312 .{ ._, .v_d, .mov, .tmp3x, .tmp2d, ._, ._ },
9313 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
9314 .{ ._, .v_d, .mov, .tmp5d, .tmp1x, ._, ._ },
9315 .{ ._, ._, .mov, .tmp6d, .tmp2d, ._, ._ },
9316 .{ ._, ._, .@"and", .tmp6w, .sa(.src0, .add_smin), ._, ._ },
9317 .{ ._, ._, .xor, .tmp6d, .tmp5d, ._, ._ },
9318 .{ ._, ._, .cmp, .tmp6w, .sa(.src0, .add_smin), ._, ._ },
9319 .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
9320 .{ ._, .v_d, .mov, .tmp3x, .tmp2d, ._, ._ },
9321 .{ ._, .v_ps, .cvtph2, .tmp1x, .tmp1x, ._, ._ },
9322 .{ ._, .v_ps, .cvtph2, .tmp3x, .tmp3x, ._, ._ },
9323 .{ ._, .v_ss, .add, .tmp1x, .tmp1x, .tmp3d, ._ },
9324 .{ ._, .v_, .cvtps2ph, .tmp1q, .tmp1x, .rm(.{}), ._ },
9325 .{ .@"1:", .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
9326 .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
9327 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
9328 } },
9329 }, .{
9330 .required_features = .{ .f16c, null, null, null },
9331 .src_constraints = .{
9332 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
9333 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
9334 .any,
9335 },
9336 .patterns = &.{
9337 .{ .src = .{ .to_mem, .to_mem, .none } },
9338 },
9339 .call_frame = .{ .alignment = .@"16" },
9340 .extra_temps = .{
9341 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
9342 .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
9343 .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
9344 .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
9345 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodh" } } },
9346 .{ .type = .f16, .kind = .{ .reg = .dx } },
9347 .{ .type = .f16, .kind = .{ .reg = .ax } },
9348 .unused,
9349 .unused,
9350 },
9351 .dst_temps = .{.mem},
9352 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9353 .each = .{ .once = &.{
9354 .{ ._, ._, .mov, .tmp0p, .sa(.src0x, .sub_unaligned_size), ._, ._ },
9355 .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
9356 .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
9357 .{ ._, ._, .movzx, .tmp2d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
9358 .{ ._, .v_d, .mov, .tmp3x, .tmp2d, ._, ._ },
9359 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
9360 .{ ._, .v_d, .mov, .tmp5d, .tmp1x, ._, ._ },
9361 .{ ._, ._, .mov, .tmp6d, .tmp2d, ._, ._ },
9362 .{ ._, ._, .@"and", .tmp6d, .sa(.src0, .add_smin), ._, ._ },
9363 .{ ._, ._, .xor, .tmp6d, .tmp5d, ._, ._ },
9364 .{ ._, ._, .cmp, .tmp6w, .sa(.src0, .add_smin), ._, ._ },
9365 .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
9366 .{ ._, .v_d, .mov, .tmp3x, .tmp2d, ._, ._ },
9367 .{ ._, .v_ps, .cvtph2, .tmp1x, .tmp1x, ._, ._ },
9368 .{ ._, .v_ps, .cvtph2, .tmp3x, .tmp3x, ._, ._ },
9369 .{ ._, .v_ss, .add, .tmp1x, .tmp1x, .tmp3d, ._ },
9370 .{ ._, .v_, .cvtps2ph, .tmp1q, .tmp1x, .rm(.{}), ._ },
9371 .{ .@"1:", .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
9372 .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
9373 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
9374 } },
9375 }, .{
9376 .required_features = .{ .avx, .fast_imm16, null, null },
9377 .src_constraints = .{
9378 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
9379 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
9380 .any,
9381 },
9382 .patterns = &.{
9383 .{ .src = .{ .to_mem, .to_mem, .none } },
9384 },
9385 .call_frame = .{ .alignment = .@"16" },
9386 .extra_temps = .{
9387 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
9388 .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
9389 .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
9390 .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
9391 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodh" } } },
9392 .{ .type = .f16, .kind = .{ .reg = .dx } },
9393 .{ .type = .f16, .kind = .{ .reg = .ax } },
9394 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__addhf3" } } },
9395 .unused,
9396 },
9397 .dst_temps = .{.mem},
9398 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9399 .each = .{ .once = &.{
9400 .{ ._, ._, .mov, .tmp0p, .sa(.src0x, .sub_unaligned_size), ._, ._ },
9401 .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
9402 .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
9403 .{ ._, ._, .movzx, .tmp2d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
9404 .{ ._, .v_d, .mov, .tmp3x, .tmp2d, ._, ._ },
9405 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
9406 .{ ._, .v_d, .mov, .tmp5d, .tmp1x, ._, ._ },
9407 .{ ._, ._, .mov, .tmp6d, .tmp2d, ._, ._ },
9408 .{ ._, ._, .@"and", .tmp6w, .sa(.src0, .add_smin), ._, ._ },
9409 .{ ._, ._, .xor, .tmp6d, .tmp5d, ._, ._ },
9410 .{ ._, ._, .cmp, .tmp6w, .sa(.src0, .add_smin), ._, ._ },
9411 .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
9412 .{ ._, .v_d, .mov, .tmp3x, .tmp2d, ._, ._ },
9413 .{ ._, ._, .call, .tmp7d, ._, ._, ._ },
9414 .{ .@"1:", .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
9415 .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
9416 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
9417 } },
9418 }, .{
9419 .required_features = .{ .avx, null, null, null },
9420 .src_constraints = .{
9421 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
9422 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
9423 .any,
9424 },
9425 .patterns = &.{
9426 .{ .src = .{ .to_mem, .to_mem, .none } },
9427 },
9428 .call_frame = .{ .alignment = .@"16" },
9429 .extra_temps = .{
9430 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
9431 .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
9432 .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
9433 .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
9434 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodh" } } },
9435 .{ .type = .f16, .kind = .{ .reg = .dx } },
9436 .{ .type = .f16, .kind = .{ .reg = .ax } },
9437 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__addhf3" } } },
9438 .unused,
9439 },
9440 .dst_temps = .{.mem},
9441 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9442 .each = .{ .once = &.{
9443 .{ ._, ._, .mov, .tmp0p, .sa(.src0x, .sub_unaligned_size), ._, ._ },
9444 .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
9445 .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
9446 .{ ._, ._, .movzx, .tmp2d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
9447 .{ ._, .v_d, .mov, .tmp3x, .tmp2d, ._, ._ },
9448 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
9449 .{ ._, .v_d, .mov, .tmp5d, .tmp1x, ._, ._ },
9450 .{ ._, ._, .mov, .tmp6d, .tmp2d, ._, ._ },
9451 .{ ._, ._, .@"and", .tmp6d, .sa(.src0, .add_smin), ._, ._ },
9452 .{ ._, ._, .xor, .tmp6d, .tmp5d, ._, ._ },
9453 .{ ._, ._, .cmp, .tmp6w, .sa(.src0, .add_smin), ._, ._ },
9454 .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
9455 .{ ._, .v_d, .mov, .tmp3x, .tmp2d, ._, ._ },
9456 .{ ._, ._, .call, .tmp7d, ._, ._, ._ },
9457 .{ .@"1:", .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
9458 .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
9459 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
9460 } },
9461 }, .{
9462 .required_features = .{ .sse4_1, .fast_imm16, null, null },
9463 .src_constraints = .{
9464 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
9465 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
9466 .any,
9467 },
9468 .patterns = &.{
9469 .{ .src = .{ .to_mem, .to_mem, .none } },
9470 },
9471 .call_frame = .{ .alignment = .@"16" },
9472 .extra_temps = .{
9473 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
9474 .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
9475 .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
9476 .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
9477 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodh" } } },
9478 .{ .type = .f16, .kind = .{ .reg = .dx } },
9479 .{ .type = .f16, .kind = .{ .reg = .ax } },
9480 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__addhf3" } } },
9481 .unused,
9482 },
9483 .dst_temps = .{.mem},
9484 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9485 .each = .{ .once = &.{
9486 .{ ._, ._, .mov, .tmp0p, .sa(.src0x, .sub_unaligned_size), ._, ._ },
9487 .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
9488 .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
9489 .{ ._, ._, .movzx, .tmp2d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
9490 .{ ._, ._d, .mov, .tmp3x, .tmp2d, ._, ._ },
9491 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
9492 .{ ._, ._d, .mov, .tmp5d, .tmp1x, ._, ._ },
9493 .{ ._, ._, .mov, .tmp6d, .tmp2d, ._, ._ },
9494 .{ ._, ._, .@"and", .tmp6w, .sa(.src0, .add_smin), ._, ._ },
9495 .{ ._, ._, .xor, .tmp6d, .tmp5d, ._, ._ },
9496 .{ ._, ._, .cmp, .tmp6w, .sa(.src0, .add_smin), ._, ._ },
9497 .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
9498 .{ ._, ._d, .mov, .tmp3x, .tmp2d, ._, ._ },
9499 .{ ._, ._, .call, .tmp7d, ._, ._, ._ },
9500 .{ .@"1:", .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
9501 .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
9502 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
9503 } },
9504 }, .{
9505 .required_features = .{ .sse4_1, null, null, null },
9506 .src_constraints = .{
9507 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
9508 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
9509 .any,
9510 },
9511 .patterns = &.{
9512 .{ .src = .{ .to_mem, .to_mem, .none } },
9513 },
9514 .call_frame = .{ .alignment = .@"16" },
9515 .extra_temps = .{
9516 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
9517 .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
9518 .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
9519 .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
9520 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodh" } } },
9521 .{ .type = .f16, .kind = .{ .reg = .dx } },
9522 .{ .type = .f16, .kind = .{ .reg = .ax } },
9523 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__addhf3" } } },
9524 .unused,
9525 },
9526 .dst_temps = .{.mem},
9527 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9528 .each = .{ .once = &.{
9529 .{ ._, ._, .mov, .tmp0p, .sa(.src0x, .sub_unaligned_size), ._, ._ },
9530 .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
9531 .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
9532 .{ ._, ._, .movzx, .tmp2d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
9533 .{ ._, ._d, .mov, .tmp3x, .tmp2d, ._, ._ },
9534 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
9535 .{ ._, ._d, .mov, .tmp5d, .tmp1x, ._, ._ },
9536 .{ ._, ._, .mov, .tmp6d, .tmp2d, ._, ._ },
9537 .{ ._, ._, .@"and", .tmp6d, .sa(.src0, .add_smin), ._, ._ },
9538 .{ ._, ._, .xor, .tmp6d, .tmp5d, ._, ._ },
9539 .{ ._, ._, .cmp, .tmp6w, .sa(.src0, .add_smin), ._, ._ },
9540 .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
9541 .{ ._, ._d, .mov, .tmp3x, .tmp2d, ._, ._ },
9542 .{ ._, ._, .call, .tmp7d, ._, ._, ._ },
9543 .{ .@"1:", .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
9544 .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
9545 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
9546 } },
9547 }, .{
9548 .required_features = .{ .sse2, .fast_imm16, null, null },
9549 .src_constraints = .{
9550 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
9551 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
9552 .any,
9553 },
9554 .patterns = &.{
9555 .{ .src = .{ .to_mem, .to_mem, .none } },
9556 },
9557 .call_frame = .{ .alignment = .@"16" },
9558 .extra_temps = .{
9559 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
9560 .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
9561 .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
9562 .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
9563 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodh" } } },
9564 .{ .type = .f16, .kind = .{ .reg = .dx } },
9565 .{ .type = .f16, .kind = .{ .reg = .ax } },
9566 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__addhf3" } } },
9567 .unused,
9568 },
9569 .dst_temps = .{.mem},
9570 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9571 .each = .{ .once = &.{
9572 .{ ._, ._, .mov, .tmp0p, .sa(.src0x, .sub_unaligned_size), ._, ._ },
9573 .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
9574 .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
9575 .{ ._, ._, .movzx, .tmp2d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
9576 .{ ._, ._d, .mov, .tmp3x, .tmp2d, ._, ._ },
9577 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
9578 .{ ._, ._d, .mov, .tmp5d, .tmp1x, ._, ._ },
9579 .{ ._, ._, .mov, .tmp6d, .tmp2d, ._, ._ },
9580 .{ ._, ._, .@"and", .tmp6w, .sa(.src0, .add_smin), ._, ._ },
9581 .{ ._, ._, .xor, .tmp6d, .tmp5d, ._, ._ },
9582 .{ ._, ._, .cmp, .tmp6w, .sa(.src0, .add_smin), ._, ._ },
9583 .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
9584 .{ ._, ._d, .mov, .tmp3x, .tmp2d, ._, ._ },
9585 .{ ._, ._, .call, .tmp7d, ._, ._, ._ },
9586 .{ ._, ._d, .mov, .tmp5d, .tmp1x, ._, ._ },
9587 .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp5w, ._, ._ },
9588 .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
9589 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
9590 } },
9591 }, .{
9592 .required_features = .{ .sse2, null, null, null },
9593 .src_constraints = .{
9594 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
9595 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
9596 .any,
9597 },
9598 .patterns = &.{
9599 .{ .src = .{ .to_mem, .to_mem, .none } },
9600 },
9601 .call_frame = .{ .alignment = .@"16" },
9602 .extra_temps = .{
9603 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
9604 .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
9605 .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
9606 .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
9607 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodh" } } },
9608 .{ .type = .f16, .kind = .{ .reg = .dx } },
9609 .{ .type = .f16, .kind = .{ .reg = .ax } },
9610 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__addhf3" } } },
9611 .unused,
9612 },
9613 .dst_temps = .{.mem},
9614 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9615 .each = .{ .once = &.{
9616 .{ ._, ._, .mov, .tmp0p, .sa(.src0x, .sub_unaligned_size), ._, ._ },
9617 .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
9618 .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
9619 .{ ._, ._, .movzx, .tmp2d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
9620 .{ ._, ._d, .mov, .tmp3x, .tmp2d, ._, ._ },
9621 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
9622 .{ ._, ._d, .mov, .tmp5d, .tmp1x, ._, ._ },
9623 .{ ._, ._, .mov, .tmp6d, .tmp2d, ._, ._ },
9624 .{ ._, ._, .@"and", .tmp6d, .sa(.src0, .add_smin), ._, ._ },
9625 .{ ._, ._, .xor, .tmp6d, .tmp5d, ._, ._ },
9626 .{ ._, ._, .cmp, .tmp6w, .sa(.src0, .add_smin), ._, ._ },
9627 .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
9628 .{ ._, ._d, .mov, .tmp3x, .tmp2d, ._, ._ },
9629 .{ ._, ._, .call, .tmp7d, ._, ._, ._ },
9630 .{ ._, ._d, .mov, .tmp5d, .tmp1x, ._, ._ },
9631 .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp5w, ._, ._ },
9632 .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
9633 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
9634 } },
9635 }, .{
9636 .required_features = .{ .sse, .fast_imm16, null, null },
9637 .src_constraints = .{
9638 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
9639 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
9640 .any,
9641 },
9642 .patterns = &.{
9643 .{ .src = .{ .to_mem, .to_mem, .none } },
9644 },
9645 .call_frame = .{ .alignment = .@"16" },
9646 .extra_temps = .{
9647 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
9648 .{ .type = .f16, .kind = .{ .reg = .ax } },
9649 .{ .type = .f32, .kind = .mem },
9650 .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
9651 .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
9652 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodh" } } },
9653 .{ .type = .f32, .kind = .mem },
9654 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__addhf3" } } },
9655 .unused,
9656 },
9657 .dst_temps = .{.mem},
9658 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9659 .each = .{ .once = &.{
9660 .{ ._, ._, .mov, .tmp0p, .sa(.src0x, .sub_unaligned_size), ._, ._ },
9661 .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
9662 .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
9663 .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
9664 .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
9665 .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
9666 .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ },
9667 .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
9668 .{ ._, ._ss, .mov, .mem(.tmp6d), .tmp3x, ._, ._ },
9669 .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ },
9670 .{ ._, ._, .@"and", .tmp1w, .sa(.src0, .add_smin), ._, ._ },
9671 .{ ._, ._, .xor, .tmp1d, .mem(.tmp6d), ._, ._ },
9672 .{ ._, ._, .cmp, .tmp1w, .sa(.src0, .add_smin), ._, ._ },
9673 .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
9674 .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ },
9675 .{ ._, ._, .call, .tmp7d, ._, ._, ._ },
9676 .{ ._, ._ss, .mov, .mem(.tmp6d), .tmp3x, ._, ._ },
9677 .{ .@"1:", ._, .mov, .tmp1d, .mem(.tmp6d), ._, ._ },
9678 .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
9679 .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
9680 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
9681 } },
9682 }, .{
9683 .required_features = .{ .sse, null, null, null },
9684 .src_constraints = .{
9685 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
9686 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
9687 .any,
9688 },
9689 .patterns = &.{
9690 .{ .src = .{ .to_mem, .to_mem, .none } },
9691 },
9692 .call_frame = .{ .alignment = .@"16" },
9693 .extra_temps = .{
9694 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
9695 .{ .type = .f16, .kind = .{ .reg = .ax } },
9696 .{ .type = .f32, .kind = .mem },
9697 .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
9698 .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
9699 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodh" } } },
9700 .{ .type = .f32, .kind = .mem },
9701 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__addhf3" } } },
9702 .unused,
9703 },
9704 .dst_temps = .{.mem},
9705 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9706 .each = .{ .once = &.{
9707 .{ ._, ._, .mov, .tmp0p, .sa(.src0x, .sub_unaligned_size), ._, ._ },
9708 .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
9709 .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
9710 .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
9711 .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
9712 .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
9713 .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ },
9714 .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
9715 .{ ._, ._ss, .mov, .mem(.tmp6d), .tmp3x, ._, ._ },
9716 .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_smin), ._, ._ },
9717 .{ ._, ._, .@"and", .tmp1d, .mem(.tmp2d), ._, ._ },
9718 .{ ._, ._, .xor, .tmp1d, .mem(.tmp6d), ._, ._ },
9719 .{ ._, ._, .cmp, .tmp1w, .sa(.src0, .add_smin), ._, ._ },
9720 .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
9721 .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ },
9722 .{ ._, ._, .call, .tmp7d, ._, ._, ._ },
9723 .{ ._, ._ss, .mov, .mem(.tmp6d), .tmp3x, ._, ._ },
9724 .{ .@"1:", ._, .mov, .tmp1d, .mem(.tmp6d), ._, ._ },
9725 .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
9726 .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
9727 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
9728 } },
9729 }, .{
9730 .required_features = .{ .avx, null, null, null },
9731 .src_constraints = .{
9732 .{ .scalar_float = .{ .of = .dword, .is = .dword } },
9733 .{ .scalar_float = .{ .of = .dword, .is = .dword } },
9734 .any,
9735 },
9736 .patterns = &.{
9737 .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
9738 },
9739 .call_frame = .{ .alignment = .@"16" },
9740 .extra_temps = .{
9741 .{ .type = .f32, .kind = .{ .rc = .general_purpose } },
9742 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmodf" } } },
9743 .{ .type = .f32, .kind = .{ .reg = .edx } },
9744 .{ .type = .f32, .kind = .{ .reg = .eax } },
9745 .unused,
9746 .unused,
9747 .unused,
9748 .unused,
9749 .unused,
9750 },
9751 .dst_temps = .{.{ .ref = .src0 }},
9752 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9753 .each = .{ .once = &.{
9754 .{ ._, .v_d, .mov, .tmp0d, .src1x, ._, ._ },
9755 .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
9756 .{ ._, .v_d, .mov, .tmp2d, .dst0x, ._, ._ },
9757 .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
9758 .{ ._, ._, .@"and", .tmp3d, .sa(.src0, .add_smin), ._, ._ },
9759 .{ ._, ._, .xor, .tmp3d, .tmp2d, ._, ._ },
9760 .{ ._, ._, .cmp, .tmp3d, .sa(.src0, .add_smin), ._, ._ },
9761 .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
9762 .{ ._, .v_d, .mov, .src1x, .tmp0d, ._, ._ },
9763 .{ ._, .v_ss, .add, .dst0x, .src0x, .src1d, ._ },
9764 } },
9765 }, .{
9766 .required_features = .{ .sse2, null, null, null },
9767 .src_constraints = .{
9768 .{ .scalar_float = .{ .of = .dword, .is = .dword } },
9769 .{ .scalar_float = .{ .of = .dword, .is = .dword } },
9770 .any,
9771 },
9772 .patterns = &.{
9773 .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
9774 },
9775 .call_frame = .{ .alignment = .@"16" },
9776 .extra_temps = .{
9777 .{ .type = .f32, .kind = .{ .rc = .general_purpose } },
9778 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmodf" } } },
9779 .{ .type = .f32, .kind = .{ .reg = .edx } },
9780 .{ .type = .f32, .kind = .{ .reg = .eax } },
9781 .unused,
9782 .unused,
9783 .unused,
9784 .unused,
9785 .unused,
9786 },
9787 .dst_temps = .{.{ .ref = .src0 }},
9788 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9789 .each = .{ .once = &.{
9790 .{ ._, ._d, .mov, .tmp0d, .src1x, ._, ._ },
9791 .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
9792 .{ ._, ._d, .mov, .tmp2d, .dst0x, ._, ._ },
9793 .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
9794 .{ ._, ._, .@"and", .tmp3d, .sa(.src0, .add_smin), ._, ._ },
9795 .{ ._, ._, .xor, .tmp3d, .tmp2d, ._, ._ },
9796 .{ ._, ._, .cmp, .tmp3d, .sa(.src0, .add_smin), ._, ._ },
9797 .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
9798 .{ ._, ._d, .mov, .src1x, .tmp0d, ._, ._ },
9799 .{ ._, ._ss, .add, .dst0x, .src1d, ._, ._ },
9800 } },
9801 }, .{
9802 .required_features = .{ .sse, null, null, null },
9803 .src_constraints = .{
9804 .{ .scalar_float = .{ .of = .dword, .is = .dword } },
9805 .{ .scalar_float = .{ .of = .dword, .is = .dword } },
9806 .any,
9807 },
9808 .patterns = &.{
9809 .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
9810 },
9811 .call_frame = .{ .alignment = .@"16" },
9812 .extra_temps = .{
9813 .{ .type = .f32, .kind = .mem },
9814 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmodf" } } },
9815 .{ .type = .f32, .kind = .mem },
9816 .{ .type = .f32, .kind = .{ .reg = .eax } },
9817 .unused,
9818 .unused,
9819 .unused,
9820 .unused,
9821 .unused,
9822 },
9823 .dst_temps = .{.{ .ref = .src0 }},
9824 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9825 .each = .{ .once = &.{
9826 .{ ._, ._ss, .mov, .mem(.tmp0d), .src1x, ._, ._ },
9827 .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
9828 .{ ._, ._ss, .mov, .mem(.tmp2d), .dst0x, ._, ._ },
9829 .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
9830 .{ ._, ._, .@"and", .tmp3d, .sa(.src0, .add_smin), ._, ._ },
9831 .{ ._, ._, .xor, .tmp3d, .mem(.tmp2d), ._, ._ },
9832 .{ ._, ._, .cmp, .tmp3d, .sa(.src0, .add_smin), ._, ._ },
9833 .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
9834 .{ ._, ._ss, .add, .dst0x, .mem(.tmp0d), ._, ._ },
9835 } },
9836 }, .{
9837 .required_features = .{ .avx, null, null, null },
9838 .src_constraints = .{
9839 .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
9840 .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
9841 .any,
9842 },
9843 .patterns = &.{
9844 .{ .src = .{ .to_mem, .to_mem, .none } },
9845 },
9846 .call_frame = .{ .alignment = .@"16" },
9847 .extra_temps = .{
9848 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
9849 .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
9850 .{ .type = .f32, .kind = .{ .reg = .xmm1 } },
9851 .{ .type = .f32, .kind = .{ .rc = .general_purpose } },
9852 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmodf" } } },
9853 .{ .type = .f32, .kind = .{ .reg = .edx } },
9854 .{ .type = .f32, .kind = .{ .reg = .eax } },
9855 .unused,
9856 .unused,
9857 },
9858 .dst_temps = .{.mem},
9859 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9860 .each = .{ .once = &.{
9861 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
9862 .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
9863 .{ ._, .v_ss, .mov, .tmp2x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
9864 .{ ._, .v_d, .mov, .tmp3d, .tmp2x, ._, ._ },
9865 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
9866 .{ ._, .v_d, .mov, .tmp5d, .tmp1x, ._, ._ },
9867 .{ ._, ._, .mov, .tmp6d, .tmp3d, ._, ._ },
9868 .{ ._, ._, .@"and", .tmp6d, .sa(.src0, .add_smin), ._, ._ },
9869 .{ ._, ._, .xor, .tmp6d, .tmp5d, ._, ._ },
9870 .{ ._, ._, .cmp, .tmp6d, .sa(.src0, .add_smin), ._, ._ },
9871 .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
9872 .{ ._, .v_d, .mov, .tmp2x, .tmp3d, ._, ._ },
9873 .{ ._, .v_ss, .add, .tmp1x, .tmp1x, .tmp2d, ._ },
9874 .{ .@"1:", .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
9875 .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
9876 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
9877 } },
9878 }, .{
9879 .required_features = .{ .sse2, null, null, null },
9880 .src_constraints = .{
9881 .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
9882 .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
9883 .any,
9884 },
9885 .patterns = &.{
9886 .{ .src = .{ .to_mem, .to_mem, .none } },
9887 },
9888 .call_frame = .{ .alignment = .@"16" },
9889 .extra_temps = .{
9890 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
9891 .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
9892 .{ .type = .f32, .kind = .{ .reg = .xmm1 } },
9893 .{ .type = .f32, .kind = .{ .rc = .general_purpose } },
9894 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmodf" } } },
9895 .{ .type = .f32, .kind = .{ .reg = .edx } },
9896 .{ .type = .f32, .kind = .{ .reg = .eax } },
9897 .unused,
9898 .unused,
9899 },
9900 .dst_temps = .{.mem},
9901 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9902 .each = .{ .once = &.{
9903 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
9904 .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
9905 .{ ._, ._ss, .mov, .tmp2x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
9906 .{ ._, ._d, .mov, .tmp3d, .tmp2x, ._, ._ },
9907 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
9908 .{ ._, ._d, .mov, .tmp5d, .tmp1x, ._, ._ },
9909 .{ ._, ._, .mov, .tmp6d, .tmp3d, ._, ._ },
9910 .{ ._, ._, .@"and", .tmp6d, .sa(.src0, .add_smin), ._, ._ },
9911 .{ ._, ._, .xor, .tmp6d, .tmp5d, ._, ._ },
9912 .{ ._, ._, .cmp, .tmp6d, .sa(.src0, .add_smin), ._, ._ },
9913 .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
9914 .{ ._, ._d, .mov, .tmp2x, .tmp3d, ._, ._ },
9915 .{ ._, ._ss, .add, .tmp1x, .tmp2d, ._, ._ },
9916 .{ .@"1:", ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
9917 .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
9918 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
9919 } },
9920 }, .{
9921 .required_features = .{ .sse, null, null, null },
9922 .src_constraints = .{
9923 .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
9924 .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
9925 .any,
9926 },
9927 .patterns = &.{
9928 .{ .src = .{ .to_mem, .to_mem, .none } },
9929 },
9930 .call_frame = .{ .alignment = .@"16" },
9931 .extra_temps = .{
9932 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
9933 .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
9934 .{ .type = .f32, .kind = .{ .reg = .xmm1 } },
9935 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmodf" } } },
9936 .{ .type = .f32, .kind = .mem },
9937 .{ .type = .f32, .kind = .{ .reg = .eax } },
9938 .unused,
9939 .unused,
9940 .unused,
9941 },
9942 .dst_temps = .{.mem},
9943 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9944 .each = .{ .once = &.{
9945 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
9946 .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
9947 .{ ._, ._ss, .mov, .tmp2x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
9948 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
9949 .{ ._, ._ss, .mov, .mem(.tmp4d), .tmp1x, ._, ._ },
9950 .{ ._, ._, .mov, .tmp5d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
9951 .{ ._, ._, .@"and", .tmp5d, .sa(.src0, .add_smin), ._, ._ },
9952 .{ ._, ._, .xor, .tmp5d, .mem(.tmp4d), ._, ._ },
9953 .{ ._, ._, .cmp, .tmp5d, .sa(.src0, .add_smin), ._, ._ },
9954 .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
9955 .{ ._, ._ss, .add, .tmp1x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
9956 .{ .@"1:", ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
9957 .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
9958 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
9959 } },
9960 }, .{
9961 .required_features = .{ .@"64bit", .avx, null, null },
9962 .src_constraints = .{
9963 .{ .scalar_float = .{ .of = .qword, .is = .qword } },
9964 .{ .scalar_float = .{ .of = .qword, .is = .qword } },
9965 .any,
9966 },
9967 .patterns = &.{
9968 .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
9969 },
9970 .call_frame = .{ .alignment = .@"16" },
9971 .extra_temps = .{
9972 .{ .type = .f64, .kind = .{ .rc = .general_purpose } },
9973 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmod" } } },
9974 .{ .type = .f64, .kind = .{ .reg = .rcx } },
9975 .{ .type = .f64, .kind = .{ .reg = .rdx } },
9976 .{ .type = .f64, .kind = .{ .reg = .rax } },
9977 .unused,
9978 .unused,
9979 .unused,
9980 .unused,
9981 },
9982 .dst_temps = .{.{ .ref = .src0 }},
9983 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9984 .each = .{ .once = &.{
9985 .{ ._, .v_q, .mov, .tmp0q, .src1x, ._, ._ },
9986 .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
9987 .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_smin), ._, ._ },
9988 .{ ._, .v_q, .mov, .tmp3q, .dst0x, ._, ._ },
9989 .{ ._, ._, .mov, .tmp4q, .tmp0q, ._, ._ },
9990 .{ ._, ._, .@"and", .tmp4q, .tmp2q, ._, ._ },
9991 .{ ._, ._, .xor, .tmp4q, .tmp3q, ._, ._ },
9992 .{ ._, ._, .cmp, .tmp4q, .tmp2q, ._, ._ },
9993 .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
9994 .{ ._, .v_q, .mov, .src1q, .tmp0q, ._, ._ },
9995 .{ ._, .v_sd, .add, .dst0x, .src0x, .src1q, ._ },
9996 } },
9997 }, .{
9998 .required_features = .{ .@"64bit", .sse2, null, null },
9999 .src_constraints = .{
10000 .{ .scalar_float = .{ .of = .qword, .is = .qword } },
10001 .{ .scalar_float = .{ .of = .qword, .is = .qword } },
10002 .any,
10003 },
10004 .patterns = &.{
10005 .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
10006 },
10007 .call_frame = .{ .alignment = .@"16" },
10008 .extra_temps = .{
10009 .{ .type = .f64, .kind = .{ .rc = .general_purpose } },
10010 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmod" } } },
10011 .{ .type = .f64, .kind = .{ .reg = .rcx } },
10012 .{ .type = .f64, .kind = .{ .reg = .rdx } },
10013 .{ .type = .f64, .kind = .{ .reg = .rax } },
10014 .unused,
10015 .unused,
10016 .unused,
10017 .unused,
10018 },
10019 .dst_temps = .{.{ .ref = .src0 }},
10020 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
10021 .each = .{ .once = &.{
10022 .{ ._, ._q, .mov, .tmp0q, .src1x, ._, ._ },
10023 .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
10024 .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_smin), ._, ._ },
10025 .{ ._, ._q, .mov, .tmp3q, .dst0x, ._, ._ },
10026 .{ ._, ._, .mov, .tmp4q, .tmp0q, ._, ._ },
10027 .{ ._, ._, .@"and", .tmp4q, .tmp2q, ._, ._ },
10028 .{ ._, ._, .xor, .tmp4q, .tmp3q, ._, ._ },
10029 .{ ._, ._, .cmp, .tmp4q, .tmp2q, ._, ._ },
10030 .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
10031 .{ ._, ._q, .mov, .src1x, .tmp0q, ._, ._ },
10032 .{ ._, ._sd, .add, .dst0x, .src1q, ._, ._ },
10033 } },
10034 }, .{
10035 .required_features = .{ .@"64bit", .sse, null, null },
10036 .src_constraints = .{
10037 .{ .scalar_float = .{ .of = .qword, .is = .qword } },
10038 .{ .scalar_float = .{ .of = .qword, .is = .qword } },
10039 .any,
10040 },
10041 .patterns = &.{
10042 .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
10043 },
10044 .call_frame = .{ .alignment = .@"16" },
10045 .extra_temps = .{
10046 .{ .type = .f64, .kind = .mem },
10047 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmod" } } },
10048 .{ .type = .f64, .kind = .mem },
10049 .{ .type = .f64, .kind = .{ .reg = .rdx } },
10050 .{ .type = .f64, .kind = .{ .reg = .rax } },
10051 .{ .type = .f64, .kind = .{ .reg = .st6 } },
10052 .{ .type = .f64, .kind = .{ .reg = .st7 } },
10053 .unused,
10054 .unused,
10055 },
10056 .dst_temps = .{.{ .ref = .src0 }},
10057 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
10058 .each = .{ .once = &.{
10059 .{ ._, ._ps, .movl, .mem(.tmp0q), .src1x, ._, ._ },
10060 .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
10061 .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_smin), ._, ._ },
10062 .{ ._, ._ps, .movl, .mem(.tmp2q), .dst0x, ._, ._ },
10063 .{ ._, ._, .mov, .tmp4q, .tmp0q, ._, ._ },
10064 .{ ._, ._, .@"and", .tmp4q, .tmp3q, ._, ._ },
10065 .{ ._, ._, .xor, .tmp4q, .mem(.tmp2q), ._, ._ },
10066 .{ ._, ._, .cmp, .tmp4q, .tmp3q, ._, ._ },
10067 .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
10068 .{ ._, .f_, .ld, .mem(.tmp2q), ._, ._, ._ },
10069 .{ ._, .f_, .ld, .mem(.tmp0q), ._, ._, ._ },
10070 .{ ._, .f_p, .add, ._, ._, ._, ._ },
10071 .{ ._, .f_p, .st, .mem(.tmp2q), ._, ._, ._ },
10072 .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
10073 .{ ._, ._ps, .movl, .dst0x, .mem(.tmp2q), ._, ._ },
10074 } },
10075 }, .{
10076 .required_features = .{ .@"64bit", .avx, null, null },
10077 .src_constraints = .{
10078 .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
10079 .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
10080 .any,
10081 },
10082 .patterns = &.{
10083 .{ .src = .{ .to_mem, .to_mem, .none } },
10084 },
10085 .call_frame = .{ .alignment = .@"16" },
10086 .extra_temps = .{
10087 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
10088 .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
10089 .{ .type = .f64, .kind = .{ .reg = .xmm1 } },
10090 .{ .type = .f64, .kind = .{ .rc = .general_purpose } },
10091 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmod" } } },
10092 .{ .type = .f64, .kind = .{ .reg = .rcx } },
10093 .{ .type = .f64, .kind = .{ .reg = .rdx } },
10094 .{ .type = .f64, .kind = .{ .reg = .rax } },
10095 .unused,
10096 },
10097 .dst_temps = .{.mem},
10098 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
10099 .each = .{ .once = &.{
10100 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
10101 .{ .@"0:", .v_sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
10102 .{ ._, .v_sd, .mov, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
10103 .{ ._, .v_q, .mov, .tmp3q, .tmp2x, ._, ._ },
10104 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
10105 .{ ._, ._, .mov, .tmp5q, .ua(.src0, .add_smin), ._, ._ },
10106 .{ ._, .v_q, .mov, .tmp6q, .tmp1x, ._, ._ },
10107 .{ ._, ._, .mov, .tmp7q, .tmp3q, ._, ._ },
10108 .{ ._, ._, .@"and", .tmp7q, .tmp5q, ._, ._ },
10109 .{ ._, ._, .xor, .tmp7q, .tmp6q, ._, ._ },
10110 .{ ._, ._, .cmp, .tmp7q, .tmp5q, ._, ._ },
10111 .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
10112 .{ ._, .v_q, .mov, .tmp2x, .tmp3q, ._, ._ },
10113 .{ ._, .v_sd, .add, .tmp1x, .tmp1x, .tmp2q, ._ },
10114 .{ .@"1:", .v_sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
10115 .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
10116 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
10117 } },
10118 }, .{
10119 .required_features = .{ .@"64bit", .sse2, null, null },
10120 .src_constraints = .{
10121 .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
10122 .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
10123 .any,
10124 },
10125 .patterns = &.{
10126 .{ .src = .{ .to_mem, .to_mem, .none } },
10127 },
10128 .call_frame = .{ .alignment = .@"16" },
10129 .extra_temps = .{
10130 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
10131 .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
10132 .{ .type = .f64, .kind = .{ .reg = .xmm1 } },
10133 .{ .type = .f64, .kind = .{ .rc = .general_purpose } },
10134 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmod" } } },
10135 .{ .type = .f64, .kind = .{ .reg = .rcx } },
10136 .{ .type = .f64, .kind = .{ .reg = .rdx } },
10137 .{ .type = .f64, .kind = .{ .reg = .rax } },
10138 .unused,
10139 },
10140 .dst_temps = .{.mem},
10141 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
10142 .each = .{ .once = &.{
10143 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
10144 .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
10145 .{ ._, ._sd, .mov, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
10146 .{ ._, ._q, .mov, .tmp3q, .tmp2x, ._, ._ },
10147 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
10148 .{ ._, ._, .mov, .tmp5q, .ua(.src0, .add_smin), ._, ._ },
10149 .{ ._, ._q, .mov, .tmp6q, .tmp1x, ._, ._ },
10150 .{ ._, ._, .mov, .tmp7q, .tmp3q, ._, ._ },
10151 .{ ._, ._, .@"and", .tmp7q, .tmp5q, ._, ._ },
10152 .{ ._, ._, .xor, .tmp7q, .tmp6q, ._, ._ },
10153 .{ ._, ._, .cmp, .tmp7q, .tmp5q, ._, ._ },
10154 .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
10155 .{ ._, ._q, .mov, .tmp2x, .tmp3q, ._, ._ },
10156 .{ ._, ._sd, .add, .tmp1x, .tmp2q, ._, ._ },
10157 .{ .@"1:", ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
10158 .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
10159 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
10160 } },
10161 }, .{
10162 .required_features = .{ .@"64bit", .sse, null, null },
10163 .src_constraints = .{
10164 .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
10165 .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
10166 .any,
10167 },
10168 .patterns = &.{
10169 .{ .src = .{ .to_mem, .to_mem, .none } },
10170 },
10171 .call_frame = .{ .alignment = .@"16" },
10172 .extra_temps = .{
10173 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
10174 .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
10175 .{ .type = .f64, .kind = .{ .reg = .xmm1 } },
10176 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmod" } } },
10177 .{ .type = .f64, .kind = .{ .reg = .rdx } },
10178 .{ .type = .f64, .kind = .mem },
10179 .{ .type = .f64, .kind = .{ .reg = .rax } },
10180 .{ .type = .f64, .kind = .{ .reg = .st6 } },
10181 .{ .type = .f64, .kind = .{ .reg = .st7 } },
10182 },
10183 .dst_temps = .{.mem},
10184 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
10185 .each = .{ .once = &.{
10186 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
10187 .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
10188 .{ ._, ._ps, .xor, .tmp2x, .tmp2x, ._, ._ },
10189 .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
10190 .{ ._, ._ps, .movl, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
10191 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
10192 .{ ._, ._, .mov, .tmp4q, .ua(.src0, .add_smin), ._, ._ },
10193 .{ ._, ._ps, .movl, .mem(.tmp5q), .tmp1x, ._, ._ },
10194 .{ ._, ._, .mov, .tmp6q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
10195 .{ ._, ._, .@"and", .tmp6q, .tmp4q, ._, ._ },
10196 .{ ._, ._, .xor, .tmp6q, .mem(.tmp5q), ._, ._ },
10197 .{ ._, ._, .cmp, .tmp6q, .tmp4q, ._, ._ },
10198 .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
10199 .{ ._, .f_, .ld, .mem(.tmp5q), ._, ._, ._ },
10200 .{ ._, .f_, .ld, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ },
10201 .{ ._, .f_p, .add, ._, ._, ._, ._ },
10202 .{ ._, .f_p, .st, .mem(.tmp5q), ._, ._, ._ },
10203 .{ ._, ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
10204 .{ ._, ._ps, .movl, .tmp1x, .mem(.tmp5q), ._, ._ },
10205 .{ .@"1:", ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
10206 .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
10207 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
10208 } },
10209 }, .{
10210 .required_features = .{ .@"64bit", .avx, .x87, .fast_imm16 },
10211 .src_constraints = .{
10212 .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
10213 .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
10214 .any,
10215 },
10216 .patterns = &.{
10217 .{ .src = .{ .to_mem, .to_mem, .none } },
10218 },
10219 .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
10220 .extra_temps = .{
10221 .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
10222 .{ .type = .f80, .kind = .{ .frame = .call_frame } },
10223 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodx" } } },
10224 .{ .type = .f80, .kind = .{ .reg = .st7 } },
10225 .{ .type = .f80, .kind = .{ .reg = .rax } },
10226 .unused,
10227 .unused,
10228 .unused,
10229 .unused,
10230 },
10231 .dst_temps = .{.{ .reg = .st0 }},
10232 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
10233 .each = .{ .once = &.{
10234 .{ ._, .v_dqa, .mov, .tmp0x, .mem(.src0x), ._, ._ },
10235 .{ ._, .v_dqa, .mov, .mem(.tmp1x), .tmp0x, ._, ._ },
10236 .{ ._, .v_dqa, .mov, .tmp0x, .mem(.src1x), ._, ._ },
10237 .{ ._, .v_dqa, .mov, .memd(.tmp1x, 16), .tmp0x, ._, ._ },
10238 .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
10239 .{ ._, .f_, .ld, .dst0t, ._, ._, ._ },
10240 .{ ._, .f_p, .st, .mem(.tmp1t), ._, ._, ._ },
10241 .{ ._, ._, .movzx, .tmp4d, .memd(.tmp1w, 16 + 8), ._, ._ },
10242 .{ ._, ._, .@"and", .tmp4w, .sa(.src0, .add_smin), ._, ._ },
10243 .{ ._, ._, .xor, .tmp4w, .memd(.tmp1w, 8), ._, ._ },
10244 .{ ._, ._, .cmp, .mem(.tmp1q), .si(1), ._, ._ },
10245 .{ ._, ._, .sbb, .tmp4w, .sa(.src0, .add_smin), ._, ._ },
10246 .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
10247 .{ ._, .f_, .ld, .memd(.tmp1t, 16), ._, ._, ._ },
10248 .{ ._, .f_p, .add, ._, ._, ._, ._ },
10249 } },
10250 }, .{
10251 .required_features = .{ .@"64bit", .avx, .x87, null },
10252 .src_constraints = .{
10253 .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
10254 .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
10255 .any,
10256 },
10257 .patterns = &.{
10258 .{ .src = .{ .to_mem, .to_mem, .none } },
10259 },
10260 .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
10261 .extra_temps = .{
10262 .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
10263 .{ .type = .f80, .kind = .{ .frame = .call_frame } },
10264 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodx" } } },
10265 .{ .type = .f80, .kind = .{ .reg = .st7 } },
10266 .{ .type = .f80, .kind = .{ .reg = .rax } },
10267 .unused,
10268 .unused,
10269 .unused,
10270 .unused,
10271 },
10272 .dst_temps = .{.{ .reg = .st0 }},
10273 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
10274 .each = .{ .once = &.{
10275 .{ ._, .v_dqa, .mov, .tmp0x, .mem(.src0x), ._, ._ },
10276 .{ ._, .v_dqa, .mov, .mem(.tmp1x), .tmp0x, ._, ._ },
10277 .{ ._, .v_dqa, .mov, .tmp0x, .mem(.src1x), ._, ._ },
10278 .{ ._, .v_dqa, .mov, .memd(.tmp1x, 16), .tmp0x, ._, ._ },
10279 .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
10280 .{ ._, .f_, .ld, .dst0t, ._, ._, ._ },
10281 .{ ._, .f_p, .st, .mem(.tmp1t), ._, ._, ._ },
10282 .{ ._, ._, .mov, .tmp4d, .sa(.src0, .add_smin), ._, ._ },
10283 .{ ._, ._, .@"and", .tmp4w, .memd(.tmp1w, 16 + 8), ._, ._ },
10284 .{ ._, ._, .xor, .tmp4w, .memd(.tmp1w, 8), ._, ._ },
10285 .{ ._, ._, .cmp, .mem(.tmp1q), .si(1), ._, ._ },
10286 .{ ._, ._, .sbb, .tmp4w, .sa(.src0, .add_smin), ._, ._ },
10287 .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
10288 .{ ._, .f_, .ld, .memd(.tmp1t, 16), ._, ._, ._ },
10289 .{ ._, .f_p, .add, ._, ._, ._, ._ },
10290 } },
10291 }, .{
10292 .required_features = .{ .@"64bit", .sse2, .x87, .fast_imm16 },
10293 .src_constraints = .{
10294 .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
10295 .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
10296 .any,
10297 },
10298 .patterns = &.{
10299 .{ .src = .{ .to_mem, .to_mem, .none } },
10300 },
10301 .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
10302 .extra_temps = .{
10303 .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
10304 .{ .type = .f80, .kind = .{ .frame = .call_frame } },
10305 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodx" } } },
10306 .{ .type = .f80, .kind = .{ .reg = .st7 } },
10307 .{ .type = .f80, .kind = .{ .reg = .rax } },
10308 .unused,
10309 .unused,
10310 .unused,
10311 .unused,
10312 },
10313 .dst_temps = .{.{ .reg = .st0 }},
10314 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
10315 .each = .{ .once = &.{
10316 .{ ._, ._dqa, .mov, .tmp0x, .mem(.src0x), ._, ._ },
10317 .{ ._, ._dqa, .mov, .mem(.tmp1x), .tmp0x, ._, ._ },
10318 .{ ._, ._dqa, .mov, .tmp0x, .mem(.src1x), ._, ._ },
10319 .{ ._, ._dqa, .mov, .memd(.tmp1x, 16), .tmp0x, ._, ._ },
10320 .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
10321 .{ ._, .f_, .ld, .dst0t, ._, ._, ._ },
10322 .{ ._, .f_p, .st, .mem(.tmp1t), ._, ._, ._ },
10323 .{ ._, ._, .movzx, .tmp4d, .memd(.tmp1w, 16 + 8), ._, ._ },
10324 .{ ._, ._, .@"and", .tmp4w, .sa(.src0, .add_smin), ._, ._ },
10325 .{ ._, ._, .xor, .tmp4w, .memd(.tmp1w, 8), ._, ._ },
10326 .{ ._, ._, .cmp, .mem(.tmp1q), .si(1), ._, ._ },
10327 .{ ._, ._, .sbb, .tmp4w, .sa(.src0, .add_smin), ._, ._ },
10328 .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
10329 .{ ._, .f_, .ld, .memd(.tmp1t, 16), ._, ._, ._ },
10330 .{ ._, .f_p, .add, ._, ._, ._, ._ },
10331 } },
10332 }, .{
10333 .required_features = .{ .@"64bit", .sse2, .x87, null },
10334 .src_constraints = .{
10335 .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
10336 .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
10337 .any,
10338 },
10339 .patterns = &.{
10340 .{ .src = .{ .to_mem, .to_mem, .none } },
10341 },
10342 .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
10343 .extra_temps = .{
10344 .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
10345 .{ .type = .f80, .kind = .{ .frame = .call_frame } },
10346 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodx" } } },
10347 .{ .type = .f80, .kind = .{ .reg = .st7 } },
10348 .{ .type = .f80, .kind = .{ .reg = .rax } },
10349 .unused,
10350 .unused,
10351 .unused,
10352 .unused,
10353 },
10354 .dst_temps = .{.{ .reg = .st0 }},
10355 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
10356 .each = .{ .once = &.{
10357 .{ ._, ._dqa, .mov, .tmp0x, .mem(.src0x), ._, ._ },
10358 .{ ._, ._dqa, .mov, .mem(.tmp1x), .tmp0x, ._, ._ },
10359 .{ ._, ._dqa, .mov, .tmp0x, .mem(.src1x), ._, ._ },
10360 .{ ._, ._dqa, .mov, .memd(.tmp1x, 16), .tmp0x, ._, ._ },
10361 .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
10362 .{ ._, .f_, .ld, .dst0t, ._, ._, ._ },
10363 .{ ._, .f_p, .st, .mem(.tmp1t), ._, ._, ._ },
10364 .{ ._, ._, .mov, .tmp4d, .sa(.src0, .add_smin), ._, ._ },
10365 .{ ._, ._, .@"and", .tmp4w, .memd(.tmp1w, 16 + 8), ._, ._ },
10366 .{ ._, ._, .xor, .tmp4w, .memd(.tmp1w, 8), ._, ._ },
10367 .{ ._, ._, .cmp, .mem(.tmp1q), .si(1), ._, ._ },
10368 .{ ._, ._, .sbb, .tmp4w, .sa(.src0, .add_smin), ._, ._ },
10369 .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
10370 .{ ._, .f_, .ld, .memd(.tmp1t, 16), ._, ._, ._ },
10371 .{ ._, .f_p, .add, ._, ._, ._, ._ },
10372 } },
10373 }, .{
10374 .required_features = .{ .@"64bit", .sse, .x87, .fast_imm16 },
10375 .src_constraints = .{
10376 .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
10377 .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
10378 .any,
10379 },
10380 .patterns = &.{
10381 .{ .src = .{ .to_mem, .to_mem, .none } },
10382 },
10383 .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
10384 .extra_temps = .{
10385 .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
10386 .{ .type = .f80, .kind = .{ .frame = .call_frame } },
10387 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodx" } } },
10388 .{ .type = .f80, .kind = .{ .reg = .st7 } },
10389 .{ .type = .f80, .kind = .{ .reg = .rax } },
10390 .unused,
10391 .unused,
10392 .unused,
10393 .unused,
10394 },
10395 .dst_temps = .{.{ .reg = .st0 }},
10396 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
10397 .each = .{ .once = &.{
10398 .{ ._, ._ps, .mova, .tmp0x, .mem(.src0x), ._, ._ },
10399 .{ ._, ._ps, .mova, .mem(.tmp1x), .tmp0x, ._, ._ },
10400 .{ ._, ._ps, .mova, .tmp0x, .mem(.src1x), ._, ._ },
10401 .{ ._, ._ps, .mova, .memd(.tmp1x, 16), .tmp0x, ._, ._ },
10402 .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
10403 .{ ._, .f_, .ld, .dst0t, ._, ._, ._ },
10404 .{ ._, .f_p, .st, .mem(.tmp1t), ._, ._, ._ },
10405 .{ ._, ._, .movzx, .tmp4d, .memd(.tmp1w, 16 + 8), ._, ._ },
10406 .{ ._, ._, .@"and", .tmp4w, .sa(.src0, .add_smin), ._, ._ },
10407 .{ ._, ._, .xor, .tmp4w, .memd(.tmp1w, 8), ._, ._ },
10408 .{ ._, ._, .cmp, .mem(.tmp1q), .si(1), ._, ._ },
10409 .{ ._, ._, .sbb, .tmp4w, .sa(.src0, .add_smin), ._, ._ },
10410 .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
10411 .{ ._, .f_, .ld, .memd(.tmp1t, 16), ._, ._, ._ },
10412 .{ ._, .f_p, .add, ._, ._, ._, ._ },
10413 } },
10414 }, .{
10415 .required_features = .{ .@"64bit", .sse, .x87, null },
10416 .src_constraints = .{
10417 .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
10418 .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
10419 .any,
10420 },
10421 .patterns = &.{
10422 .{ .src = .{ .to_mem, .to_mem, .none } },
10423 },
10424 .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
10425 .extra_temps = .{
10426 .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
10427 .{ .type = .f80, .kind = .{ .frame = .call_frame } },
10428 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodx" } } },
10429 .{ .type = .f80, .kind = .{ .reg = .st7 } },
10430 .{ .type = .f80, .kind = .{ .reg = .rax } },
10431 .unused,
10432 .unused,
10433 .unused,
10434 .unused,
10435 },
10436 .dst_temps = .{.{ .reg = .st0 }},
10437 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
10438 .each = .{ .once = &.{
10439 .{ ._, ._ps, .mova, .tmp0x, .mem(.src0x), ._, ._ },
10440 .{ ._, ._ps, .mova, .mem(.tmp1x), .tmp0x, ._, ._ },
10441 .{ ._, ._ps, .mova, .tmp0x, .mem(.src1x), ._, ._ },
10442 .{ ._, ._ps, .mova, .memd(.tmp1x, 16), .tmp0x, ._, ._ },
10443 .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
10444 .{ ._, .f_, .ld, .dst0t, ._, ._, ._ },
10445 .{ ._, .f_p, .st, .mem(.tmp1t), ._, ._, ._ },
10446 .{ ._, ._, .mov, .tmp4d, .sa(.src0, .add_smin), ._, ._ },
10447 .{ ._, ._, .@"and", .tmp4w, .memd(.tmp1w, 16 + 8), ._, ._ },
10448 .{ ._, ._, .xor, .tmp4w, .memd(.tmp1w, 8), ._, ._ },
10449 .{ ._, ._, .cmp, .mem(.tmp1q), .si(1), ._, ._ },
10450 .{ ._, ._, .sbb, .tmp4w, .sa(.src0, .add_smin), ._, ._ },
10451 .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
10452 .{ ._, .f_, .ld, .memd(.tmp1t, 16), ._, ._, ._ },
10453 .{ ._, .f_p, .add, ._, ._, ._, ._ },
10454 } },
10455 }, .{
10456 .required_features = .{ .@"64bit", .avx, .x87, .fast_imm16 },
10457 .src_constraints = .{
10458 .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
10459 .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
10460 .any,
10461 },
10462 .patterns = &.{
10463 .{ .src = .{ .to_mem, .to_mem, .none } },
10464 },
10465 .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
10466 .extra_temps = .{
10467 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
10468 .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
10469 .{ .type = .f80, .kind = .{ .frame = .call_frame } },
10470 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodx" } } },
10471 .{ .type = .f80, .kind = .{ .reg = .st7 } },
10472 .{ .type = .f80, .kind = .{ .reg = .rax } },
10473 .unused,
10474 .unused,
10475 .unused,
10476 },
10477 .dst_temps = .{.mem},
10478 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
10479 .each = .{ .once = &.{
10480 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
10481 .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
10482 .{ ._, .v_dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ },
10483 .{ ._, .v_dqa, .mov, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
10484 .{ ._, .v_dqa, .mov, .memd(.tmp2x, 16), .tmp1x, ._, ._ },
10485 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
10486 .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
10487 .{ ._, .f_, .ld, .tmp4t, ._, ._, ._ },
10488 .{ ._, .f_p, .st, .mem(.tmp2t), ._, ._, ._ },
10489 .{ ._, ._, .movzx, .tmp5d, .memd(.tmp2w, 16 + 8), ._, ._ },
10490 .{ ._, ._, .@"and", .tmp5w, .sa(.src0, .add_smin), ._, ._ },
10491 .{ ._, ._, .xor, .tmp5w, .memd(.tmp2w, 8), ._, ._ },
10492 .{ ._, ._, .cmp, .mem(.tmp2q), .si(1), ._, ._ },
10493 .{ ._, ._, .sbb, .tmp5w, .sa(.src0, .add_smin), ._, ._ },
10494 .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
10495 .{ ._, .f_, .ld, .memd(.tmp2t, 16), ._, ._, ._ },
10496 .{ ._, .f_p, .add, ._, ._, ._, ._ },
10497 .{ .@"1:", .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
10498 .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
10499 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
10500 } },
10501 }, .{
10502 .required_features = .{ .@"64bit", .avx, .x87, null },
10503 .src_constraints = .{
10504 .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
10505 .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
10506 .any,
10507 },
10508 .patterns = &.{
10509 .{ .src = .{ .to_mem, .to_mem, .none } },
10510 },
10511 .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
10512 .extra_temps = .{
10513 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
10514 .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
10515 .{ .type = .f80, .kind = .{ .frame = .call_frame } },
10516 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodx" } } },
10517 .{ .type = .f80, .kind = .{ .reg = .st7 } },
10518 .{ .type = .f80, .kind = .{ .reg = .rax } },
10519 .unused,
10520 .unused,
10521 .unused,
10522 },
10523 .dst_temps = .{.mem},
10524 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
10525 .each = .{ .once = &.{
10526 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
10527 .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
10528 .{ ._, .v_dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ },
10529 .{ ._, .v_dqa, .mov, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
10530 .{ ._, .v_dqa, .mov, .memd(.tmp2x, 16), .tmp1x, ._, ._ },
10531 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
10532 .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
10533 .{ ._, .f_, .ld, .tmp4t, ._, ._, ._ },
10534 .{ ._, .f_p, .st, .mem(.tmp2t), ._, ._, ._ },
10535 .{ ._, ._, .mov, .tmp5d, .sa(.src0, .add_smin), ._, ._ },
10536 .{ ._, ._, .@"and", .tmp5w, .memd(.tmp2w, 16 + 8), ._, ._ },
10537 .{ ._, ._, .xor, .tmp5w, .memd(.tmp2w, 8), ._, ._ },
10538 .{ ._, ._, .cmp, .mem(.tmp2q), .si(1), ._, ._ },
10539 .{ ._, ._, .sbb, .tmp5w, .sa(.src0, .add_smin), ._, ._ },
10540 .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
10541 .{ ._, .f_, .ld, .memd(.tmp2t, 16), ._, ._, ._ },
10542 .{ ._, .f_p, .add, ._, ._, ._, ._ },
10543 .{ .@"1:", .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
10544 .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
10545 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
10546 } },
10547 }, .{
10548 .required_features = .{ .@"64bit", .sse2, .x87, .fast_imm16 },
10549 .src_constraints = .{
10550 .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
10551 .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
10552 .any,
10553 },
10554 .patterns = &.{
10555 .{ .src = .{ .to_mem, .to_mem, .none } },
10556 },
10557 .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
10558 .extra_temps = .{
10559 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
10560 .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
10561 .{ .type = .f80, .kind = .{ .frame = .call_frame } },
10562 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodx" } } },
10563 .{ .type = .f80, .kind = .{ .reg = .st7 } },
10564 .{ .type = .f80, .kind = .{ .reg = .rax } },
10565 .unused,
10566 .unused,
10567 .unused,
10568 },
10569 .dst_temps = .{.mem},
10570 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
10571 .each = .{ .once = &.{
10572 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
10573 .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
10574 .{ ._, ._dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ },
10575 .{ ._, ._dqa, .mov, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
10576 .{ ._, ._dqa, .mov, .memd(.tmp2x, 16), .tmp1x, ._, ._ },
10577 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
10578 .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
10579 .{ ._, .f_, .ld, .tmp4t, ._, ._, ._ },
10580 .{ ._, .f_p, .st, .mem(.tmp2t), ._, ._, ._ },
10581 .{ ._, ._, .movzx, .tmp5d, .memd(.tmp2w, 16 + 8), ._, ._ },
10582 .{ ._, ._, .@"and", .tmp5w, .sa(.src0, .add_smin), ._, ._ },
10583 .{ ._, ._, .xor, .tmp5w, .memd(.tmp2w, 8), ._, ._ },
10584 .{ ._, ._, .cmp, .mem(.tmp2q), .si(1), ._, ._ },
10585 .{ ._, ._, .sbb, .tmp5w, .sa(.src0, .add_smin), ._, ._ },
10586 .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
10587 .{ ._, .f_, .ld, .memd(.tmp2t, 16), ._, ._, ._ },
10588 .{ ._, .f_p, .add, ._, ._, ._, ._ },
10589 .{ .@"1:", .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
10590 .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
10591 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
10592 } },
10593 }, .{
10594 .required_features = .{ .@"64bit", .sse2, .x87, null },
10595 .src_constraints = .{
10596 .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
10597 .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
10598 .any,
10599 },
10600 .patterns = &.{
10601 .{ .src = .{ .to_mem, .to_mem, .none } },
10602 },
10603 .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
10604 .extra_temps = .{
10605 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
10606 .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
10607 .{ .type = .f80, .kind = .{ .frame = .call_frame } },
10608 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodx" } } },
10609 .{ .type = .f80, .kind = .{ .reg = .st7 } },
10610 .{ .type = .f80, .kind = .{ .reg = .rax } },
10611 .unused,
10612 .unused,
10613 .unused,
10614 },
10615 .dst_temps = .{.mem},
10616 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
10617 .each = .{ .once = &.{
10618 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
10619 .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
10620 .{ ._, ._dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ },
10621 .{ ._, ._dqa, .mov, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
10622 .{ ._, ._dqa, .mov, .memd(.tmp2x, 16), .tmp1x, ._, ._ },
10623 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
10624 .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
10625 .{ ._, .f_, .ld, .tmp4t, ._, ._, ._ },
10626 .{ ._, .f_p, .st, .mem(.tmp2t), ._, ._, ._ },
10627 .{ ._, ._, .mov, .tmp5d, .sa(.src0, .add_smin), ._, ._ },
10628 .{ ._, ._, .@"and", .tmp5w, .memd(.tmp2w, 16 + 8), ._, ._ },
10629 .{ ._, ._, .xor, .tmp5w, .memd(.tmp2w, 8), ._, ._ },
10630 .{ ._, ._, .cmp, .mem(.tmp2q), .si(1), ._, ._ },
10631 .{ ._, ._, .sbb, .tmp5w, .sa(.src0, .add_smin), ._, ._ },
10632 .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
10633 .{ ._, .f_, .ld, .memd(.tmp2t, 16), ._, ._, ._ },
10634 .{ ._, .f_p, .add, ._, ._, ._, ._ },
10635 .{ .@"1:", .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
10636 .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
10637 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
10638 } },
10639 }, .{
10640 .required_features = .{ .@"64bit", .sse, .x87, .fast_imm16 },
10641 .src_constraints = .{
10642 .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
10643 .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
10644 .any,
10645 },
10646 .patterns = &.{
10647 .{ .src = .{ .to_mem, .to_mem, .none } },
10648 },
10649 .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
10650 .extra_temps = .{
10651 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
10652 .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
10653 .{ .type = .f80, .kind = .{ .frame = .call_frame } },
10654 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodx" } } },
10655 .{ .type = .f80, .kind = .{ .reg = .st7 } },
10656 .{ .type = .f80, .kind = .{ .reg = .rax } },
10657 .unused,
10658 .unused,
10659 .unused,
10660 },
10661 .dst_temps = .{.mem},
10662 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
10663 .each = .{ .once = &.{
10664 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
10665 .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
10666 .{ ._, ._ps, .mova, .mem(.tmp2x), .tmp1x, ._, ._ },
10667 .{ ._, ._ps, .mova, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
10668 .{ ._, ._ps, .mova, .memd(.tmp2x, 16), .tmp1x, ._, ._ },
10669 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
10670 .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
10671 .{ ._, .f_, .ld, .tmp4t, ._, ._, ._ },
10672 .{ ._, .f_p, .st, .mem(.tmp2t), ._, ._, ._ },
10673 .{ ._, ._, .movzx, .tmp5d, .memd(.tmp2w, 16 + 8), ._, ._ },
10674 .{ ._, ._, .@"and", .tmp5w, .sa(.src0, .add_smin), ._, ._ },
10675 .{ ._, ._, .xor, .tmp5w, .memd(.tmp2w, 8), ._, ._ },
10676 .{ ._, ._, .cmp, .mem(.tmp2q), .si(1), ._, ._ },
10677 .{ ._, ._, .sbb, .tmp5w, .sa(.src0, .add_smin), ._, ._ },
10678 .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
10679 .{ ._, .f_, .ld, .memd(.tmp2t, 16), ._, ._, ._ },
10680 .{ ._, .f_p, .add, ._, ._, ._, ._ },
10681 .{ .@"1:", .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
10682 .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
10683 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
10684 } },
10685 }, .{
10686 .required_features = .{ .@"64bit", .sse, .x87, null },
10687 .src_constraints = .{
10688 .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
10689 .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
10690 .any,
10691 },
10692 .patterns = &.{
10693 .{ .src = .{ .to_mem, .to_mem, .none } },
10694 },
10695 .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
10696 .extra_temps = .{
10697 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
10698 .{ .type = .f80, .kind = .{ .reg = .xmm0 } },
10699 .{ .type = .f80, .kind = .{ .frame = .call_frame } },
10700 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodx" } } },
10701 .{ .type = .f80, .kind = .{ .reg = .st7 } },
10702 .{ .type = .f80, .kind = .{ .reg = .rax } },
10703 .unused,
10704 .unused,
10705 .unused,
10706 },
10707 .dst_temps = .{.mem},
10708 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
10709 .each = .{ .once = &.{
10710 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
10711 .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
10712 .{ ._, ._ps, .mova, .mem(.tmp2x), .tmp1x, ._, ._ },
10713 .{ ._, ._ps, .mova, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
10714 .{ ._, ._ps, .mova, .memd(.tmp2x, 16), .tmp1x, ._, ._ },
10715 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
10716 .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
10717 .{ ._, .f_, .ld, .tmp4t, ._, ._, ._ },
10718 .{ ._, .f_p, .st, .mem(.tmp2t), ._, ._, ._ },
10719 .{ ._, ._, .mov, .tmp5d, .sa(.src0, .add_smin), ._, ._ },
10720 .{ ._, ._, .@"and", .tmp5w, .memd(.tmp2w, 16 + 8), ._, ._ },
10721 .{ ._, ._, .xor, .tmp5w, .memd(.tmp2w, 8), ._, ._ },
10722 .{ ._, ._, .cmp, .mem(.tmp2q), .si(1), ._, ._ },
10723 .{ ._, ._, .sbb, .tmp5w, .sa(.src0, .add_smin), ._, ._ },
10724 .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
10725 .{ ._, .f_, .ld, .memd(.tmp2t, 16), ._, ._, ._ },
10726 .{ ._, .f_p, .add, ._, ._, ._, ._ },
10727 .{ .@"1:", .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
10728 .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
10729 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
10730 } },
10731 }, .{
10732 .required_features = .{ .@"64bit", .avx, null, null },
10733 .src_constraints = .{
10734 .{ .scalar_float = .{ .of = .xword, .is = .xword } },
10735 .{ .scalar_float = .{ .of = .xword, .is = .xword } },
10736 .any,
10737 },
10738 .patterns = &.{
10739 .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
10740 },
10741 .call_frame = .{ .alignment = .@"16" },
10742 .extra_temps = .{
10743 .{ .type = .f128, .kind = .mem },
10744 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmodq" } } },
10745 .{ .type = .f128, .kind = .{ .reg = .rcx } },
10746 .{ .type = .f128, .kind = .{ .reg = .rdx } },
10747 .{ .type = .f128, .kind = .{ .reg = .rax } },
10748 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__addtf3" } } },
10749 .unused,
10750 .unused,
10751 .unused,
10752 },
10753 .dst_temps = .{.{ .ref = .src0 }},
10754 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
10755 .each = .{ .once = &.{
10756 .{ ._, .v_dqa, .mov, .mem(.tmp0x), .src1x, ._, ._ },
10757 .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
10758 .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_smin), ._, ._ },
10759 .{ ._, .vp_q, .extr, .tmp3q, .dst0x, .ui(1), ._ },
10760 .{ ._, ._, .mov, .tmp4q, .tmp2q, ._, ._ },
10761 .{ ._, ._, .@"and", .tmp4q, .memd(.tmp0q, 8), ._, ._ },
10762 .{ ._, ._, .xor, .tmp4q, .tmp3q, ._, ._ },
10763 .{ ._, .v_q, .mov, .tmp3q, .dst0x, ._, ._ },
10764 .{ ._, ._, .cmp, .tmp3q, .si(1), ._, ._ },
10765 .{ ._, ._, .sbb, .tmp4q, .tmp2q, ._, ._ },
10766 .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
10767 .{ ._, .v_dqa, .mov, .src1x, .mem(.tmp0x), ._, ._ },
10768 .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
10769 } },
10770 }, .{
10771 .required_features = .{ .@"64bit", .sse4_1, null, null },
10772 .src_constraints = .{
10773 .{ .scalar_float = .{ .of = .xword, .is = .xword } },
10774 .{ .scalar_float = .{ .of = .xword, .is = .xword } },
10775 .any,
10776 },
10777 .patterns = &.{
10778 .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
10779 },
10780 .call_frame = .{ .alignment = .@"16" },
10781 .extra_temps = .{
10782 .{ .type = .f128, .kind = .mem },
10783 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmodq" } } },
10784 .{ .type = .f128, .kind = .{ .reg = .rcx } },
10785 .{ .type = .f128, .kind = .{ .reg = .rdx } },
10786 .{ .type = .f128, .kind = .{ .reg = .rax } },
10787 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__addtf3" } } },
10788 .unused,
10789 .unused,
10790 .unused,
10791 },
10792 .dst_temps = .{.{ .ref = .src0 }},
10793 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
10794 .each = .{ .once = &.{
10795 .{ ._, ._dqa, .mov, .mem(.tmp0x), .src1x, ._, ._ },
10796 .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
10797 .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_smin), ._, ._ },
10798 .{ ._, .p_q, .extr, .tmp3q, .dst0x, .ui(1), ._ },
10799 .{ ._, ._, .mov, .tmp4q, .tmp2q, ._, ._ },
10800 .{ ._, ._, .@"and", .tmp4q, .memd(.tmp0q, 8), ._, ._ },
10801 .{ ._, ._, .xor, .tmp4q, .tmp3q, ._, ._ },
10802 .{ ._, ._q, .mov, .tmp3q, .dst0x, ._, ._ },
10803 .{ ._, ._, .cmp, .tmp3q, .si(1), ._, ._ },
10804 .{ ._, ._, .sbb, .tmp4q, .tmp2q, ._, ._ },
10805 .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
10806 .{ ._, ._dqa, .mov, .src1x, .mem(.tmp0x), ._, ._ },
10807 .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
10808 } },
10809 }, .{
10810 .required_features = .{ .@"64bit", .sse2, null, null },
10811 .src_constraints = .{
10812 .{ .scalar_float = .{ .of = .xword, .is = .xword } },
10813 .{ .scalar_float = .{ .of = .xword, .is = .xword } },
10814 .any,
10815 },
10816 .patterns = &.{
10817 .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
10818 },
10819 .call_frame = .{ .alignment = .@"16" },
10820 .extra_temps = .{
10821 .{ .type = .f128, .kind = .mem },
10822 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmodq" } } },
10823 .{ .type = .f128, .kind = .{ .reg = .rcx } },
10824 .{ .type = .f128, .kind = .{ .reg = .rdx } },
10825 .{ .type = .f128, .kind = .{ .reg = .rax } },
10826 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__addtf3" } } },
10827 .unused,
10828 .unused,
10829 .unused,
10830 },
10831 .dst_temps = .{.{ .ref = .src0 }},
10832 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
10833 .each = .{ .once = &.{
10834 .{ ._, ._dqa, .mov, .mem(.tmp0x), .src1x, ._, ._ },
10835 .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
10836 .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_smin), ._, ._ },
10837 .{ ._, .p_d, .shuf, .src1x, .dst0x, .ui(0b11_10_11_10), ._ },
10838 .{ ._, ._q, .mov, .tmp3q, .src1x, ._, ._ },
10839 .{ ._, ._, .mov, .tmp4q, .tmp2q, ._, ._ },
10840 .{ ._, ._, .@"and", .tmp4q, .memd(.tmp0q, 8), ._, ._ },
10841 .{ ._, ._, .xor, .tmp4q, .tmp3q, ._, ._ },
10842 .{ ._, ._q, .mov, .tmp3q, .dst0x, ._, ._ },
10843 .{ ._, ._, .cmp, .tmp3q, .si(1), ._, ._ },
10844 .{ ._, ._, .sbb, .tmp4q, .tmp2q, ._, ._ },
10845 .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
10846 .{ ._, ._dqa, .mov, .src1x, .mem(.tmp0x), ._, ._ },
10847 .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
10848 } },
10849 }, .{
10850 .required_features = .{ .@"64bit", .sse, null, null },
10851 .src_constraints = .{
10852 .{ .scalar_float = .{ .of = .xword, .is = .xword } },
10853 .{ .scalar_float = .{ .of = .xword, .is = .xword } },
10854 .any,
10855 },
10856 .patterns = &.{
10857 .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
10858 },
10859 .call_frame = .{ .alignment = .@"16" },
10860 .extra_temps = .{
10861 .{ .type = .f128, .kind = .mem },
10862 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmodq" } } },
10863 .{ .type = .f128, .kind = .{ .reg = .rdx } },
10864 .{ .type = .f128, .kind = .mem },
10865 .{ .type = .f128, .kind = .{ .reg = .rax } },
10866 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__addtf3" } } },
10867 .unused,
10868 .unused,
10869 .unused,
10870 },
10871 .dst_temps = .{.{ .ref = .src0 }},
10872 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
10873 .each = .{ .once = &.{
10874 .{ ._, ._ps, .mova, .mem(.tmp0x), .src1x, ._, ._ },
10875 .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
10876 .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_smin), ._, ._ },
10877 .{ ._, ._ps, .mova, .mem(.tmp3x), .dst0x, ._, ._ },
10878 .{ ._, ._, .mov, .tmp4q, .tmp2q, ._, ._ },
10879 .{ ._, ._, .@"and", .tmp4q, .memd(.tmp0q, 8), ._, ._ },
10880 .{ ._, ._, .xor, .tmp4q, .memd(.tmp3q, 8), ._, ._ },
10881 .{ ._, ._, .cmp, .mem(.tmp3q), .si(1), ._, ._ },
10882 .{ ._, ._, .sbb, .tmp4q, .tmp2q, ._, ._ },
10883 .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
10884 .{ ._, ._ps, .mova, .src1x, .mem(.tmp0x), ._, ._ },
10885 .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
10886 } },
10887 }, .{
10888 .required_features = .{ .@"64bit", .avx, null, null },
10889 .src_constraints = .{
10890 .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
10891 .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
10892 .any,
10893 },
10894 .patterns = &.{
10895 .{ .src = .{ .to_mem, .to_mem, .none } },
10896 },
10897 .call_frame = .{ .alignment = .@"16" },
10898 .extra_temps = .{
10899 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
10900 .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
10901 .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
10902 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmodq" } } },
10903 .{ .type = .f128, .kind = .{ .reg = .rcx } },
10904 .{ .type = .f128, .kind = .{ .reg = .rdx } },
10905 .{ .type = .f128, .kind = .{ .reg = .rax } },
10906 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__addtf3" } } },
10907 .unused,
10908 },
10909 .dst_temps = .{.mem},
10910 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
10911 .each = .{ .once = &.{
10912 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
10913 .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
10914 .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
10915 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
10916 .{ ._, ._, .mov, .tmp4q, .ua(.src0, .add_smin), ._, ._ },
10917 .{ ._, .vp_q, .extr, .tmp5q, .tmp1x, .ui(1), ._ },
10918 .{ ._, ._, .mov, .tmp6q, .tmp4q, ._, ._ },
10919 .{ ._, ._, .@"and", .tmp6q, .memiad(.src1q, .tmp0, .add_unaligned_size, 8), ._, ._ },
10920 .{ ._, ._, .xor, .tmp6q, .tmp5q, ._, ._ },
10921 .{ ._, .v_q, .mov, .tmp5q, .tmp1x, ._, ._ },
10922 .{ ._, ._, .cmp, .tmp5q, .si(1), ._, ._ },
10923 .{ ._, ._, .sbb, .tmp6q, .tmp4q, ._, ._ },
10924 .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
10925 .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
10926 .{ ._, ._, .call, .tmp7d, ._, ._, ._ },
10927 .{ .@"1:", .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
10928 .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
10929 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
10930 } },
10931 }, .{
10932 .required_features = .{ .@"64bit", .sse4_1, null, null },
10933 .src_constraints = .{
10934 .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
10935 .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
10936 .any,
10937 },
10938 .patterns = &.{
10939 .{ .src = .{ .to_mem, .to_mem, .none } },
10940 },
10941 .call_frame = .{ .alignment = .@"16" },
10942 .extra_temps = .{
10943 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
10944 .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
10945 .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
10946 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmodq" } } },
10947 .{ .type = .f128, .kind = .{ .reg = .rcx } },
10948 .{ .type = .f128, .kind = .{ .reg = .rdx } },
10949 .{ .type = .f128, .kind = .{ .reg = .rax } },
10950 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__addtf3" } } },
10951 .unused,
10952 },
10953 .dst_temps = .{.mem},
10954 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
10955 .each = .{ .once = &.{
10956 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
10957 .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
10958 .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
10959 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
10960 .{ ._, ._, .mov, .tmp4q, .ua(.src0, .add_smin), ._, ._ },
10961 .{ ._, .p_q, .extr, .tmp5q, .tmp1x, .ui(1), ._ },
10962 .{ ._, ._, .mov, .tmp6q, .tmp4q, ._, ._ },
10963 .{ ._, ._, .@"and", .tmp6q, .memiad(.src1q, .tmp0, .add_unaligned_size, 8), ._, ._ },
10964 .{ ._, ._, .xor, .tmp6q, .tmp5q, ._, ._ },
10965 .{ ._, ._q, .mov, .tmp5q, .tmp1x, ._, ._ },
10966 .{ ._, ._, .cmp, .tmp5q, .si(1), ._, ._ },
10967 .{ ._, ._, .sbb, .tmp6q, .tmp4q, ._, ._ },
10968 .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
10969 .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
10970 .{ ._, ._, .call, .tmp7d, ._, ._, ._ },
10971 .{ .@"1:", ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
10972 .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
10973 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
10974 } },
10975 }, .{
10976 .required_features = .{ .@"64bit", .sse2, null, null },
10977 .src_constraints = .{
10978 .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
10979 .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
10980 .any,
10981 },
10982 .patterns = &.{
10983 .{ .src = .{ .to_mem, .to_mem, .none } },
10984 },
10985 .call_frame = .{ .alignment = .@"16" },
10986 .extra_temps = .{
10987 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
10988 .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
10989 .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
10990 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmodq" } } },
10991 .{ .type = .f128, .kind = .{ .reg = .rcx } },
10992 .{ .type = .f128, .kind = .{ .reg = .rdx } },
10993 .{ .type = .f128, .kind = .{ .reg = .rax } },
10994 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__addtf3" } } },
10995 .unused,
10996 },
10997 .dst_temps = .{.mem},
10998 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
10999 .each = .{ .once = &.{
11000 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
11001 .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
11002 .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
11003 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
11004 .{ ._, ._, .mov, .tmp4q, .ua(.src0, .add_smin), ._, ._ },
11005 .{ ._, .p_d, .shuf, .tmp2x, .tmp1x, .ui(0b11_10_11_10), ._ },
11006 .{ ._, ._q, .mov, .tmp5q, .tmp2x, ._, ._ },
11007 .{ ._, ._, .mov, .tmp6q, .tmp4q, ._, ._ },
11008 .{ ._, ._, .@"and", .tmp6q, .memiad(.src1q, .tmp0, .add_unaligned_size, 8), ._, ._ },
11009 .{ ._, ._, .xor, .tmp6q, .tmp5q, ._, ._ },
11010 .{ ._, ._q, .mov, .tmp5q, .tmp1x, ._, ._ },
11011 .{ ._, ._, .cmp, .tmp5q, .si(1), ._, ._ },
11012 .{ ._, ._, .sbb, .tmp6q, .tmp4q, ._, ._ },
11013 .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
11014 .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
11015 .{ ._, ._, .call, .tmp7d, ._, ._, ._ },
11016 .{ .@"1:", ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
11017 .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
11018 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
11019 } },
11020 }, .{
11021 .required_features = .{ .@"64bit", .sse, null, null },
11022 .src_constraints = .{
11023 .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
11024 .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
11025 .any,
11026 },
11027 .patterns = &.{
11028 .{ .src = .{ .to_mem, .to_mem, .none } },
11029 },
11030 .call_frame = .{ .alignment = .@"16" },
11031 .extra_temps = .{
11032 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
11033 .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
11034 .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
11035 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmodq" } } },
11036 .{ .type = .f128, .kind = .{ .reg = .rdx } },
11037 .{ .type = .f128, .kind = .mem },
11038 .{ .type = .f128, .kind = .{ .reg = .rax } },
11039 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__addtf3" } } },
11040 .unused,
11041 },
11042 .dst_temps = .{.mem},
11043 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
11044 .each = .{ .once = &.{
11045 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
11046 .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
11047 .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
11048 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
11049 .{ ._, ._, .mov, .tmp4q, .ua(.src0, .add_smin), ._, ._ },
11050 .{ ._, ._ps, .mova, .mem(.tmp5x), .tmp1x, ._, ._ },
11051 .{ ._, ._, .mov, .tmp6q, .tmp4q, ._, ._ },
11052 .{ ._, ._, .@"and", .tmp6q, .memiad(.src1q, .tmp0, .add_unaligned_size, 8), ._, ._ },
11053 .{ ._, ._, .xor, .tmp6q, .memd(.tmp5q, 8), ._, ._ },
11054 .{ ._, ._, .cmp, .mem(.tmp5q), .si(1), ._, ._ },
11055 .{ ._, ._, .sbb, .tmp6q, .tmp4q, ._, ._ },
11056 .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
11057 .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
11058 .{ ._, ._, .call, .tmp7d, ._, ._, ._ },
11059 .{ .@"1:", ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
11060 .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
11061 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
11062 } },
11063 } }) catch |err| switch (err) {
11064 error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{
11065 @tagName(air_tag),
11066 cg.typeOf(bin_op.lhs).fmt(pt),
11067 ops[0].tracking(cg),
11068 ops[1].tracking(cg),
11069 }),
11070 else => |e| return e,
11071 };
11072 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
11073 },
8986 .ptr_add => |air_tag| if (use_old) try cg.airPtrArithmetic(inst, air_tag) else {11074 .ptr_add => |air_tag| if (use_old) try cg.airPtrArithmetic(inst, air_tag) else {
8987 const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;11075 const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
8988 const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data;11076 const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data;
...@@ -68831,6 +70919,7 @@ const Select = struct {...@@ -68831,6 +70919,7 @@ const Select = struct {
68831 const sub_src0_elem_size_times_src1: Adjust = .{ .sign = .neg, .lhs = .src0_elem_size_times_src1, .op = .mul, .rhs = .@"1" };70919 const sub_src0_elem_size_times_src1: Adjust = .{ .sign = .neg, .lhs = .src0_elem_size_times_src1, .op = .mul, .rhs = .@"1" };
68832 const add_log2_src0_elem_size: Adjust = .{ .sign = .pos, .lhs = .log2_src0_elem_size, .op = .mul, .rhs = .@"1" };70920 const add_log2_src0_elem_size: Adjust = .{ .sign = .pos, .lhs = .log2_src0_elem_size, .op = .mul, .rhs = .@"1" };
68833 const add_elem_limbs: Adjust = .{ .sign = .pos, .lhs = .elem_limbs, .op = .mul, .rhs = .@"1" };70921 const add_elem_limbs: Adjust = .{ .sign = .pos, .lhs = .elem_limbs, .op = .mul, .rhs = .@"1" };
70922 const add_smin: Adjust = .{ .sign = .pos, .lhs = .smin, .op = .mul, .rhs = .@"1" };
68834 const add_umax: Adjust = .{ .sign = .pos, .lhs = .umax, .op = .mul, .rhs = .@"1" };70923 const add_umax: Adjust = .{ .sign = .pos, .lhs = .umax, .op = .mul, .rhs = .@"1" };
68835 };70924 };
68836 const Ref = enum(u4) {70925 const Ref = enum(u4) {
test/behavior/x86_64/math.zig+39
...@@ -11479,6 +11479,45 @@ test rem {...@@ -11479,6 +11479,45 @@ test rem {
11479 try test_rem.testFloatVectors();11479 try test_rem.testFloatVectors();
11480}11480}
1148111481
11482inline fn mod(comptime Type: type, lhs: Type, rhs: Type) Type {
11483 if (@inComptime()) {
11484 const scalarMod = struct {
11485 fn scalarMod(scalar_lhs: Scalar(Type), scalar_rhs: Scalar(Type)) Scalar(Type) {
11486 // workaround https://github.com/ziglang/zig/issues/22748
11487 if (scalar_rhs == 0) return nan(Scalar(Type));
11488 const scalar_rem = @rem(scalar_lhs, scalar_rhs);
11489 return if (scalar_rem == 0 or math.signbit(scalar_rem) == math.signbit(scalar_rhs)) scalar_rem else scalar_rem + scalar_rhs;
11490 }
11491 }.scalarMod;
11492 // workaround https://github.com/ziglang/zig/issues/22748
11493 switch (@typeInfo(Type)) {
11494 // workaround llvm backend bugs
11495 // TODO: else => return if (rhs != 0) @mod(lhs, rhs) else nan(Type),
11496 // TODO: .vector => |info| {
11497 // TODO: var res: Type = undefined;
11498 // TODO: inline for (0..info.len) |i| res[i] = if (rhs[i] != 0) @mod(lhs[i], rhs[i]) else nan(Scalar(Type));
11499 // TODO: return res;
11500 // TODO: },
11501 else => return scalarMod(lhs, rhs),
11502 .vector => |info| {
11503 var res: Type = undefined;
11504 inline for (0..info.len) |i| res[i] = scalarMod(lhs[i], rhs[i]);
11505 return res;
11506 },
11507 }
11508 }
11509 // workaround https://github.com/ziglang/zig/issues/22748
11510 // TODO: return @mod(lhs, rhs);
11511 var rt_rhs = rhs;
11512 _ = &rt_rhs;
11513 return @mod(lhs, rt_rhs);
11514}
11515test mod {
11516 const test_mod = binary(mod, .{});
11517 try test_mod.testFloats();
11518 try test_mod.testFloatVectors();
11519}
11520
11482inline fn bitNot(comptime Type: type, rhs: Type) @TypeOf(~rhs) {11521inline fn bitNot(comptime Type: type, rhs: Type) @TypeOf(~rhs) {
11483 return ~rhs;11522 return ~rhs;
11484}11523}