| ... | ... | @@ -2393,7 +2393,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2393 | 2393 | } |
| 2394 | 2394 | |
| 2395 | 2395 | fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2396 | | @setEvalBranchQuota(3_600); |
| 2396 | @setEvalBranchQuota(3_900); |
| 2397 | 2397 | const pt = cg.pt; |
| 2398 | 2398 | const zcu = pt.zcu; |
| 2399 | 2399 | const ip = &zcu.intern_pool; |
| ... | ... | @@ -2805,10 +2805,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2805 | 2805 | } |
| 2806 | 2806 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| 2807 | 2807 | }, |
| 2808 | | .max => |air_tag| if (use_old) try cg.airBinOp(inst, air_tag) else fallback: { |
| 2808 | .max => |air_tag| if (use_old) try cg.airBinOp(inst, air_tag) else { |
| 2809 | 2809 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; |
| 2810 | | const ty = cg.typeOf(bin_op.lhs); |
| 2811 | | if (ty.isVector(zcu) and cg.floatBits(ty.childType(zcu)) != null) break :fallback try cg.airBinOp(inst, air_tag); |
| 2812 | 2810 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 2813 | 2811 | var res: [1]Temp = undefined; |
| 2814 | 2812 | cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ |
| ... | ... | @@ -4510,7 +4508,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4510 | 4508 | }, |
| 4511 | 4509 | .extra_temps = .{ |
| 4512 | 4510 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 4513 | | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 4511 | .{ .type = .vector_4_u32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 4514 | 4512 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 4515 | 4513 | .unused, |
| 4516 | 4514 | .unused, |
| ... | ... | @@ -4647,7 +4645,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4647 | 4645 | }, |
| 4648 | 4646 | .extra_temps = .{ |
| 4649 | 4647 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4650 | | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 4648 | .{ .type = .vector_4_u32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 4651 | 4649 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 4652 | 4650 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 4653 | 4651 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| ... | ... | @@ -4967,7 +4965,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4967 | 4965 | }, |
| 4968 | 4966 | .extra_temps = .{ |
| 4969 | 4967 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 4970 | | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 4968 | .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 4971 | 4969 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 4972 | 4970 | .unused, |
| 4973 | 4971 | .unused, |
| ... | ... | @@ -4998,7 +4996,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4998 | 4996 | }, |
| 4999 | 4997 | .extra_temps = .{ |
| 5000 | 4998 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 5001 | | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 4999 | .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 5002 | 5000 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 5003 | 5001 | .{ .type = .vector_2_u64, .kind = .{ .reg = .xmm0 } }, |
| 5004 | 5002 | .unused, |
| ... | ... | @@ -5030,7 +5028,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5030 | 5028 | }, |
| 5031 | 5029 | .extra_temps = .{ |
| 5032 | 5030 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 5033 | | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 5031 | .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 5034 | 5032 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 5035 | 5033 | .unused, |
| 5036 | 5034 | .unused, |
| ... | ... | @@ -5059,7 +5057,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5059 | 5057 | }, |
| 5060 | 5058 | .extra_temps = .{ |
| 5061 | 5059 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5062 | | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 5060 | .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 5063 | 5061 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 5064 | 5062 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 5065 | 5063 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| ... | ... | @@ -5095,7 +5093,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5095 | 5093 | }, |
| 5096 | 5094 | .extra_temps = .{ |
| 5097 | 5095 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5098 | | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 5096 | .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 5099 | 5097 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 5100 | 5098 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 5101 | 5099 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| ... | ... | @@ -5131,7 +5129,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5131 | 5129 | }, |
| 5132 | 5130 | .extra_temps = .{ |
| 5133 | 5131 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5134 | | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 5132 | .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 5135 | 5133 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 5136 | 5134 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 5137 | 5135 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| ... | ... | @@ -5383,8 +5381,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5383 | 5381 | .{ .src = .{ .to_sse, .to_sse } }, |
| 5384 | 5382 | }, |
| 5385 | 5383 | .extra_temps = .{ |
| 5386 | | .{ .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 5387 | | .{ .kind = .{ .rc = .sse } }, |
| 5384 | .{ .type = .f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 5385 | .{ .type = .f16, .kind = .{ .rc = .sse } }, |
| 5388 | 5386 | .unused, |
| 5389 | 5387 | .unused, |
| 5390 | 5388 | .unused, |
| ... | ... | @@ -5395,12 +5393,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5395 | 5393 | }, |
| 5396 | 5394 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 5397 | 5395 | .each = .{ .once = &.{ |
| 5398 | | .{ ._, .v_ps, .cvtph2, .dst0x, .src0x, ._, ._ }, |
| 5399 | | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1x, ._, ._ }, |
| 5396 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 5397 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 5400 | 5398 | .{ ._, .v_ss, .cmp, .tmp1x, .dst0x, .dst0x, .vp(.unord) }, |
| 5401 | 5399 | .{ ._, .v_ss, .max, .dst0x, .tmp0x, .dst0x, ._ }, |
| 5402 | 5400 | .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp0x, .tmp1x }, |
| 5403 | | .{ ._, .v_, .cvtps2ph, .dst0x, .dst0x, .rm(.{}), ._ }, |
| 5401 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 5404 | 5402 | } }, |
| 5405 | 5403 | }, .{ |
| 5406 | 5404 | .required_features = .{ .sse, null, null, null }, |
| ... | ... | @@ -5423,11 +5421,248 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5423 | 5421 | .unused, |
| 5424 | 5422 | .unused, |
| 5425 | 5423 | }, |
| 5426 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5427 | 5424 | .dst_temps = .{.{ .ref = .src0 }}, |
| 5425 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5428 | 5426 | .each = .{ .once = &.{ |
| 5429 | 5427 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 5430 | 5428 | } }, |
| 5429 | }, .{ |
| 5430 | .required_features = .{ .f16c, null, null, null }, |
| 5431 | .src_constraints = .{ |
| 5432 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 5433 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 5434 | }, |
| 5435 | .patterns = &.{ |
| 5436 | .{ .src = .{ .mem, .mem } }, |
| 5437 | .{ .src = .{ .to_sse, .mem } }, |
| 5438 | .{ .src = .{ .mem, .to_sse } }, |
| 5439 | .{ .src = .{ .to_sse, .to_sse } }, |
| 5440 | }, |
| 5441 | .extra_temps = .{ |
| 5442 | .{ .type = .vector_4_f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 5443 | .{ .type = .vector_4_f16, .kind = .{ .rc = .sse } }, |
| 5444 | .unused, |
| 5445 | .unused, |
| 5446 | .unused, |
| 5447 | .unused, |
| 5448 | .unused, |
| 5449 | .unused, |
| 5450 | .unused, |
| 5451 | }, |
| 5452 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 5453 | .each = .{ .once = &.{ |
| 5454 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 5455 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 5456 | .{ ._, .v_ps, .cmp, .tmp1x, .dst0x, .dst0x, .vp(.unord) }, |
| 5457 | .{ ._, .v_ps, .max, .dst0x, .tmp0x, .dst0x, ._ }, |
| 5458 | .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp0x, .tmp1x }, |
| 5459 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 5460 | } }, |
| 5461 | }, .{ |
| 5462 | .required_features = .{ .f16c, null, null, null }, |
| 5463 | .src_constraints = .{ |
| 5464 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 5465 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 5466 | }, |
| 5467 | .patterns = &.{ |
| 5468 | .{ .src = .{ .mem, .mem } }, |
| 5469 | .{ .src = .{ .to_sse, .mem } }, |
| 5470 | .{ .src = .{ .mem, .to_sse } }, |
| 5471 | .{ .src = .{ .to_sse, .to_sse } }, |
| 5472 | }, |
| 5473 | .extra_temps = .{ |
| 5474 | .{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 5475 | .{ .type = .vector_8_f16, .kind = .{ .rc = .sse } }, |
| 5476 | .unused, |
| 5477 | .unused, |
| 5478 | .unused, |
| 5479 | .unused, |
| 5480 | .unused, |
| 5481 | .unused, |
| 5482 | .unused, |
| 5483 | }, |
| 5484 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 5485 | .each = .{ .once = &.{ |
| 5486 | .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ }, |
| 5487 | .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ }, |
| 5488 | .{ ._, .v_ps, .cmp, .tmp1y, .dst0y, .dst0y, .vp(.unord) }, |
| 5489 | .{ ._, .v_ps, .max, .dst0y, .tmp0y, .dst0y, ._ }, |
| 5490 | .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp0y, .tmp1y }, |
| 5491 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0y, .rm(.{}), ._ }, |
| 5492 | } }, |
| 5493 | }, .{ |
| 5494 | .required_features = .{ .f16c, null, null, null }, |
| 5495 | .src_constraints = .{ |
| 5496 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 5497 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 5498 | }, |
| 5499 | .patterns = &.{ |
| 5500 | .{ .src = .{ .to_mem, .to_mem } }, |
| 5501 | }, |
| 5502 | .extra_temps = .{ |
| 5503 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5504 | .{ .type = .vector_8_f16, .kind = .{ .rc = .sse } }, |
| 5505 | .{ .type = .vector_8_f16, .kind = .{ .rc = .sse } }, |
| 5506 | .{ .type = .vector_8_f16, .kind = .{ .rc = .sse } }, |
| 5507 | .unused, |
| 5508 | .unused, |
| 5509 | .unused, |
| 5510 | .unused, |
| 5511 | .unused, |
| 5512 | }, |
| 5513 | .dst_temps = .{.mem}, |
| 5514 | .clobbers = .{ .eflags = true }, |
| 5515 | .each = .{ .once = &.{ |
| 5516 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 5517 | .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 5518 | .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 5519 | .{ ._, .v_ps, .cmp, .tmp3y, .tmp1y, .tmp1y, .vp(.unord) }, |
| 5520 | .{ ._, .v_ps, .max, .tmp1y, .tmp2y, .tmp1y, ._ }, |
| 5521 | .{ ._, .v_ps, .blendv, .tmp1y, .tmp1y, .tmp2y, .tmp3y }, |
| 5522 | .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_size), .tmp1y, .rm(.{}), ._ }, |
| 5523 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 5524 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5525 | } }, |
| 5526 | }, .{ |
| 5527 | .required_features = .{ .avx, null, null, null }, |
| 5528 | .src_constraints = .{ |
| 5529 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 5530 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 5531 | }, |
| 5532 | .patterns = &.{ |
| 5533 | .{ .src = .{ .to_mem, .to_mem } }, |
| 5534 | }, |
| 5535 | .call_frame = .{ .alignment = .@"16" }, |
| 5536 | .extra_temps = .{ |
| 5537 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5538 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 5539 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 5540 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmaxh" } } }, |
| 5541 | .unused, |
| 5542 | .unused, |
| 5543 | .unused, |
| 5544 | .unused, |
| 5545 | .unused, |
| 5546 | }, |
| 5547 | .dst_temps = .{.mem}, |
| 5548 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5549 | .each = .{ .once = &.{ |
| 5550 | .{ ._, ._, .mov, .tmp0q, .sa(.src0, .sub_size), ._, ._ }, |
| 5551 | .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, |
| 5552 | .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_size), .ui(0) }, |
| 5553 | .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_size), .ui(0) }, |
| 5554 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 5555 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_size), .tmp1x, .ui(0), ._ }, |
| 5556 | .{ ._, ._, .add, .tmp0q, .si(2), ._, ._ }, |
| 5557 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5558 | } }, |
| 5559 | }, .{ |
| 5560 | .required_features = .{ .sse4_1, null, null, null }, |
| 5561 | .src_constraints = .{ |
| 5562 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 5563 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 5564 | }, |
| 5565 | .patterns = &.{ |
| 5566 | .{ .src = .{ .to_mem, .to_mem } }, |
| 5567 | }, |
| 5568 | .call_frame = .{ .alignment = .@"16" }, |
| 5569 | .extra_temps = .{ |
| 5570 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5571 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 5572 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 5573 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmaxh" } } }, |
| 5574 | .unused, |
| 5575 | .unused, |
| 5576 | .unused, |
| 5577 | .unused, |
| 5578 | .unused, |
| 5579 | }, |
| 5580 | .dst_temps = .{.mem}, |
| 5581 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5582 | .each = .{ .once = &.{ |
| 5583 | .{ ._, ._, .mov, .tmp0q, .sa(.src0, .sub_size), ._, ._ }, |
| 5584 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 5585 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 5586 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_size), .ui(0), ._ }, |
| 5587 | .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_size), .ui(0), ._ }, |
| 5588 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 5589 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_size), .tmp1x, .ui(0), ._ }, |
| 5590 | .{ ._, ._, .add, .tmp0q, .si(2), ._, ._ }, |
| 5591 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5592 | } }, |
| 5593 | }, .{ |
| 5594 | .required_features = .{ .sse2, null, null, null }, |
| 5595 | .src_constraints = .{ |
| 5596 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 5597 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 5598 | }, |
| 5599 | .patterns = &.{ |
| 5600 | .{ .src = .{ .to_mem, .to_mem } }, |
| 5601 | }, |
| 5602 | .call_frame = .{ .alignment = .@"16" }, |
| 5603 | .extra_temps = .{ |
| 5604 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5605 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 5606 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 5607 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmaxh" } } }, |
| 5608 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 5609 | .unused, |
| 5610 | .unused, |
| 5611 | .unused, |
| 5612 | .unused, |
| 5613 | }, |
| 5614 | .dst_temps = .{.mem}, |
| 5615 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5616 | .each = .{ .once = &.{ |
| 5617 | .{ ._, ._, .mov, .tmp0q, .sa(.src0, .sub_size), ._, ._ }, |
| 5618 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 5619 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 5620 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_size), .ui(0), ._ }, |
| 5621 | .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_size), .ui(0), ._ }, |
| 5622 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 5623 | .{ ._, .p_w, .extr, .tmp4d, .tmp1x, .ui(0), ._ }, |
| 5624 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp4w, ._, ._ }, |
| 5625 | .{ ._, ._, .add, .tmp0q, .si(2), ._, ._ }, |
| 5626 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5627 | } }, |
| 5628 | }, .{ |
| 5629 | .required_features = .{ .sse, null, null, null }, |
| 5630 | .src_constraints = .{ |
| 5631 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 5632 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 5633 | }, |
| 5634 | .patterns = &.{ |
| 5635 | .{ .src = .{ .to_mem, .to_mem } }, |
| 5636 | }, |
| 5637 | .call_frame = .{ .alignment = .@"16" }, |
| 5638 | .extra_temps = .{ |
| 5639 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5640 | .{ .type = .f16, .kind = .{ .reg = .eax } }, |
| 5641 | .{ .type = .f32, .kind = .mem }, |
| 5642 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 5643 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 5644 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmaxh" } } }, |
| 5645 | .unused, |
| 5646 | .unused, |
| 5647 | .unused, |
| 5648 | }, |
| 5649 | .dst_temps = .{.mem}, |
| 5650 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5651 | .each = .{ .once = &.{ |
| 5652 | .{ ._, ._, .mov, .tmp0q, .sa(.src0, .sub_size), ._, ._ }, |
| 5653 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_size), ._, ._ }, |
| 5654 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 5655 | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, |
| 5656 | .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_size), ._, ._ }, |
| 5657 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 5658 | .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ }, |
| 5659 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 5660 | .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ }, |
| 5661 | .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ }, |
| 5662 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp1w, ._, ._ }, |
| 5663 | .{ ._, ._, .add, .tmp0q, .si(2), ._, ._ }, |
| 5664 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5665 | } }, |
| 5431 | 5666 | }, .{ |
| 5432 | 5667 | .required_features = .{ .avx, null, null, null }, |
| 5433 | 5668 | .src_constraints = .{ |
| ... | ... | @@ -5438,7 +5673,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5438 | 5673 | .{ .src = .{ .to_sse, .to_sse } }, |
| 5439 | 5674 | }, |
| 5440 | 5675 | .extra_temps = .{ |
| 5441 | | .{ .kind = .{ .rc = .sse } }, |
| 5676 | .{ .type = .f32, .kind = .{ .rc = .sse } }, |
| 5442 | 5677 | .unused, |
| 5443 | 5678 | .unused, |
| 5444 | 5679 | .unused, |
| ... | ... | @@ -5499,6 +5734,210 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5499 | 5734 | .{ ._, ._ps, .andn, .dst0x, .src1x, ._, ._ }, |
| 5500 | 5735 | .{ ._, ._ps, .@"or", .dst0x, .tmp0x, ._, ._ }, |
| 5501 | 5736 | } }, |
| 5737 | }, .{ |
| 5738 | .required_features = .{ .avx, null, null, null }, |
| 5739 | .src_constraints = .{ |
| 5740 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 5741 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 5742 | }, |
| 5743 | .patterns = &.{ |
| 5744 | .{ .src = .{ .to_sse, .to_sse } }, |
| 5745 | }, |
| 5746 | .extra_temps = .{ |
| 5747 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 5748 | .unused, |
| 5749 | .unused, |
| 5750 | .unused, |
| 5751 | .unused, |
| 5752 | .unused, |
| 5753 | .unused, |
| 5754 | .unused, |
| 5755 | .unused, |
| 5756 | }, |
| 5757 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 5758 | .each = .{ .once = &.{ |
| 5759 | .{ ._, .v_ps, .cmp, .tmp0x, .src0x, .src0x, .vp(.unord) }, |
| 5760 | .{ ._, .v_ps, .max, .dst0x, .src1x, .src0x, ._ }, |
| 5761 | .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .src1x, .tmp0x }, |
| 5762 | } }, |
| 5763 | }, .{ |
| 5764 | .required_features = .{ .sse4_1, null, null, null }, |
| 5765 | .src_constraints = .{ |
| 5766 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 5767 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 5768 | }, |
| 5769 | .patterns = &.{ |
| 5770 | .{ .src = .{ .{ .to_reg = .xmm0 }, .mem } }, |
| 5771 | .{ .src = .{ .mem, .{ .to_reg = .xmm0 } }, .commute = .{ 0, 1 } }, |
| 5772 | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse } }, |
| 5773 | }, |
| 5774 | .dst_temps = .{.{ .rc = .sse }}, |
| 5775 | .each = .{ .once = &.{ |
| 5776 | .{ ._, ._ps, .mova, .dst0x, .src1x, ._, ._ }, |
| 5777 | .{ ._, ._ps, .max, .dst0x, .src0x, ._, ._ }, |
| 5778 | .{ ._, ._ps, .cmp, .src0x, .src0x, .vp(.unord), ._ }, |
| 5779 | .{ ._, ._ps, .blendv, .dst0x, .src1x, .src0x, ._ }, |
| 5780 | } }, |
| 5781 | }, .{ |
| 5782 | .required_features = .{ .sse, null, null, null }, |
| 5783 | .src_constraints = .{ |
| 5784 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 5785 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 5786 | }, |
| 5787 | .patterns = &.{ |
| 5788 | .{ .src = .{ .to_mut_sse, .mem } }, |
| 5789 | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 5790 | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 5791 | }, |
| 5792 | .extra_temps = .{ |
| 5793 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 5794 | .unused, |
| 5795 | .unused, |
| 5796 | .unused, |
| 5797 | .unused, |
| 5798 | .unused, |
| 5799 | .unused, |
| 5800 | .unused, |
| 5801 | .unused, |
| 5802 | }, |
| 5803 | .dst_temps = .{.{ .ref = .src0 }}, |
| 5804 | .each = .{ .once = &.{ |
| 5805 | .{ ._, ._ps, .mova, .tmp0x, .src1x, ._, ._ }, |
| 5806 | .{ ._, ._ps, .max, .tmp0x, .src0x, ._, ._ }, |
| 5807 | .{ ._, ._ps, .cmp, .dst0x, .src0x, .vp(.ord), ._ }, |
| 5808 | .{ ._, ._ps, .@"and", .tmp0x, .dst0x, ._, ._ }, |
| 5809 | .{ ._, ._ps, .andn, .dst0x, .src1x, ._, ._ }, |
| 5810 | .{ ._, ._ps, .@"or", .dst0x, .tmp0x, ._, ._ }, |
| 5811 | } }, |
| 5812 | }, .{ |
| 5813 | .required_features = .{ .avx, null, null, null }, |
| 5814 | .src_constraints = .{ |
| 5815 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 5816 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 5817 | }, |
| 5818 | .patterns = &.{ |
| 5819 | .{ .src = .{ .to_sse, .to_sse } }, |
| 5820 | }, |
| 5821 | .extra_temps = .{ |
| 5822 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 5823 | .unused, |
| 5824 | .unused, |
| 5825 | .unused, |
| 5826 | .unused, |
| 5827 | .unused, |
| 5828 | .unused, |
| 5829 | .unused, |
| 5830 | .unused, |
| 5831 | }, |
| 5832 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 5833 | .each = .{ .once = &.{ |
| 5834 | .{ ._, .v_ps, .cmp, .tmp0y, .src0y, .src0y, .vp(.unord) }, |
| 5835 | .{ ._, .v_ps, .max, .dst0y, .src1y, .src0y, ._ }, |
| 5836 | .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .src1y, .tmp0y }, |
| 5837 | } }, |
| 5838 | }, .{ |
| 5839 | .required_features = .{ .avx, null, null, null }, |
| 5840 | .src_constraints = .{ |
| 5841 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 5842 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 5843 | }, |
| 5844 | .patterns = &.{ |
| 5845 | .{ .src = .{ .to_mem, .to_mem } }, |
| 5846 | }, |
| 5847 | .extra_temps = .{ |
| 5848 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5849 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 5850 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 5851 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 5852 | .unused, |
| 5853 | .unused, |
| 5854 | .unused, |
| 5855 | .unused, |
| 5856 | .unused, |
| 5857 | }, |
| 5858 | .dst_temps = .{.mem}, |
| 5859 | .clobbers = .{ .eflags = true }, |
| 5860 | .each = .{ .once = &.{ |
| 5861 | .{ ._, ._, .mov, .tmp0q, .sa(.src0, .sub_size), ._, ._ }, |
| 5862 | .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 5863 | .{ ._, .v_ps, .mova, .tmp2y, .memia(.src1y, .tmp0, .add_size), ._, ._ }, |
| 5864 | .{ ._, .v_ps, .cmp, .tmp3y, .tmp1y, .tmp1y, .vp(.unord) }, |
| 5865 | .{ ._, .v_ps, .max, .tmp1y, .tmp2y, .tmp1y, ._ }, |
| 5866 | .{ ._, .v_ps, .blendv, .tmp1y, .tmp1y, .tmp2y, .tmp3y }, |
| 5867 | .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ }, |
| 5868 | .{ ._, ._, .add, .tmp0q, .si(32), ._, ._ }, |
| 5869 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5870 | } }, |
| 5871 | }, .{ |
| 5872 | .required_features = .{ .sse4_1, null, null, null }, |
| 5873 | .src_constraints = .{ |
| 5874 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 5875 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 5876 | }, |
| 5877 | .patterns = &.{ |
| 5878 | .{ .src = .{ .to_mem, .to_mem } }, |
| 5879 | }, |
| 5880 | .extra_temps = .{ |
| 5881 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5882 | .{ .type = .vector_4_f32, .kind = .{ .reg = .xmm0 } }, |
| 5883 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 5884 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 5885 | .unused, |
| 5886 | .unused, |
| 5887 | .unused, |
| 5888 | .unused, |
| 5889 | .unused, |
| 5890 | }, |
| 5891 | .dst_temps = .{.mem}, |
| 5892 | .clobbers = .{ .eflags = true }, |
| 5893 | .each = .{ .once = &.{ |
| 5894 | .{ ._, ._, .mov, .tmp0q, .sa(.src0, .sub_size), ._, ._ }, |
| 5895 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 5896 | .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 5897 | .{ ._, ._ps, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 5898 | .{ ._, ._ps, .max, .tmp3x, .tmp1x, ._, ._ }, |
| 5899 | .{ ._, ._ps, .cmp, .tmp1x, .tmp1x, .vp(.unord), ._ }, |
| 5900 | .{ ._, ._ps, .blendv, .tmp3x, .tmp2x, .tmp1x, ._ }, |
| 5901 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, |
| 5902 | .{ ._, ._, .add, .tmp0q, .si(16), ._, ._ }, |
| 5903 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5904 | } }, |
| 5905 | }, .{ |
| 5906 | .required_features = .{ .sse, null, null, null }, |
| 5907 | .src_constraints = .{ |
| 5908 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 5909 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 5910 | }, |
| 5911 | .patterns = &.{ |
| 5912 | .{ .src = .{ .to_mem, .to_mem } }, |
| 5913 | }, |
| 5914 | .extra_temps = .{ |
| 5915 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5916 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 5917 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 5918 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 5919 | .unused, |
| 5920 | .unused, |
| 5921 | .unused, |
| 5922 | .unused, |
| 5923 | .unused, |
| 5924 | }, |
| 5925 | .dst_temps = .{.mem}, |
| 5926 | .clobbers = .{ .eflags = true }, |
| 5927 | .each = .{ .once = &.{ |
| 5928 | .{ ._, ._, .mov, .tmp0q, .sa(.src0, .sub_size), ._, ._ }, |
| 5929 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 5930 | .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 5931 | .{ ._, ._ps, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 5932 | .{ ._, ._ps, .max, .tmp3x, .tmp1x, ._, ._ }, |
| 5933 | .{ ._, ._ps, .cmp, .tmp1x, .tmp1x, .vp(.ord), ._ }, |
| 5934 | .{ ._, ._ps, .@"and", .tmp3x, .tmp1x, ._, ._ }, |
| 5935 | .{ ._, ._ps, .andn, .tmp1x, .tmp2x, ._, ._ }, |
| 5936 | .{ ._, ._ps, .@"or", .tmp1x, .tmp3x, ._, ._ }, |
| 5937 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 5938 | .{ ._, ._, .add, .tmp0q, .si(16), ._, ._ }, |
| 5939 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5940 | } }, |
| 5502 | 5941 | }, .{ |
| 5503 | 5942 | .required_features = .{ .avx, null, null, null }, |
| 5504 | 5943 | .src_constraints = .{ |
| ... | ... | @@ -5509,7 +5948,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5509 | 5948 | .{ .src = .{ .to_sse, .to_sse } }, |
| 5510 | 5949 | }, |
| 5511 | 5950 | .extra_temps = .{ |
| 5512 | | .{ .kind = .{ .rc = .sse } }, |
| 5951 | .{ .type = .f64, .kind = .{ .rc = .sse } }, |
| 5513 | 5952 | .unused, |
| 5514 | 5953 | .unused, |
| 5515 | 5954 | .unused, |
| ... | ... | @@ -5591,11 +6030,249 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5591 | 6030 | .unused, |
| 5592 | 6031 | .unused, |
| 5593 | 6032 | }, |
| 5594 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5595 | 6033 | .dst_temps = .{.{ .ref = .src0 }}, |
| 6034 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5596 | 6035 | .each = .{ .once = &.{ |
| 5597 | 6036 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 5598 | 6037 | } }, |
| 6038 | }, .{ |
| 6039 | .required_features = .{ .avx, null, null, null }, |
| 6040 | .src_constraints = .{ |
| 6041 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 6042 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 6043 | }, |
| 6044 | .patterns = &.{ |
| 6045 | .{ .src = .{ .to_sse, .to_sse } }, |
| 6046 | }, |
| 6047 | .extra_temps = .{ |
| 6048 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 6049 | .unused, |
| 6050 | .unused, |
| 6051 | .unused, |
| 6052 | .unused, |
| 6053 | .unused, |
| 6054 | .unused, |
| 6055 | .unused, |
| 6056 | .unused, |
| 6057 | }, |
| 6058 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 6059 | .each = .{ .once = &.{ |
| 6060 | .{ ._, .v_pd, .cmp, .tmp0x, .src0x, .src0x, .vp(.unord) }, |
| 6061 | .{ ._, .v_pd, .max, .dst0x, .src1x, .src0x, ._ }, |
| 6062 | .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .src1x, .tmp0x }, |
| 6063 | } }, |
| 6064 | }, .{ |
| 6065 | .required_features = .{ .sse4_1, null, null, null }, |
| 6066 | .src_constraints = .{ |
| 6067 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 6068 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 6069 | }, |
| 6070 | .patterns = &.{ |
| 6071 | .{ .src = .{ .{ .to_reg = .xmm0 }, .mem } }, |
| 6072 | .{ .src = .{ .mem, .{ .to_reg = .xmm0 } }, .commute = .{ 0, 1 } }, |
| 6073 | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse } }, |
| 6074 | }, |
| 6075 | .dst_temps = .{.{ .rc = .sse }}, |
| 6076 | .each = .{ .once = &.{ |
| 6077 | .{ ._, ._pd, .mova, .dst0x, .src1x, ._, ._ }, |
| 6078 | .{ ._, ._pd, .max, .dst0x, .src0x, ._, ._ }, |
| 6079 | .{ ._, ._pd, .cmp, .src0x, .src0x, .vp(.unord), ._ }, |
| 6080 | .{ ._, ._pd, .blendv, .dst0x, .src1x, .src0x, ._ }, |
| 6081 | } }, |
| 6082 | }, .{ |
| 6083 | .required_features = .{ .sse2, null, null, null }, |
| 6084 | .src_constraints = .{ |
| 6085 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 6086 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 6087 | }, |
| 6088 | .patterns = &.{ |
| 6089 | .{ .src = .{ .to_mut_sse, .mem } }, |
| 6090 | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 6091 | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 6092 | }, |
| 6093 | .extra_temps = .{ |
| 6094 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 6095 | .unused, |
| 6096 | .unused, |
| 6097 | .unused, |
| 6098 | .unused, |
| 6099 | .unused, |
| 6100 | .unused, |
| 6101 | .unused, |
| 6102 | .unused, |
| 6103 | }, |
| 6104 | .dst_temps = .{.{ .ref = .src0 }}, |
| 6105 | .each = .{ .once = &.{ |
| 6106 | .{ ._, ._pd, .mova, .tmp0x, .src1x, ._, ._ }, |
| 6107 | .{ ._, ._pd, .max, .tmp0x, .src0x, ._, ._ }, |
| 6108 | .{ ._, ._pd, .cmp, .dst0x, .src0x, .vp(.ord), ._ }, |
| 6109 | .{ ._, ._pd, .@"and", .tmp0x, .dst0x, ._, ._ }, |
| 6110 | .{ ._, ._pd, .andn, .dst0x, .src1x, ._, ._ }, |
| 6111 | .{ ._, ._pd, .@"or", .dst0x, .tmp0x, ._, ._ }, |
| 6112 | } }, |
| 6113 | }, .{ |
| 6114 | .required_features = .{ .avx, null, null, null }, |
| 6115 | .src_constraints = .{ |
| 6116 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 6117 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 6118 | }, |
| 6119 | .patterns = &.{ |
| 6120 | .{ .src = .{ .to_sse, .to_sse } }, |
| 6121 | }, |
| 6122 | .extra_temps = .{ |
| 6123 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 6124 | .unused, |
| 6125 | .unused, |
| 6126 | .unused, |
| 6127 | .unused, |
| 6128 | .unused, |
| 6129 | .unused, |
| 6130 | .unused, |
| 6131 | .unused, |
| 6132 | }, |
| 6133 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 6134 | .each = .{ .once = &.{ |
| 6135 | .{ ._, .v_pd, .cmp, .tmp0y, .src0y, .src0y, .vp(.unord) }, |
| 6136 | .{ ._, .v_pd, .max, .dst0y, .src1y, .src0y, ._ }, |
| 6137 | .{ ._, .v_pd, .blendv, .dst0y, .dst0y, .src1y, .tmp0y }, |
| 6138 | } }, |
| 6139 | }, .{ |
| 6140 | .required_features = .{ .avx, null, null, null }, |
| 6141 | .src_constraints = .{ |
| 6142 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| 6143 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| 6144 | }, |
| 6145 | .patterns = &.{ |
| 6146 | .{ .src = .{ .to_mem, .to_mem } }, |
| 6147 | }, |
| 6148 | .extra_temps = .{ |
| 6149 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6150 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 6151 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 6152 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 6153 | .unused, |
| 6154 | .unused, |
| 6155 | .unused, |
| 6156 | .unused, |
| 6157 | .unused, |
| 6158 | }, |
| 6159 | .dst_temps = .{.mem}, |
| 6160 | .clobbers = .{ .eflags = true }, |
| 6161 | .each = .{ .once = &.{ |
| 6162 | .{ ._, ._, .mov, .tmp0q, .sa(.src0, .sub_size), ._, ._ }, |
| 6163 | .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 6164 | .{ ._, .v_pd, .mova, .tmp2y, .memia(.src1y, .tmp0, .add_size), ._, ._ }, |
| 6165 | .{ ._, .v_pd, .cmp, .tmp3y, .tmp1y, .tmp1y, .vp(.unord) }, |
| 6166 | .{ ._, .v_pd, .max, .tmp1y, .tmp2y, .tmp1y, ._ }, |
| 6167 | .{ ._, .v_pd, .blendv, .tmp1y, .tmp1y, .tmp2y, .tmp3y }, |
| 6168 | .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ }, |
| 6169 | .{ ._, ._, .add, .tmp0q, .si(32), ._, ._ }, |
| 6170 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6171 | } }, |
| 6172 | }, .{ |
| 6173 | .required_features = .{ .sse4_1, null, null, null }, |
| 6174 | .src_constraints = .{ |
| 6175 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 6176 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 6177 | }, |
| 6178 | .patterns = &.{ |
| 6179 | .{ .src = .{ .to_mem, .to_mem } }, |
| 6180 | }, |
| 6181 | .extra_temps = .{ |
| 6182 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6183 | .{ .type = .vector_2_f64, .kind = .{ .reg = .xmm0 } }, |
| 6184 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 6185 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 6186 | .unused, |
| 6187 | .unused, |
| 6188 | .unused, |
| 6189 | .unused, |
| 6190 | .unused, |
| 6191 | }, |
| 6192 | .dst_temps = .{.mem}, |
| 6193 | .clobbers = .{ .eflags = true }, |
| 6194 | .each = .{ .once = &.{ |
| 6195 | .{ ._, ._, .mov, .tmp0q, .sa(.src0, .sub_size), ._, ._ }, |
| 6196 | .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 6197 | .{ ._, ._pd, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 6198 | .{ ._, ._pd, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 6199 | .{ ._, ._pd, .max, .tmp3x, .tmp1x, ._, ._ }, |
| 6200 | .{ ._, ._pd, .cmp, .tmp1x, .tmp1x, .vp(.unord), ._ }, |
| 6201 | .{ ._, ._pd, .blendv, .tmp3x, .tmp2x, .tmp1x, ._ }, |
| 6202 | .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, |
| 6203 | .{ ._, ._, .add, .tmp0q, .si(16), ._, ._ }, |
| 6204 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6205 | } }, |
| 6206 | }, .{ |
| 6207 | .required_features = .{ .sse2, null, null, null }, |
| 6208 | .src_constraints = .{ |
| 6209 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 6210 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 6211 | }, |
| 6212 | .patterns = &.{ |
| 6213 | .{ .src = .{ .to_mem, .to_mem } }, |
| 6214 | }, |
| 6215 | .extra_temps = .{ |
| 6216 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6217 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 6218 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 6219 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 6220 | .unused, |
| 6221 | .unused, |
| 6222 | .unused, |
| 6223 | .unused, |
| 6224 | .unused, |
| 6225 | }, |
| 6226 | .dst_temps = .{.mem}, |
| 6227 | .clobbers = .{ .eflags = true }, |
| 6228 | .each = .{ .once = &.{ |
| 6229 | .{ ._, ._, .mov, .tmp0q, .sa(.src0, .sub_size), ._, ._ }, |
| 6230 | .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 6231 | .{ ._, ._pd, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 6232 | .{ ._, ._pd, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 6233 | .{ ._, ._pd, .max, .tmp3x, .tmp1x, ._, ._ }, |
| 6234 | .{ ._, ._pd, .cmp, .tmp1x, .tmp1x, .vp(.ord), ._ }, |
| 6235 | .{ ._, ._pd, .@"and", .tmp3x, .tmp1x, ._, ._ }, |
| 6236 | .{ ._, ._pd, .andn, .tmp1x, .tmp2x, ._, ._ }, |
| 6237 | .{ ._, ._pd, .@"or", .tmp1x, .tmp3x, ._, ._ }, |
| 6238 | .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 6239 | .{ ._, ._, .add, .tmp0q, .si(16), ._, ._ }, |
| 6240 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6241 | } }, |
| 6242 | }, .{ |
| 6243 | .required_features = .{ .sse, null, null, null }, |
| 6244 | .src_constraints = .{ |
| 6245 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 6246 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 6247 | }, |
| 6248 | .patterns = &.{ |
| 6249 | .{ .src = .{ .to_mem, .to_mem } }, |
| 6250 | }, |
| 6251 | .call_frame = .{ .alignment = .@"16" }, |
| 6252 | .extra_temps = .{ |
| 6253 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6254 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 6255 | .{ .type = .f64, .kind = .{ .reg = .xmm1 } }, |
| 6256 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmax" } } }, |
| 6257 | .unused, |
| 6258 | .unused, |
| 6259 | .unused, |
| 6260 | .unused, |
| 6261 | .unused, |
| 6262 | }, |
| 6263 | .dst_temps = .{.mem}, |
| 6264 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 6265 | .each = .{ .once = &.{ |
| 6266 | .{ ._, ._, .mov, .tmp0q, .sa(.src0, .sub_size), ._, ._ }, |
| 6267 | .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 6268 | .{ ._, ._ps, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 6269 | .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 6270 | .{ ._, ._ps, .movl, .tmp2x, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 6271 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 6272 | .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, |
| 6273 | .{ ._, ._, .add, .tmp0q, .si(8), ._, ._ }, |
| 6274 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6275 | } }, |
| 5599 | 6276 | }, .{ |
| 5600 | 6277 | .required_features = .{ .x87, .cmov, null, null }, |
| 5601 | 6278 | .src_constraints = .{ |
| ... | ... | @@ -5750,6 +6427,172 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5750 | 6427 | .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, |
| 5751 | 6428 | .{ .@"1:", .f_p, .st, .dst0t, ._, ._, ._ }, |
| 5752 | 6429 | } }, |
| 6430 | }, .{ |
| 6431 | .required_features = .{ .x87, .cmov, null, null }, |
| 6432 | .src_constraints = .{ |
| 6433 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 6434 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 6435 | }, |
| 6436 | .patterns = &.{ |
| 6437 | .{ .src = .{ .to_mem, .to_mem } }, |
| 6438 | }, |
| 6439 | .extra_temps = .{ |
| 6440 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6441 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 6442 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 6443 | .unused, |
| 6444 | .unused, |
| 6445 | .unused, |
| 6446 | .unused, |
| 6447 | .unused, |
| 6448 | .unused, |
| 6449 | }, |
| 6450 | .dst_temps = .{.mem}, |
| 6451 | .clobbers = .{ .eflags = true }, |
| 6452 | .each = .{ .once = &.{ |
| 6453 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 6454 | .{ .@"0:", .f_, .ld, .memia(.src1t, .tmp0, .add_size), ._, ._, ._ }, |
| 6455 | .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ }, |
| 6456 | .{ ._, .f_, .ucomi, .tmp1t, .tmp1t, ._, ._ }, |
| 6457 | .{ ._, .f_u, .cmov, .tmp1t, .tmp2t, ._, ._ }, |
| 6458 | .{ ._, .f_, .xch, .tmp2t, ._, ._, ._ }, |
| 6459 | .{ ._, .f_, .ucomi, .tmp1t, .tmp2t, ._, ._ }, |
| 6460 | .{ ._, .f_, .xch, .tmp2t, ._, ._, ._ }, |
| 6461 | .{ ._, .f_nb, .cmov, .tmp1t, .tmp2t, ._, ._ }, |
| 6462 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_size), ._, ._, ._ }, |
| 6463 | .{ ._, .f_p, .st, .tmp2t, ._, ._, ._ }, |
| 6464 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 6465 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6466 | } }, |
| 6467 | }, .{ |
| 6468 | .required_features = .{ .sahf, .x87, null, null }, |
| 6469 | .src_constraints = .{ |
| 6470 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 6471 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 6472 | }, |
| 6473 | .patterns = &.{ |
| 6474 | .{ .src = .{ .to_mem, .to_mem } }, |
| 6475 | }, |
| 6476 | .extra_temps = .{ |
| 6477 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6478 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 6479 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 6480 | .{ .type = .u8, .kind = .{ .reg = .ah } }, |
| 6481 | .unused, |
| 6482 | .unused, |
| 6483 | .unused, |
| 6484 | .unused, |
| 6485 | .unused, |
| 6486 | }, |
| 6487 | .dst_temps = .{.mem}, |
| 6488 | .clobbers = .{ .eflags = true }, |
| 6489 | .each = .{ .once = &.{ |
| 6490 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 6491 | .{ .@"0:", .f_, .ld, .memia(.src1t, .tmp0, .add_size), ._, ._, ._ }, |
| 6492 | .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ }, |
| 6493 | .{ ._, .f_, .ucom, .tmp1t, ._, ._, ._ }, |
| 6494 | .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ }, |
| 6495 | .{ ._, ._, .sahf, ._, ._, ._, ._ }, |
| 6496 | .{ ._, ._p, .j, .@"1f", ._, ._, ._ }, |
| 6497 | .{ ._, .f_, .xch, .tmp2t, ._, ._, ._ }, |
| 6498 | .{ ._, .f_, .ucom, .tmp2t, ._, ._, ._ }, |
| 6499 | .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ }, |
| 6500 | .{ ._, .f_, .xch, .tmp2t, ._, ._, ._ }, |
| 6501 | .{ ._, ._, .sahf, ._, ._, ._, ._ }, |
| 6502 | .{ ._, ._b, .j, .@"2f", ._, ._, ._ }, |
| 6503 | .{ .@"1:", .f_p, .st, .tmp1t, ._, ._, ._ }, |
| 6504 | .{ ._, .f_, .ld, .tmp2t, ._, ._, ._ }, |
| 6505 | .{ .@"2:", .f_p, .st, .memia(.dst0t, .tmp0, .add_size), ._, ._, ._ }, |
| 6506 | .{ ._, .f_p, .st, .tmp2t, ._, ._, ._ }, |
| 6507 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 6508 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6509 | } }, |
| 6510 | }, .{ |
| 6511 | .required_features = .{ .@"64bit", .x87, null, null }, |
| 6512 | .src_constraints = .{ |
| 6513 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 6514 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 6515 | }, |
| 6516 | .patterns = &.{ |
| 6517 | .{ .src = .{ .to_mem, .to_mem } }, |
| 6518 | }, |
| 6519 | .extra_temps = .{ |
| 6520 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6521 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 6522 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 6523 | .{ .type = .u8, .kind = .{ .reg = .ah } }, |
| 6524 | .unused, |
| 6525 | .unused, |
| 6526 | .unused, |
| 6527 | .unused, |
| 6528 | .unused, |
| 6529 | }, |
| 6530 | .dst_temps = .{.mem}, |
| 6531 | .clobbers = .{ .eflags = true }, |
| 6532 | .each = .{ .once = &.{ |
| 6533 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 6534 | .{ .@"0:", .f_, .ld, .memia(.src1t, .tmp0, .add_size), ._, ._, ._ }, |
| 6535 | .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ }, |
| 6536 | .{ ._, .f_, .xam, ._, ._, ._, ._ }, |
| 6537 | .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ }, |
| 6538 | .{ ._, ._, .@"test", .tmp3b, .si(0b0_1_000_100), ._, ._ }, |
| 6539 | .{ ._, ._z, .j, .@"1f", ._, ._, ._ }, |
| 6540 | .{ ._, .f_, .xch, .tmp2t, ._, ._, ._ }, |
| 6541 | .{ ._, .f_, .ucom, .tmp2t, ._, ._, ._ }, |
| 6542 | .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ }, |
| 6543 | .{ ._, .f_, .xch, .tmp2t, ._, ._, ._ }, |
| 6544 | .{ ._, ._, .@"test", .tmp3b, .si(0b0_0_000_001), ._, ._ }, |
| 6545 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| 6546 | .{ .@"1:", .f_p, .st, .tmp1t, ._, ._, ._ }, |
| 6547 | .{ ._, .f_, .ld, .tmp2t, ._, ._, ._ }, |
| 6548 | .{ .@"2:", .f_p, .st, .memia(.dst0t, .tmp0, .add_size), ._, ._, ._ }, |
| 6549 | .{ ._, .f_p, .st, .tmp2t, ._, ._, ._ }, |
| 6550 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 6551 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6552 | } }, |
| 6553 | }, .{ |
| 6554 | .required_features = .{ .x87, null, null, null }, |
| 6555 | .src_constraints = .{ |
| 6556 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 6557 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 6558 | }, |
| 6559 | .patterns = &.{ |
| 6560 | .{ .src = .{ .to_mem, .to_mem } }, |
| 6561 | }, |
| 6562 | .extra_temps = .{ |
| 6563 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6564 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 6565 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 6566 | .{ .type = .u8, .kind = .{ .reg = .ah } }, |
| 6567 | .unused, |
| 6568 | .unused, |
| 6569 | .unused, |
| 6570 | .unused, |
| 6571 | .unused, |
| 6572 | }, |
| 6573 | .dst_temps = .{.mem}, |
| 6574 | .clobbers = .{ .eflags = true }, |
| 6575 | .each = .{ .once = &.{ |
| 6576 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 6577 | .{ .@"0:", .f_, .ld, .memia(.src1t, .tmp0, .add_size), ._, ._, ._ }, |
| 6578 | .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ }, |
| 6579 | .{ ._, .f_, .ucom, .tmp1t, ._, ._, ._ }, |
| 6580 | .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ }, |
| 6581 | .{ ._, ._, .sahf, ._, ._, ._, ._ }, |
| 6582 | .{ ._, ._p, .j, .@"1f", ._, ._, ._ }, |
| 6583 | .{ ._, .f_, .xch, .tmp2t, ._, ._, ._ }, |
| 6584 | .{ ._, .f_, .ucom, .tmp2t, ._, ._, ._ }, |
| 6585 | .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ }, |
| 6586 | .{ ._, .f_, .xch, .tmp2t, ._, ._, ._ }, |
| 6587 | .{ ._, ._, .sahf, ._, ._, ._, ._ }, |
| 6588 | .{ ._, ._b, .j, .@"2f", ._, ._, ._ }, |
| 6589 | .{ .@"1:", .f_p, .st, .tmp1t, ._, ._, ._ }, |
| 6590 | .{ ._, .f_, .ld, .tmp2t, ._, ._, ._ }, |
| 6591 | .{ .@"2:", .f_p, .st, .memia(.dst0t, .tmp0, .add_size), ._, ._, ._ }, |
| 6592 | .{ ._, .f_p, .st, .tmp2t, ._, ._, ._ }, |
| 6593 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 6594 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6595 | } }, |
| 5753 | 6596 | }, .{ |
| 5754 | 6597 | .required_features = .{ .sse, null, null, null }, |
| 5755 | 6598 | .src_constraints = .{ |
| ... | ... | @@ -5771,11 +6614,107 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5771 | 6614 | .unused, |
| 5772 | 6615 | .unused, |
| 5773 | 6616 | }, |
| 5774 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5775 | 6617 | .dst_temps = .{.{ .ref = .src0 }}, |
| 6618 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5776 | 6619 | .each = .{ .once = &.{ |
| 5777 | 6620 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 5778 | 6621 | } }, |
| 6622 | }, .{ |
| 6623 | .required_features = .{ .avx, null, null, null }, |
| 6624 | .src_constraints = .{ |
| 6625 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 6626 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 6627 | }, |
| 6628 | .patterns = &.{ |
| 6629 | .{ .src = .{ .to_mem, .to_mem } }, |
| 6630 | }, |
| 6631 | .call_frame = .{ .alignment = .@"16" }, |
| 6632 | .extra_temps = .{ |
| 6633 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6634 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 6635 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 6636 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmaxq" } } }, |
| 6637 | .unused, |
| 6638 | .unused, |
| 6639 | .unused, |
| 6640 | .unused, |
| 6641 | .unused, |
| 6642 | }, |
| 6643 | .dst_temps = .{.mem}, |
| 6644 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 6645 | .each = .{ .once = &.{ |
| 6646 | .{ ._, ._, .mov, .tmp0q, .sa(.src0, .sub_size), ._, ._ }, |
| 6647 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 6648 | .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 6649 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 6650 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 6651 | .{ ._, ._, .add, .tmp0q, .si(16), ._, ._ }, |
| 6652 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6653 | } }, |
| 6654 | }, .{ |
| 6655 | .required_features = .{ .sse2, null, null, null }, |
| 6656 | .src_constraints = .{ |
| 6657 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 6658 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 6659 | }, |
| 6660 | .patterns = &.{ |
| 6661 | .{ .src = .{ .to_mem, .to_mem } }, |
| 6662 | }, |
| 6663 | .call_frame = .{ .alignment = .@"16" }, |
| 6664 | .extra_temps = .{ |
| 6665 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6666 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 6667 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 6668 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmaxq" } } }, |
| 6669 | .unused, |
| 6670 | .unused, |
| 6671 | .unused, |
| 6672 | .unused, |
| 6673 | .unused, |
| 6674 | }, |
| 6675 | .dst_temps = .{.mem}, |
| 6676 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 6677 | .each = .{ .once = &.{ |
| 6678 | .{ ._, ._, .mov, .tmp0q, .sa(.src0, .sub_size), ._, ._ }, |
| 6679 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 6680 | .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 6681 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 6682 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 6683 | .{ ._, ._, .add, .tmp0q, .si(16), ._, ._ }, |
| 6684 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6685 | } }, |
| 6686 | }, .{ |
| 6687 | .required_features = .{ .sse, null, null, null }, |
| 6688 | .src_constraints = .{ |
| 6689 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 6690 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 6691 | }, |
| 6692 | .patterns = &.{ |
| 6693 | .{ .src = .{ .to_mem, .to_mem } }, |
| 6694 | }, |
| 6695 | .call_frame = .{ .alignment = .@"16" }, |
| 6696 | .extra_temps = .{ |
| 6697 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6698 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 6699 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 6700 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmaxq" } } }, |
| 6701 | .unused, |
| 6702 | .unused, |
| 6703 | .unused, |
| 6704 | .unused, |
| 6705 | .unused, |
| 6706 | }, |
| 6707 | .dst_temps = .{.mem}, |
| 6708 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 6709 | .each = .{ .once = &.{ |
| 6710 | .{ ._, ._, .mov, .tmp0q, .sa(.src0, .sub_size), ._, ._ }, |
| 6711 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 6712 | .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 6713 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 6714 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 6715 | .{ ._, ._, .add, .tmp0q, .si(16), ._, ._ }, |
| 6716 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6717 | } }, |
| 5779 | 6718 | } }) catch |err| switch (err) { |
| 5780 | 6719 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 5781 | 6720 | @tagName(air_tag), |
| ... | ... | @@ -5787,10 +6726,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5787 | 6726 | }; |
| 5788 | 6727 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| 5789 | 6728 | }, |
| 5790 | | .min => |air_tag| if (use_old) try cg.airBinOp(inst, air_tag) else fallback: { |
| 6729 | .min => |air_tag| if (use_old) try cg.airBinOp(inst, air_tag) else { |
| 5791 | 6730 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; |
| 5792 | | const ty = cg.typeOf(bin_op.lhs); |
| 5793 | | if (ty.isVector(zcu) and cg.floatBits(ty.childType(zcu)) != null) break :fallback try cg.airBinOp(inst, air_tag); |
| 5794 | 6731 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 5795 | 6732 | var res: [1]Temp = undefined; |
| 5796 | 6733 | cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ |
| ... | ... | @@ -7494,7 +8431,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7494 | 8431 | }, |
| 7495 | 8432 | .extra_temps = .{ |
| 7496 | 8433 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 7497 | | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 8434 | .{ .type = .vector_4_u32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 7498 | 8435 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 7499 | 8436 | .unused, |
| 7500 | 8437 | .unused, |
| ... | ... | @@ -7631,7 +8568,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7631 | 8568 | }, |
| 7632 | 8569 | .extra_temps = .{ |
| 7633 | 8570 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 7634 | | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 8571 | .{ .type = .vector_4_u32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 7635 | 8572 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 7636 | 8573 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 7637 | 8574 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| ... | ... | @@ -7955,7 +8892,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7955 | 8892 | }, |
| 7956 | 8893 | .extra_temps = .{ |
| 7957 | 8894 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 7958 | | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 8895 | .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 7959 | 8896 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 7960 | 8897 | .unused, |
| 7961 | 8898 | .unused, |
| ... | ... | @@ -7986,7 +8923,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7986 | 8923 | }, |
| 7987 | 8924 | .extra_temps = .{ |
| 7988 | 8925 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 7989 | | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 8926 | .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 7990 | 8927 | .{ .type = .vector_2_u64, .kind = .{ .reg = .xmm0 } }, |
| 7991 | 8928 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 7992 | 8929 | .unused, |
| ... | ... | @@ -8018,7 +8955,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8018 | 8955 | }, |
| 8019 | 8956 | .extra_temps = .{ |
| 8020 | 8957 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 8021 | | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 8958 | .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 8022 | 8959 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 8023 | 8960 | .unused, |
| 8024 | 8961 | .unused, |
| ... | ... | @@ -8047,7 +8984,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8047 | 8984 | }, |
| 8048 | 8985 | .extra_temps = .{ |
| 8049 | 8986 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8050 | | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 8987 | .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 8051 | 8988 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 8052 | 8989 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 8053 | 8990 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| ... | ... | @@ -8083,7 +9020,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8083 | 9020 | }, |
| 8084 | 9021 | .extra_temps = .{ |
| 8085 | 9022 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8086 | | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 9023 | .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 8087 | 9024 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 8088 | 9025 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 8089 | 9026 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| ... | ... | @@ -8119,7 +9056,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8119 | 9056 | }, |
| 8120 | 9057 | .extra_temps = .{ |
| 8121 | 9058 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8122 | | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 9059 | .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 8123 | 9060 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 8124 | 9061 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 8125 | 9062 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| ... | ... | @@ -8371,8 +9308,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8371 | 9308 | .{ .src = .{ .to_sse, .to_sse } }, |
| 8372 | 9309 | }, |
| 8373 | 9310 | .extra_temps = .{ |
| 8374 | | .{ .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 8375 | | .{ .kind = .{ .rc = .sse } }, |
| 9311 | .{ .type = .f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 9312 | .{ .type = .f16, .kind = .{ .rc = .sse } }, |
| 8376 | 9313 | .unused, |
| 8377 | 9314 | .unused, |
| 8378 | 9315 | .unused, |
| ... | ... | @@ -8383,12 +9320,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8383 | 9320 | }, |
| 8384 | 9321 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 8385 | 9322 | .each = .{ .once = &.{ |
| 8386 | | .{ ._, .v_ps, .cvtph2, .dst0x, .src0x, ._, ._ }, |
| 8387 | | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1x, ._, ._ }, |
| 9323 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 9324 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 8388 | 9325 | .{ ._, .v_ss, .cmp, .tmp1x, .dst0x, .dst0x, .vp(.unord) }, |
| 8389 | 9326 | .{ ._, .v_ss, .min, .dst0x, .tmp0x, .dst0x, ._ }, |
| 8390 | 9327 | .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp0x, .tmp1x }, |
| 8391 | | .{ ._, .v_, .cvtps2ph, .dst0x, .dst0x, .rm(.{}), ._ }, |
| 9328 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 8392 | 9329 | } }, |
| 8393 | 9330 | }, .{ |
| 8394 | 9331 | .required_features = .{ .sse, null, null, null }, |
| ... | ... | @@ -8411,11 +9348,248 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8411 | 9348 | .unused, |
| 8412 | 9349 | .unused, |
| 8413 | 9350 | }, |
| 8414 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8415 | 9351 | .dst_temps = .{.{ .ref = .src0 }}, |
| 9352 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8416 | 9353 | .each = .{ .once = &.{ |
| 8417 | 9354 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 8418 | 9355 | } }, |
| 9356 | }, .{ |
| 9357 | .required_features = .{ .f16c, null, null, null }, |
| 9358 | .src_constraints = .{ |
| 9359 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 9360 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 9361 | }, |
| 9362 | .patterns = &.{ |
| 9363 | .{ .src = .{ .mem, .mem } }, |
| 9364 | .{ .src = .{ .to_sse, .mem } }, |
| 9365 | .{ .src = .{ .mem, .to_sse } }, |
| 9366 | .{ .src = .{ .to_sse, .to_sse } }, |
| 9367 | }, |
| 9368 | .extra_temps = .{ |
| 9369 | .{ .type = .vector_4_f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 9370 | .{ .type = .vector_4_f16, .kind = .{ .rc = .sse } }, |
| 9371 | .unused, |
| 9372 | .unused, |
| 9373 | .unused, |
| 9374 | .unused, |
| 9375 | .unused, |
| 9376 | .unused, |
| 9377 | .unused, |
| 9378 | }, |
| 9379 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 9380 | .each = .{ .once = &.{ |
| 9381 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 9382 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 9383 | .{ ._, .v_ps, .cmp, .tmp1x, .dst0x, .dst0x, .vp(.unord) }, |
| 9384 | .{ ._, .v_ps, .min, .dst0x, .tmp0x, .dst0x, ._ }, |
| 9385 | .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp0x, .tmp1x }, |
| 9386 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 9387 | } }, |
| 9388 | }, .{ |
| 9389 | .required_features = .{ .f16c, null, null, null }, |
| 9390 | .src_constraints = .{ |
| 9391 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 9392 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 9393 | }, |
| 9394 | .patterns = &.{ |
| 9395 | .{ .src = .{ .mem, .mem } }, |
| 9396 | .{ .src = .{ .to_sse, .mem } }, |
| 9397 | .{ .src = .{ .mem, .to_sse } }, |
| 9398 | .{ .src = .{ .to_sse, .to_sse } }, |
| 9399 | }, |
| 9400 | .extra_temps = .{ |
| 9401 | .{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 9402 | .{ .type = .vector_8_f16, .kind = .{ .rc = .sse } }, |
| 9403 | .unused, |
| 9404 | .unused, |
| 9405 | .unused, |
| 9406 | .unused, |
| 9407 | .unused, |
| 9408 | .unused, |
| 9409 | .unused, |
| 9410 | }, |
| 9411 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 9412 | .each = .{ .once = &.{ |
| 9413 | .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ }, |
| 9414 | .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ }, |
| 9415 | .{ ._, .v_ps, .cmp, .tmp1y, .dst0y, .dst0y, .vp(.unord) }, |
| 9416 | .{ ._, .v_ps, .min, .dst0y, .tmp0y, .dst0y, ._ }, |
| 9417 | .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp0y, .tmp1y }, |
| 9418 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0y, .rm(.{}), ._ }, |
| 9419 | } }, |
| 9420 | }, .{ |
| 9421 | .required_features = .{ .f16c, null, null, null }, |
| 9422 | .src_constraints = .{ |
| 9423 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 9424 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 9425 | }, |
| 9426 | .patterns = &.{ |
| 9427 | .{ .src = .{ .to_mem, .to_mem } }, |
| 9428 | }, |
| 9429 | .extra_temps = .{ |
| 9430 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 9431 | .{ .type = .vector_8_f16, .kind = .{ .rc = .sse } }, |
| 9432 | .{ .type = .vector_8_f16, .kind = .{ .rc = .sse } }, |
| 9433 | .{ .type = .vector_8_f16, .kind = .{ .rc = .sse } }, |
| 9434 | .unused, |
| 9435 | .unused, |
| 9436 | .unused, |
| 9437 | .unused, |
| 9438 | .unused, |
| 9439 | }, |
| 9440 | .dst_temps = .{.mem}, |
| 9441 | .clobbers = .{ .eflags = true }, |
| 9442 | .each = .{ .once = &.{ |
| 9443 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 9444 | .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 9445 | .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 9446 | .{ ._, .v_ps, .cmp, .tmp3y, .tmp1y, .tmp1y, .vp(.unord) }, |
| 9447 | .{ ._, .v_ps, .min, .tmp1y, .tmp2y, .tmp1y, ._ }, |
| 9448 | .{ ._, .v_ps, .blendv, .tmp1y, .tmp1y, .tmp2y, .tmp3y }, |
| 9449 | .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_size), .tmp1y, .rm(.{}), ._ }, |
| 9450 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 9451 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 9452 | } }, |
| 9453 | }, .{ |
| 9454 | .required_features = .{ .avx, null, null, null }, |
| 9455 | .src_constraints = .{ |
| 9456 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 9457 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 9458 | }, |
| 9459 | .patterns = &.{ |
| 9460 | .{ .src = .{ .to_mem, .to_mem } }, |
| 9461 | }, |
| 9462 | .call_frame = .{ .alignment = .@"16" }, |
| 9463 | .extra_temps = .{ |
| 9464 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 9465 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 9466 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 9467 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fminh" } } }, |
| 9468 | .unused, |
| 9469 | .unused, |
| 9470 | .unused, |
| 9471 | .unused, |
| 9472 | .unused, |
| 9473 | }, |
| 9474 | .dst_temps = .{.mem}, |
| 9475 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 9476 | .each = .{ .once = &.{ |
| 9477 | .{ ._, ._, .mov, .tmp0q, .sa(.src0, .sub_size), ._, ._ }, |
| 9478 | .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, |
| 9479 | .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_size), .ui(0) }, |
| 9480 | .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_size), .ui(0) }, |
| 9481 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 9482 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_size), .tmp1x, .ui(0), ._ }, |
| 9483 | .{ ._, ._, .add, .tmp0q, .si(2), ._, ._ }, |
| 9484 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 9485 | } }, |
| 9486 | }, .{ |
| 9487 | .required_features = .{ .sse4_1, null, null, null }, |
| 9488 | .src_constraints = .{ |
| 9489 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 9490 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 9491 | }, |
| 9492 | .patterns = &.{ |
| 9493 | .{ .src = .{ .to_mem, .to_mem } }, |
| 9494 | }, |
| 9495 | .call_frame = .{ .alignment = .@"16" }, |
| 9496 | .extra_temps = .{ |
| 9497 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 9498 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 9499 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 9500 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fminh" } } }, |
| 9501 | .unused, |
| 9502 | .unused, |
| 9503 | .unused, |
| 9504 | .unused, |
| 9505 | .unused, |
| 9506 | }, |
| 9507 | .dst_temps = .{.mem}, |
| 9508 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 9509 | .each = .{ .once = &.{ |
| 9510 | .{ ._, ._, .mov, .tmp0q, .sa(.src0, .sub_size), ._, ._ }, |
| 9511 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 9512 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 9513 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_size), .ui(0), ._ }, |
| 9514 | .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_size), .ui(0), ._ }, |
| 9515 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 9516 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_size), .tmp1x, .ui(0), ._ }, |
| 9517 | .{ ._, ._, .add, .tmp0q, .si(2), ._, ._ }, |
| 9518 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 9519 | } }, |
| 9520 | }, .{ |
| 9521 | .required_features = .{ .sse2, null, null, null }, |
| 9522 | .src_constraints = .{ |
| 9523 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 9524 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 9525 | }, |
| 9526 | .patterns = &.{ |
| 9527 | .{ .src = .{ .to_mem, .to_mem } }, |
| 9528 | }, |
| 9529 | .call_frame = .{ .alignment = .@"16" }, |
| 9530 | .extra_temps = .{ |
| 9531 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 9532 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 9533 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 9534 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fminh" } } }, |
| 9535 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 9536 | .unused, |
| 9537 | .unused, |
| 9538 | .unused, |
| 9539 | .unused, |
| 9540 | }, |
| 9541 | .dst_temps = .{.mem}, |
| 9542 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 9543 | .each = .{ .once = &.{ |
| 9544 | .{ ._, ._, .mov, .tmp0q, .sa(.src0, .sub_size), ._, ._ }, |
| 9545 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 9546 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 9547 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_size), .ui(0), ._ }, |
| 9548 | .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_size), .ui(0), ._ }, |
| 9549 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 9550 | .{ ._, .p_w, .extr, .tmp4d, .tmp1x, .ui(0), ._ }, |
| 9551 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp4w, ._, ._ }, |
| 9552 | .{ ._, ._, .add, .tmp0q, .si(2), ._, ._ }, |
| 9553 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 9554 | } }, |
| 9555 | }, .{ |
| 9556 | .required_features = .{ .sse, null, null, null }, |
| 9557 | .src_constraints = .{ |
| 9558 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 9559 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 9560 | }, |
| 9561 | .patterns = &.{ |
| 9562 | .{ .src = .{ .to_mem, .to_mem } }, |
| 9563 | }, |
| 9564 | .call_frame = .{ .alignment = .@"16" }, |
| 9565 | .extra_temps = .{ |
| 9566 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 9567 | .{ .type = .f16, .kind = .{ .reg = .eax } }, |
| 9568 | .{ .type = .f32, .kind = .mem }, |
| 9569 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 9570 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 9571 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fminh" } } }, |
| 9572 | .unused, |
| 9573 | .unused, |
| 9574 | .unused, |
| 9575 | }, |
| 9576 | .dst_temps = .{.mem}, |
| 9577 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 9578 | .each = .{ .once = &.{ |
| 9579 | .{ ._, ._, .mov, .tmp0q, .sa(.src0, .sub_size), ._, ._ }, |
| 9580 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_size), ._, ._ }, |
| 9581 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 9582 | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, |
| 9583 | .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_size), ._, ._ }, |
| 9584 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 9585 | .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ }, |
| 9586 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 9587 | .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ }, |
| 9588 | .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ }, |
| 9589 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp1w, ._, ._ }, |
| 9590 | .{ ._, ._, .add, .tmp0q, .si(2), ._, ._ }, |
| 9591 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 9592 | } }, |
| 8419 | 9593 | }, .{ |
| 8420 | 9594 | .required_features = .{ .avx, null, null, null }, |
| 8421 | 9595 | .src_constraints = .{ |
| ... | ... | @@ -8426,7 +9600,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8426 | 9600 | .{ .src = .{ .to_sse, .to_sse } }, |
| 8427 | 9601 | }, |
| 8428 | 9602 | .extra_temps = .{ |
| 8429 | | .{ .kind = .{ .rc = .sse } }, |
| 9603 | .{ .type = .f32, .kind = .{ .rc = .sse } }, |
| 8430 | 9604 | .unused, |
| 8431 | 9605 | .unused, |
| 8432 | 9606 | .unused, |
| ... | ... | @@ -8487,6 +9661,210 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8487 | 9661 | .{ ._, ._ps, .andn, .dst0x, .src1x, ._, ._ }, |
| 8488 | 9662 | .{ ._, ._ps, .@"or", .dst0x, .tmp0x, ._, ._ }, |
| 8489 | 9663 | } }, |
| 9664 | }, .{ |
| 9665 | .required_features = .{ .avx, null, null, null }, |
| 9666 | .src_constraints = .{ |
| 9667 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 9668 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 9669 | }, |
| 9670 | .patterns = &.{ |
| 9671 | .{ .src = .{ .to_sse, .to_sse } }, |
| 9672 | }, |
| 9673 | .extra_temps = .{ |
| 9674 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 9675 | .unused, |
| 9676 | .unused, |
| 9677 | .unused, |
| 9678 | .unused, |
| 9679 | .unused, |
| 9680 | .unused, |
| 9681 | .unused, |
| 9682 | .unused, |
| 9683 | }, |
| 9684 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 9685 | .each = .{ .once = &.{ |
| 9686 | .{ ._, .v_ps, .cmp, .tmp0x, .src0x, .src0x, .vp(.unord) }, |
| 9687 | .{ ._, .v_ps, .min, .dst0x, .src1x, .src0x, ._ }, |
| 9688 | .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .src1x, .tmp0x }, |
| 9689 | } }, |
| 9690 | }, .{ |
| 9691 | .required_features = .{ .sse4_1, null, null, null }, |
| 9692 | .src_constraints = .{ |
| 9693 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 9694 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 9695 | }, |
| 9696 | .patterns = &.{ |
| 9697 | .{ .src = .{ .{ .to_reg = .xmm0 }, .mem } }, |
| 9698 | .{ .src = .{ .mem, .{ .to_reg = .xmm0 } }, .commute = .{ 0, 1 } }, |
| 9699 | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse } }, |
| 9700 | }, |
| 9701 | .dst_temps = .{.{ .rc = .sse }}, |
| 9702 | .each = .{ .once = &.{ |
| 9703 | .{ ._, ._ps, .mova, .dst0x, .src1x, ._, ._ }, |
| 9704 | .{ ._, ._ps, .min, .dst0x, .src0x, ._, ._ }, |
| 9705 | .{ ._, ._ps, .cmp, .src0x, .src0x, .vp(.unord), ._ }, |
| 9706 | .{ ._, ._ps, .blendv, .dst0x, .src1x, .src0x, ._ }, |
| 9707 | } }, |
| 9708 | }, .{ |
| 9709 | .required_features = .{ .sse, null, null, null }, |
| 9710 | .src_constraints = .{ |
| 9711 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 9712 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 9713 | }, |
| 9714 | .patterns = &.{ |
| 9715 | .{ .src = .{ .to_mut_sse, .mem } }, |
| 9716 | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 9717 | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 9718 | }, |
| 9719 | .extra_temps = .{ |
| 9720 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 9721 | .unused, |
| 9722 | .unused, |
| 9723 | .unused, |
| 9724 | .unused, |
| 9725 | .unused, |
| 9726 | .unused, |
| 9727 | .unused, |
| 9728 | .unused, |
| 9729 | }, |
| 9730 | .dst_temps = .{.{ .ref = .src0 }}, |
| 9731 | .each = .{ .once = &.{ |
| 9732 | .{ ._, ._ps, .mova, .tmp0x, .src1x, ._, ._ }, |
| 9733 | .{ ._, ._ps, .min, .tmp0x, .src0x, ._, ._ }, |
| 9734 | .{ ._, ._ps, .cmp, .dst0x, .src0x, .vp(.ord), ._ }, |
| 9735 | .{ ._, ._ps, .@"and", .tmp0x, .dst0x, ._, ._ }, |
| 9736 | .{ ._, ._ps, .andn, .dst0x, .src1x, ._, ._ }, |
| 9737 | .{ ._, ._ps, .@"or", .dst0x, .tmp0x, ._, ._ }, |
| 9738 | } }, |
| 9739 | }, .{ |
| 9740 | .required_features = .{ .avx, null, null, null }, |
| 9741 | .src_constraints = .{ |
| 9742 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 9743 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 9744 | }, |
| 9745 | .patterns = &.{ |
| 9746 | .{ .src = .{ .to_sse, .to_sse } }, |
| 9747 | }, |
| 9748 | .extra_temps = .{ |
| 9749 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 9750 | .unused, |
| 9751 | .unused, |
| 9752 | .unused, |
| 9753 | .unused, |
| 9754 | .unused, |
| 9755 | .unused, |
| 9756 | .unused, |
| 9757 | .unused, |
| 9758 | }, |
| 9759 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 9760 | .each = .{ .once = &.{ |
| 9761 | .{ ._, .v_ps, .cmp, .tmp0y, .src0y, .src0y, .vp(.unord) }, |
| 9762 | .{ ._, .v_ps, .min, .dst0y, .src1y, .src0y, ._ }, |
| 9763 | .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .src1y, .tmp0y }, |
| 9764 | } }, |
| 9765 | }, .{ |
| 9766 | .required_features = .{ .avx, null, null, null }, |
| 9767 | .src_constraints = .{ |
| 9768 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 9769 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 9770 | }, |
| 9771 | .patterns = &.{ |
| 9772 | .{ .src = .{ .to_mem, .to_mem } }, |
| 9773 | }, |
| 9774 | .extra_temps = .{ |
| 9775 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 9776 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 9777 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 9778 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 9779 | .unused, |
| 9780 | .unused, |
| 9781 | .unused, |
| 9782 | .unused, |
| 9783 | .unused, |
| 9784 | }, |
| 9785 | .dst_temps = .{.mem}, |
| 9786 | .clobbers = .{ .eflags = true }, |
| 9787 | .each = .{ .once = &.{ |
| 9788 | .{ ._, ._, .mov, .tmp0q, .sa(.src0, .sub_size), ._, ._ }, |
| 9789 | .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 9790 | .{ ._, .v_ps, .mova, .tmp2y, .memia(.src1y, .tmp0, .add_size), ._, ._ }, |
| 9791 | .{ ._, .v_ps, .cmp, .tmp3y, .tmp1y, .tmp1y, .vp(.unord) }, |
| 9792 | .{ ._, .v_ps, .min, .tmp1y, .tmp2y, .tmp1y, ._ }, |
| 9793 | .{ ._, .v_ps, .blendv, .tmp1y, .tmp1y, .tmp2y, .tmp3y }, |
| 9794 | .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ }, |
| 9795 | .{ ._, ._, .add, .tmp0q, .si(32), ._, ._ }, |
| 9796 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 9797 | } }, |
| 9798 | }, .{ |
| 9799 | .required_features = .{ .sse4_1, null, null, null }, |
| 9800 | .src_constraints = .{ |
| 9801 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 9802 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 9803 | }, |
| 9804 | .patterns = &.{ |
| 9805 | .{ .src = .{ .to_mem, .to_mem } }, |
| 9806 | }, |
| 9807 | .extra_temps = .{ |
| 9808 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 9809 | .{ .type = .vector_4_f32, .kind = .{ .reg = .xmm0 } }, |
| 9810 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 9811 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 9812 | .unused, |
| 9813 | .unused, |
| 9814 | .unused, |
| 9815 | .unused, |
| 9816 | .unused, |
| 9817 | }, |
| 9818 | .dst_temps = .{.mem}, |
| 9819 | .clobbers = .{ .eflags = true }, |
| 9820 | .each = .{ .once = &.{ |
| 9821 | .{ ._, ._, .mov, .tmp0q, .sa(.src0, .sub_size), ._, ._ }, |
| 9822 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 9823 | .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 9824 | .{ ._, ._ps, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 9825 | .{ ._, ._ps, .min, .tmp3x, .tmp1x, ._, ._ }, |
| 9826 | .{ ._, ._ps, .cmp, .tmp1x, .tmp1x, .vp(.unord), ._ }, |
| 9827 | .{ ._, ._ps, .blendv, .tmp3x, .tmp2x, .tmp1x, ._ }, |
| 9828 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, |
| 9829 | .{ ._, ._, .add, .tmp0q, .si(16), ._, ._ }, |
| 9830 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 9831 | } }, |
| 9832 | }, .{ |
| 9833 | .required_features = .{ .sse, null, null, null }, |
| 9834 | .src_constraints = .{ |
| 9835 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 9836 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 9837 | }, |
| 9838 | .patterns = &.{ |
| 9839 | .{ .src = .{ .to_mem, .to_mem } }, |
| 9840 | }, |
| 9841 | .extra_temps = .{ |
| 9842 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 9843 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 9844 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 9845 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 9846 | .unused, |
| 9847 | .unused, |
| 9848 | .unused, |
| 9849 | .unused, |
| 9850 | .unused, |
| 9851 | }, |
| 9852 | .dst_temps = .{.mem}, |
| 9853 | .clobbers = .{ .eflags = true }, |
| 9854 | .each = .{ .once = &.{ |
| 9855 | .{ ._, ._, .mov, .tmp0q, .sa(.src0, .sub_size), ._, ._ }, |
| 9856 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 9857 | .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 9858 | .{ ._, ._ps, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 9859 | .{ ._, ._ps, .min, .tmp3x, .tmp1x, ._, ._ }, |
| 9860 | .{ ._, ._ps, .cmp, .tmp1x, .tmp1x, .vp(.ord), ._ }, |
| 9861 | .{ ._, ._ps, .@"and", .tmp3x, .tmp1x, ._, ._ }, |
| 9862 | .{ ._, ._ps, .andn, .tmp1x, .tmp2x, ._, ._ }, |
| 9863 | .{ ._, ._ps, .@"or", .tmp1x, .tmp3x, ._, ._ }, |
| 9864 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 9865 | .{ ._, ._, .add, .tmp0q, .si(16), ._, ._ }, |
| 9866 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 9867 | } }, |
| 8490 | 9868 | }, .{ |
| 8491 | 9869 | .required_features = .{ .avx, null, null, null }, |
| 8492 | 9870 | .src_constraints = .{ |
| ... | ... | @@ -8497,7 +9875,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8497 | 9875 | .{ .src = .{ .to_sse, .to_sse } }, |
| 8498 | 9876 | }, |
| 8499 | 9877 | .extra_temps = .{ |
| 8500 | | .{ .kind = .{ .rc = .sse } }, |
| 9878 | .{ .type = .f64, .kind = .{ .rc = .sse } }, |
| 8501 | 9879 | .unused, |
| 8502 | 9880 | .unused, |
| 8503 | 9881 | .unused, |
| ... | ... | @@ -8579,11 +9957,249 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8579 | 9957 | .unused, |
| 8580 | 9958 | .unused, |
| 8581 | 9959 | }, |
| 8582 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8583 | 9960 | .dst_temps = .{.{ .ref = .src0 }}, |
| 9961 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8584 | 9962 | .each = .{ .once = &.{ |
| 8585 | 9963 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 8586 | 9964 | } }, |
| 9965 | }, .{ |
| 9966 | .required_features = .{ .avx, null, null, null }, |
| 9967 | .src_constraints = .{ |
| 9968 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 9969 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 9970 | }, |
| 9971 | .patterns = &.{ |
| 9972 | .{ .src = .{ .to_sse, .to_sse } }, |
| 9973 | }, |
| 9974 | .extra_temps = .{ |
| 9975 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 9976 | .unused, |
| 9977 | .unused, |
| 9978 | .unused, |
| 9979 | .unused, |
| 9980 | .unused, |
| 9981 | .unused, |
| 9982 | .unused, |
| 9983 | .unused, |
| 9984 | }, |
| 9985 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 9986 | .each = .{ .once = &.{ |
| 9987 | .{ ._, .v_pd, .cmp, .tmp0x, .src0x, .src0x, .vp(.unord) }, |
| 9988 | .{ ._, .v_pd, .min, .dst0x, .src1x, .src0x, ._ }, |
| 9989 | .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .src1x, .tmp0x }, |
| 9990 | } }, |
| 9991 | }, .{ |
| 9992 | .required_features = .{ .sse4_1, null, null, null }, |
| 9993 | .src_constraints = .{ |
| 9994 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 9995 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 9996 | }, |
| 9997 | .patterns = &.{ |
| 9998 | .{ .src = .{ .{ .to_reg = .xmm0 }, .mem } }, |
| 9999 | .{ .src = .{ .mem, .{ .to_reg = .xmm0 } }, .commute = .{ 0, 1 } }, |
| 10000 | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse } }, |
| 10001 | }, |
| 10002 | .dst_temps = .{.{ .rc = .sse }}, |
| 10003 | .each = .{ .once = &.{ |
| 10004 | .{ ._, ._pd, .mova, .dst0x, .src1x, ._, ._ }, |
| 10005 | .{ ._, ._pd, .min, .dst0x, .src0x, ._, ._ }, |
| 10006 | .{ ._, ._pd, .cmp, .src0x, .src0x, .vp(.unord), ._ }, |
| 10007 | .{ ._, ._pd, .blendv, .dst0x, .src1x, .src0x, ._ }, |
| 10008 | } }, |
| 10009 | }, .{ |
| 10010 | .required_features = .{ .sse2, null, null, null }, |
| 10011 | .src_constraints = .{ |
| 10012 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 10013 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 10014 | }, |
| 10015 | .patterns = &.{ |
| 10016 | .{ .src = .{ .to_mut_sse, .mem } }, |
| 10017 | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 10018 | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 10019 | }, |
| 10020 | .extra_temps = .{ |
| 10021 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 10022 | .unused, |
| 10023 | .unused, |
| 10024 | .unused, |
| 10025 | .unused, |
| 10026 | .unused, |
| 10027 | .unused, |
| 10028 | .unused, |
| 10029 | .unused, |
| 10030 | }, |
| 10031 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10032 | .each = .{ .once = &.{ |
| 10033 | .{ ._, ._pd, .mova, .tmp0x, .src1x, ._, ._ }, |
| 10034 | .{ ._, ._pd, .min, .tmp0x, .src0x, ._, ._ }, |
| 10035 | .{ ._, ._pd, .cmp, .dst0x, .src0x, .vp(.ord), ._ }, |
| 10036 | .{ ._, ._pd, .@"and", .tmp0x, .dst0x, ._, ._ }, |
| 10037 | .{ ._, ._pd, .andn, .dst0x, .src1x, ._, ._ }, |
| 10038 | .{ ._, ._pd, .@"or", .dst0x, .tmp0x, ._, ._ }, |
| 10039 | } }, |
| 10040 | }, .{ |
| 10041 | .required_features = .{ .avx, null, null, null }, |
| 10042 | .src_constraints = .{ |
| 10043 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 10044 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 10045 | }, |
| 10046 | .patterns = &.{ |
| 10047 | .{ .src = .{ .to_sse, .to_sse } }, |
| 10048 | }, |
| 10049 | .extra_temps = .{ |
| 10050 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 10051 | .unused, |
| 10052 | .unused, |
| 10053 | .unused, |
| 10054 | .unused, |
| 10055 | .unused, |
| 10056 | .unused, |
| 10057 | .unused, |
| 10058 | .unused, |
| 10059 | }, |
| 10060 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 10061 | .each = .{ .once = &.{ |
| 10062 | .{ ._, .v_pd, .cmp, .tmp0y, .src0y, .src0y, .vp(.unord) }, |
| 10063 | .{ ._, .v_pd, .min, .dst0y, .src1y, .src0y, ._ }, |
| 10064 | .{ ._, .v_pd, .blendv, .dst0y, .dst0y, .src1y, .tmp0y }, |
| 10065 | } }, |
| 10066 | }, .{ |
| 10067 | .required_features = .{ .avx, null, null, null }, |
| 10068 | .src_constraints = .{ |
| 10069 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| 10070 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| 10071 | }, |
| 10072 | .patterns = &.{ |
| 10073 | .{ .src = .{ .to_mem, .to_mem } }, |
| 10074 | }, |
| 10075 | .extra_temps = .{ |
| 10076 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10077 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 10078 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 10079 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 10080 | .unused, |
| 10081 | .unused, |
| 10082 | .unused, |
| 10083 | .unused, |
| 10084 | .unused, |
| 10085 | }, |
| 10086 | .dst_temps = .{.mem}, |
| 10087 | .clobbers = .{ .eflags = true }, |
| 10088 | .each = .{ .once = &.{ |
| 10089 | .{ ._, ._, .mov, .tmp0q, .sa(.src0, .sub_size), ._, ._ }, |
| 10090 | .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 10091 | .{ ._, .v_pd, .mova, .tmp2y, .memia(.src1y, .tmp0, .add_size), ._, ._ }, |
| 10092 | .{ ._, .v_pd, .cmp, .tmp3y, .tmp1y, .tmp1y, .vp(.unord) }, |
| 10093 | .{ ._, .v_pd, .min, .tmp1y, .tmp2y, .tmp1y, ._ }, |
| 10094 | .{ ._, .v_pd, .blendv, .tmp1y, .tmp1y, .tmp2y, .tmp3y }, |
| 10095 | .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ }, |
| 10096 | .{ ._, ._, .add, .tmp0q, .si(32), ._, ._ }, |
| 10097 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 10098 | } }, |
| 10099 | }, .{ |
| 10100 | .required_features = .{ .sse4_1, null, null, null }, |
| 10101 | .src_constraints = .{ |
| 10102 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 10103 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 10104 | }, |
| 10105 | .patterns = &.{ |
| 10106 | .{ .src = .{ .to_mem, .to_mem } }, |
| 10107 | }, |
| 10108 | .extra_temps = .{ |
| 10109 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10110 | .{ .type = .vector_2_f64, .kind = .{ .reg = .xmm0 } }, |
| 10111 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 10112 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 10113 | .unused, |
| 10114 | .unused, |
| 10115 | .unused, |
| 10116 | .unused, |
| 10117 | .unused, |
| 10118 | }, |
| 10119 | .dst_temps = .{.mem}, |
| 10120 | .clobbers = .{ .eflags = true }, |
| 10121 | .each = .{ .once = &.{ |
| 10122 | .{ ._, ._, .mov, .tmp0q, .sa(.src0, .sub_size), ._, ._ }, |
| 10123 | .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 10124 | .{ ._, ._pd, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 10125 | .{ ._, ._pd, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 10126 | .{ ._, ._pd, .min, .tmp3x, .tmp1x, ._, ._ }, |
| 10127 | .{ ._, ._pd, .cmp, .tmp1x, .tmp1x, .vp(.unord), ._ }, |
| 10128 | .{ ._, ._pd, .blendv, .tmp3x, .tmp2x, .tmp1x, ._ }, |
| 10129 | .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, |
| 10130 | .{ ._, ._, .add, .tmp0q, .si(16), ._, ._ }, |
| 10131 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 10132 | } }, |
| 10133 | }, .{ |
| 10134 | .required_features = .{ .sse2, null, null, null }, |
| 10135 | .src_constraints = .{ |
| 10136 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 10137 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 10138 | }, |
| 10139 | .patterns = &.{ |
| 10140 | .{ .src = .{ .to_mem, .to_mem } }, |
| 10141 | }, |
| 10142 | .extra_temps = .{ |
| 10143 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10144 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 10145 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 10146 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 10147 | .unused, |
| 10148 | .unused, |
| 10149 | .unused, |
| 10150 | .unused, |
| 10151 | .unused, |
| 10152 | }, |
| 10153 | .dst_temps = .{.mem}, |
| 10154 | .clobbers = .{ .eflags = true }, |
| 10155 | .each = .{ .once = &.{ |
| 10156 | .{ ._, ._, .mov, .tmp0q, .sa(.src0, .sub_size), ._, ._ }, |
| 10157 | .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 10158 | .{ ._, ._pd, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 10159 | .{ ._, ._pd, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 10160 | .{ ._, ._pd, .min, .tmp3x, .tmp1x, ._, ._ }, |
| 10161 | .{ ._, ._pd, .cmp, .tmp1x, .tmp1x, .vp(.ord), ._ }, |
| 10162 | .{ ._, ._pd, .@"and", .tmp3x, .tmp1x, ._, ._ }, |
| 10163 | .{ ._, ._pd, .andn, .tmp1x, .tmp2x, ._, ._ }, |
| 10164 | .{ ._, ._pd, .@"or", .tmp1x, .tmp3x, ._, ._ }, |
| 10165 | .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 10166 | .{ ._, ._, .add, .tmp0q, .si(16), ._, ._ }, |
| 10167 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 10168 | } }, |
| 10169 | }, .{ |
| 10170 | .required_features = .{ .sse, null, null, null }, |
| 10171 | .src_constraints = .{ |
| 10172 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 10173 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 10174 | }, |
| 10175 | .patterns = &.{ |
| 10176 | .{ .src = .{ .to_mem, .to_mem } }, |
| 10177 | }, |
| 10178 | .call_frame = .{ .alignment = .@"16" }, |
| 10179 | .extra_temps = .{ |
| 10180 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10181 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 10182 | .{ .type = .f64, .kind = .{ .reg = .xmm1 } }, |
| 10183 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmin" } } }, |
| 10184 | .unused, |
| 10185 | .unused, |
| 10186 | .unused, |
| 10187 | .unused, |
| 10188 | .unused, |
| 10189 | }, |
| 10190 | .dst_temps = .{.mem}, |
| 10191 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 10192 | .each = .{ .once = &.{ |
| 10193 | .{ ._, ._, .mov, .tmp0q, .sa(.src0, .sub_size), ._, ._ }, |
| 10194 | .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 10195 | .{ ._, ._ps, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 10196 | .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 10197 | .{ ._, ._ps, .movl, .tmp2x, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 10198 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 10199 | .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, |
| 10200 | .{ ._, ._, .add, .tmp0q, .si(8), ._, ._ }, |
| 10201 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 10202 | } }, |
| 8587 | 10203 | }, .{ |
| 8588 | 10204 | .required_features = .{ .x87, .cmov, null, null }, |
| 8589 | 10205 | .src_constraints = .{ |
| ... | ... | @@ -8730,6 +10346,164 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8730 | 10346 | .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, |
| 8731 | 10347 | .{ .@"1:", .f_p, .st, .dst0t, ._, ._, ._ }, |
| 8732 | 10348 | } }, |
| 10349 | }, .{ |
| 10350 | .required_features = .{ .x87, .cmov, null, null }, |
| 10351 | .src_constraints = .{ |
| 10352 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 10353 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 10354 | }, |
| 10355 | .patterns = &.{ |
| 10356 | .{ .src = .{ .to_mem, .to_mem } }, |
| 10357 | }, |
| 10358 | .extra_temps = .{ |
| 10359 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10360 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 10361 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 10362 | .unused, |
| 10363 | .unused, |
| 10364 | .unused, |
| 10365 | .unused, |
| 10366 | .unused, |
| 10367 | .unused, |
| 10368 | }, |
| 10369 | .dst_temps = .{.mem}, |
| 10370 | .clobbers = .{ .eflags = true }, |
| 10371 | .each = .{ .once = &.{ |
| 10372 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 10373 | .{ .@"0:", .f_, .ld, .memia(.src1t, .tmp0, .add_size), ._, ._, ._ }, |
| 10374 | .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ }, |
| 10375 | .{ ._, .f_, .ucomi, .tmp1t, .tmp1t, ._, ._ }, |
| 10376 | .{ ._, .f_u, .cmov, .tmp1t, .tmp2t, ._, ._ }, |
| 10377 | .{ ._, .f_, .ucomi, .tmp1t, .tmp2t, ._, ._ }, |
| 10378 | .{ ._, .f_nb, .cmov, .tmp1t, .tmp2t, ._, ._ }, |
| 10379 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_size), ._, ._, ._ }, |
| 10380 | .{ ._, .f_p, .st, .tmp2t, ._, ._, ._ }, |
| 10381 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 10382 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 10383 | } }, |
| 10384 | }, .{ |
| 10385 | .required_features = .{ .sahf, .x87, null, null }, |
| 10386 | .src_constraints = .{ |
| 10387 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 10388 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 10389 | }, |
| 10390 | .patterns = &.{ |
| 10391 | .{ .src = .{ .to_mem, .to_mem } }, |
| 10392 | }, |
| 10393 | .extra_temps = .{ |
| 10394 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10395 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 10396 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 10397 | .{ .type = .u8, .kind = .{ .reg = .ah } }, |
| 10398 | .unused, |
| 10399 | .unused, |
| 10400 | .unused, |
| 10401 | .unused, |
| 10402 | .unused, |
| 10403 | }, |
| 10404 | .dst_temps = .{.mem}, |
| 10405 | .clobbers = .{ .eflags = true }, |
| 10406 | .each = .{ .once = &.{ |
| 10407 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 10408 | .{ .@"0:", .f_, .ld, .memia(.src1t, .tmp0, .add_size), ._, ._, ._ }, |
| 10409 | .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ }, |
| 10410 | .{ ._, .f_, .ucom, .tmp1t, ._, ._, ._ }, |
| 10411 | .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ }, |
| 10412 | .{ ._, ._, .sahf, ._, ._, ._, ._ }, |
| 10413 | .{ ._, ._p, .j, .@"1f", ._, ._, ._ }, |
| 10414 | .{ ._, .f_, .ucom, .tmp2t, ._, ._, ._ }, |
| 10415 | .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ }, |
| 10416 | .{ ._, ._, .sahf, ._, ._, ._, ._ }, |
| 10417 | .{ ._, ._b, .j, .@"2f", ._, ._, ._ }, |
| 10418 | .{ .@"1:", .f_p, .st, .tmp1t, ._, ._, ._ }, |
| 10419 | .{ ._, .f_, .ld, .tmp2t, ._, ._, ._ }, |
| 10420 | .{ .@"2:", .f_p, .st, .memia(.dst0t, .tmp0, .add_size), ._, ._, ._ }, |
| 10421 | .{ ._, .f_p, .st, .tmp2t, ._, ._, ._ }, |
| 10422 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 10423 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 10424 | } }, |
| 10425 | }, .{ |
| 10426 | .required_features = .{ .@"64bit", .x87, null, null }, |
| 10427 | .src_constraints = .{ |
| 10428 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 10429 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 10430 | }, |
| 10431 | .patterns = &.{ |
| 10432 | .{ .src = .{ .to_mem, .to_mem } }, |
| 10433 | }, |
| 10434 | .extra_temps = .{ |
| 10435 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10436 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 10437 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 10438 | .{ .type = .u8, .kind = .{ .reg = .ah } }, |
| 10439 | .unused, |
| 10440 | .unused, |
| 10441 | .unused, |
| 10442 | .unused, |
| 10443 | .unused, |
| 10444 | }, |
| 10445 | .dst_temps = .{.mem}, |
| 10446 | .clobbers = .{ .eflags = true }, |
| 10447 | .each = .{ .once = &.{ |
| 10448 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 10449 | .{ .@"0:", .f_, .ld, .memia(.src1t, .tmp0, .add_size), ._, ._, ._ }, |
| 10450 | .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ }, |
| 10451 | .{ ._, .f_, .xam, ._, ._, ._, ._ }, |
| 10452 | .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ }, |
| 10453 | .{ ._, ._, .@"test", .tmp3b, .si(0b0_1_000_100), ._, ._ }, |
| 10454 | .{ ._, ._z, .j, .@"1f", ._, ._, ._ }, |
| 10455 | .{ ._, .f_, .ucom, .tmp2t, ._, ._, ._ }, |
| 10456 | .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ }, |
| 10457 | .{ ._, ._, .@"test", .tmp3b, .si(0b0_0_000_001), ._, ._ }, |
| 10458 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| 10459 | .{ .@"1:", .f_p, .st, .tmp1t, ._, ._, ._ }, |
| 10460 | .{ ._, .f_, .ld, .tmp2t, ._, ._, ._ }, |
| 10461 | .{ .@"2:", .f_p, .st, .memia(.dst0t, .tmp0, .add_size), ._, ._, ._ }, |
| 10462 | .{ ._, .f_p, .st, .tmp2t, ._, ._, ._ }, |
| 10463 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 10464 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 10465 | } }, |
| 10466 | }, .{ |
| 10467 | .required_features = .{ .x87, null, null, null }, |
| 10468 | .src_constraints = .{ |
| 10469 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 10470 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 10471 | }, |
| 10472 | .patterns = &.{ |
| 10473 | .{ .src = .{ .to_mem, .to_mem } }, |
| 10474 | }, |
| 10475 | .extra_temps = .{ |
| 10476 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10477 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 10478 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 10479 | .{ .type = .u8, .kind = .{ .reg = .ah } }, |
| 10480 | .unused, |
| 10481 | .unused, |
| 10482 | .unused, |
| 10483 | .unused, |
| 10484 | .unused, |
| 10485 | }, |
| 10486 | .dst_temps = .{.mem}, |
| 10487 | .clobbers = .{ .eflags = true }, |
| 10488 | .each = .{ .once = &.{ |
| 10489 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 10490 | .{ .@"0:", .f_, .ld, .memia(.src1t, .tmp0, .add_size), ._, ._, ._ }, |
| 10491 | .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ }, |
| 10492 | .{ ._, .f_, .ucom, .tmp1t, ._, ._, ._ }, |
| 10493 | .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ }, |
| 10494 | .{ ._, ._, .sahf, ._, ._, ._, ._ }, |
| 10495 | .{ ._, ._p, .j, .@"1f", ._, ._, ._ }, |
| 10496 | .{ ._, .f_, .ucom, .tmp2t, ._, ._, ._ }, |
| 10497 | .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ }, |
| 10498 | .{ ._, ._, .sahf, ._, ._, ._, ._ }, |
| 10499 | .{ ._, ._b, .j, .@"2f", ._, ._, ._ }, |
| 10500 | .{ .@"1:", .f_p, .st, .tmp1t, ._, ._, ._ }, |
| 10501 | .{ ._, .f_, .ld, .tmp2t, ._, ._, ._ }, |
| 10502 | .{ .@"2:", .f_p, .st, .memia(.dst0t, .tmp0, .add_size), ._, ._, ._ }, |
| 10503 | .{ ._, .f_p, .st, .tmp2t, ._, ._, ._ }, |
| 10504 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 10505 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 10506 | } }, |
| 8733 | 10507 | }, .{ |
| 8734 | 10508 | .required_features = .{ .sse, null, null, null }, |
| 8735 | 10509 | .src_constraints = .{ |
| ... | ... | @@ -8751,11 +10525,107 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8751 | 10525 | .unused, |
| 8752 | 10526 | .unused, |
| 8753 | 10527 | }, |
| 8754 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8755 | 10528 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10529 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8756 | 10530 | .each = .{ .once = &.{ |
| 8757 | 10531 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 8758 | 10532 | } }, |
| 10533 | }, .{ |
| 10534 | .required_features = .{ .avx, null, null, null }, |
| 10535 | .src_constraints = .{ |
| 10536 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 10537 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 10538 | }, |
| 10539 | .patterns = &.{ |
| 10540 | .{ .src = .{ .to_mem, .to_mem } }, |
| 10541 | }, |
| 10542 | .call_frame = .{ .alignment = .@"16" }, |
| 10543 | .extra_temps = .{ |
| 10544 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10545 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 10546 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 10547 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fminq" } } }, |
| 10548 | .unused, |
| 10549 | .unused, |
| 10550 | .unused, |
| 10551 | .unused, |
| 10552 | .unused, |
| 10553 | }, |
| 10554 | .dst_temps = .{.mem}, |
| 10555 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 10556 | .each = .{ .once = &.{ |
| 10557 | .{ ._, ._, .mov, .tmp0q, .sa(.src0, .sub_size), ._, ._ }, |
| 10558 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 10559 | .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 10560 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 10561 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 10562 | .{ ._, ._, .add, .tmp0q, .si(16), ._, ._ }, |
| 10563 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 10564 | } }, |
| 10565 | }, .{ |
| 10566 | .required_features = .{ .sse2, null, null, null }, |
| 10567 | .src_constraints = .{ |
| 10568 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 10569 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 10570 | }, |
| 10571 | .patterns = &.{ |
| 10572 | .{ .src = .{ .to_mem, .to_mem } }, |
| 10573 | }, |
| 10574 | .call_frame = .{ .alignment = .@"16" }, |
| 10575 | .extra_temps = .{ |
| 10576 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10577 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 10578 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 10579 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fminq" } } }, |
| 10580 | .unused, |
| 10581 | .unused, |
| 10582 | .unused, |
| 10583 | .unused, |
| 10584 | .unused, |
| 10585 | }, |
| 10586 | .dst_temps = .{.mem}, |
| 10587 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 10588 | .each = .{ .once = &.{ |
| 10589 | .{ ._, ._, .mov, .tmp0q, .sa(.src0, .sub_size), ._, ._ }, |
| 10590 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 10591 | .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 10592 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 10593 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 10594 | .{ ._, ._, .add, .tmp0q, .si(16), ._, ._ }, |
| 10595 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 10596 | } }, |
| 10597 | }, .{ |
| 10598 | .required_features = .{ .sse, null, null, null }, |
| 10599 | .src_constraints = .{ |
| 10600 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 10601 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 10602 | }, |
| 10603 | .patterns = &.{ |
| 10604 | .{ .src = .{ .to_mem, .to_mem } }, |
| 10605 | }, |
| 10606 | .call_frame = .{ .alignment = .@"16" }, |
| 10607 | .extra_temps = .{ |
| 10608 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10609 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 10610 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 10611 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fminq" } } }, |
| 10612 | .unused, |
| 10613 | .unused, |
| 10614 | .unused, |
| 10615 | .unused, |
| 10616 | .unused, |
| 10617 | }, |
| 10618 | .dst_temps = .{.mem}, |
| 10619 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 10620 | .each = .{ .once = &.{ |
| 10621 | .{ ._, ._, .mov, .tmp0q, .sa(.src0, .sub_size), ._, ._ }, |
| 10622 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 10623 | .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 10624 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 10625 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 10626 | .{ ._, ._, .add, .tmp0q, .si(16), ._, ._ }, |
| 10627 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 10628 | } }, |
| 8759 | 10629 | } }) catch |err| switch (err) { |
| 8760 | 10630 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 8761 | 10631 | @tagName(air_tag), |
| ... | ... | @@ -8955,7 +10825,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8955 | 10825 | }, |
| 8956 | 10826 | .extra_temps = .{ |
| 8957 | 10827 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8958 | | .{ .kind = .{ .rc = .sse } }, |
| 10828 | .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, |
| 8959 | 10829 | .unused, |
| 8960 | 10830 | .unused, |
| 8961 | 10831 | .unused, |
| ... | ... | @@ -8982,7 +10852,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8982 | 10852 | }, |
| 8983 | 10853 | .extra_temps = .{ |
| 8984 | 10854 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8985 | | .{ .kind = .{ .rc = .sse } }, |
| 10855 | .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, |
| 8986 | 10856 | .unused, |
| 8987 | 10857 | .unused, |
| 8988 | 10858 | .unused, |
| ... | ... | @@ -9009,7 +10879,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9009 | 10879 | }, |
| 9010 | 10880 | .extra_temps = .{ |
| 9011 | 10881 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 9012 | | .{ .kind = .{ .rc = .sse } }, |
| 10882 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 9013 | 10883 | .unused, |
| 9014 | 10884 | .unused, |
| 9015 | 10885 | .unused, |
| ... | ... | @@ -9036,7 +10906,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9036 | 10906 | }, |
| 9037 | 10907 | .extra_temps = .{ |
| 9038 | 10908 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 9039 | | .{ .kind = .{ .rc = .sse } }, |
| 10909 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 9040 | 10910 | .unused, |
| 9041 | 10911 | .unused, |
| 9042 | 10912 | .unused, |
| ... | ... | @@ -9063,7 +10933,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9063 | 10933 | }, |
| 9064 | 10934 | .extra_temps = .{ |
| 9065 | 10935 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 9066 | | .{ .kind = .{ .rc = .sse } }, |
| 10936 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 9067 | 10937 | .unused, |
| 9068 | 10938 | .unused, |
| 9069 | 10939 | .unused, |
| ... | ... | @@ -15226,8 +17096,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15226 | 17096 | .info = .{ .kind = .all, .scalar = .dword }, |
| 15227 | 17097 | } }}, |
| 15228 | 17098 | .each = .{ .once = &.{ |
| 15229 | | .{ ._, .v_ps, .cvtph2, .dst0x, .src0x, ._, ._ }, |
| 15230 | | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1x, ._, ._ }, |
| 17099 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 17100 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 15231 | 17101 | .{ ._, .v_ss, .cmp, .dst0x, .dst0x, .tmp0x, .vp(switch (cc) { |
| 15232 | 17102 | else => unreachable, |
| 15233 | 17103 | .e => .eq, |
| ... | ... | @@ -15815,7 +17685,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15815 | 17685 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 15816 | 17686 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 15817 | 17687 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| 15818 | | .{ .type = .vector_8_f16, .kind = .mem }, |
| 17688 | .{ .type = .f32, .kind = .mem }, |
| 15819 | 17689 | .unused, |
| 15820 | 17690 | }, |
| 15821 | 17691 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| ... | ... | @@ -15825,10 +17695,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15825 | 17695 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 15826 | 17696 | .{ .@"0:", ._, .movzx, .tmp4d, .memsi(.src0w, .@"2", .tmp0), ._, ._ }, |
| 15827 | 17697 | .{ ._, ._, .mov, .mem(.tmp7d), .tmp4d, ._, ._ }, |
| 15828 | | .{ ._, ._ps, .mova, .tmp1x, .mem(.tmp7x), ._, ._ }, |
| 17698 | .{ ._, ._ss, .mov, .tmp1x, .mem(.tmp7d), ._, ._ }, |
| 15829 | 17699 | .{ ._, ._, .movzx, .tmp4d, .memsi(.src1w, .@"2", .tmp0), ._, ._ }, |
| 15830 | 17700 | .{ ._, ._, .mov, .mem(.tmp7d), .tmp4d, ._, ._ }, |
| 15831 | | .{ ._, ._ps, .mova, .tmp2x, .mem(.tmp7x), ._, ._ }, |
| 17701 | .{ ._, ._ss, .mov, .tmp2x, .mem(.tmp7d), ._, ._ }, |
| 15832 | 17702 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 15833 | 17703 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| 15834 | 17704 | .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ }, |
| ... | ... | @@ -15863,7 +17733,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15863 | 17733 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 15864 | 17734 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 15865 | 17735 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| 15866 | | .{ .type = .vector_8_f16, .kind = .mem }, |
| 17736 | .{ .type = .f32, .kind = .mem }, |
| 15867 | 17737 | .unused, |
| 15868 | 17738 | }, |
| 15869 | 17739 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| ... | ... | @@ -15873,10 +17743,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15873 | 17743 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 15874 | 17744 | .{ .@"0:", ._, .movzx, .tmp4d, .memsi(.src0w, .@"2", .tmp0), ._, ._ }, |
| 15875 | 17745 | .{ ._, ._, .mov, .mem(.tmp7d), .tmp4d, ._, ._ }, |
| 15876 | | .{ ._, ._ps, .mova, .tmp1x, .mem(.tmp7x), ._, ._ }, |
| 17746 | .{ ._, ._ss, .mov, .tmp1x, .mem(.tmp7d), ._, ._ }, |
| 15877 | 17747 | .{ ._, ._, .movzx, .tmp4d, .memsi(.src1w, .@"2", .tmp0), ._, ._ }, |
| 15878 | 17748 | .{ ._, ._, .mov, .mem(.tmp7d), .tmp4d, ._, ._ }, |
| 15879 | | .{ ._, ._ps, .mova, .tmp2x, .mem(.tmp7x), ._, ._ }, |
| 17749 | .{ ._, ._ss, .mov, .tmp2x, .mem(.tmp7d), ._, ._ }, |
| 15880 | 17750 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 15881 | 17751 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| 15882 | 17752 | .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ }, |
| ... | ... | @@ -16133,7 +18003,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16133 | 18003 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 16134 | 18004 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 16135 | 18005 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 16136 | | .{ .type = .vector_8_f16, .kind = .mem }, |
| 18006 | .{ .type = .f32, .kind = .mem }, |
| 16137 | 18007 | }, |
| 16138 | 18008 | .dst_temps = .{.mem}, |
| 16139 | 18009 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| ... | ... | @@ -16142,10 +18012,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16142 | 18012 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 16143 | 18013 | .{ .@"0:", ._, .movzx, .tmp5d, .memsi(.src0w, .@"2", .tmp0), ._, ._ }, |
| 16144 | 18014 | .{ ._, ._, .mov, .mem(.tmp8d), .tmp5d, ._, ._ }, |
| 16145 | | .{ ._, ._ps, .mova, .tmp2x, .mem(.tmp8x), ._, ._ }, |
| 18015 | .{ ._, ._ss, .mov, .tmp2x, .mem(.tmp8d), ._, ._ }, |
| 16146 | 18016 | .{ ._, ._, .movzx, .tmp5d, .memsi(.src1w, .@"2", .tmp0), ._, ._ }, |
| 16147 | 18017 | .{ ._, ._, .mov, .mem(.tmp8d), .tmp5d, ._, ._ }, |
| 16148 | | .{ ._, ._ps, .mova, .tmp3x, .mem(.tmp8x), ._, ._ }, |
| 18018 | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp8d), ._, ._ }, |
| 16149 | 18019 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 16150 | 18020 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| 16151 | 18021 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, |
| ... | ... | @@ -16191,7 +18061,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16191 | 18061 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 16192 | 18062 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 16193 | 18063 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 16194 | | .{ .type = .vector_8_f16, .kind = .mem }, |
| 18064 | .{ .type = .f32, .kind = .mem }, |
| 16195 | 18065 | }, |
| 16196 | 18066 | .dst_temps = .{.mem}, |
| 16197 | 18067 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| ... | ... | @@ -16200,10 +18070,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16200 | 18070 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 16201 | 18071 | .{ .@"0:", ._, .movzx, .tmp5d, .memsi(.src0w, .@"2", .tmp0), ._, ._ }, |
| 16202 | 18072 | .{ ._, ._, .mov, .mem(.tmp8d), .tmp5d, ._, ._ }, |
| 16203 | | .{ ._, ._ps, .mova, .tmp2x, .mem(.tmp8x), ._, ._ }, |
| 18073 | .{ ._, ._ss, .mov, .tmp2x, .mem(.tmp8d), ._, ._ }, |
| 16204 | 18074 | .{ ._, ._, .movzx, .tmp5d, .memsi(.src1w, .@"2", .tmp0), ._, ._ }, |
| 16205 | 18075 | .{ ._, ._, .mov, .mem(.tmp8d), .tmp5d, ._, ._ }, |
| 16206 | | .{ ._, ._ps, .mova, .tmp3x, .mem(.tmp8x), ._, ._ }, |
| 18076 | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp8d), ._, ._ }, |
| 16207 | 18077 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 16208 | 18078 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| 16209 | 18079 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, |
| ... | ... | @@ -16482,7 +18352,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16482 | 18352 | .{ ._, ._, .@"or", .tmp4b, .tmp5b, ._, ._ }, |
| 16483 | 18353 | .{ ._, ._, .mov, .lea(.byte, .tmp1), .tmp4b, ._, ._ }, |
| 16484 | 18354 | .{ ._, ._, .lea, .tmp1p, .lead(.none, .tmp1, 1), ._, ._ }, |
| 16485 | | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 18355 | .{ ._, ._, .add, .tmp0p, .si(64), ._, ._ }, |
| 16486 | 18356 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 16487 | 18357 | } }, |
| 16488 | 18358 | }, .{ |
| ... | ... | @@ -16528,7 +18398,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16528 | 18398 | .{ ._, ._, .@"or", .tmp4b, .tmp5b, ._, ._ }, |
| 16529 | 18399 | .{ ._, ._, .mov, .lea(.byte, .tmp1), .tmp4b, ._, ._ }, |
| 16530 | 18400 | .{ ._, ._c, .in, .tmp1q, ._, ._, ._ }, |
| 16531 | | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 18401 | .{ ._, ._, .add, .tmp0p, .si(64), ._, ._ }, |
| 16532 | 18402 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 16533 | 18403 | } }, |
| 16534 | 18404 | }, .{ |
| ... | ... | @@ -19809,8 +21679,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19809 | 21679 | } }}, |
| 19810 | 21680 | .clobbers = .{ .eflags = true }, |
| 19811 | 21681 | .each = .{ .once = &.{ |
| 19812 | | .{ ._, .v_ps, .cvtph2, .tmp0x, .src0x, ._, ._ }, |
| 19813 | | .{ ._, .v_ps, .cvtph2, .tmp1x, .src1x, ._, ._ }, |
| 21682 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src0q, ._, ._ }, |
| 21683 | .{ ._, .v_ps, .cvtph2, .tmp1x, .src1q, ._, ._ }, |
| 19814 | 21684 | .{ ._, .v_ss, .ucomi, .tmp0x, .tmp1x, ._, ._ }, |
| 19815 | 21685 | } }, |
| 19816 | 21686 | }, .{ |
| ... | ... | @@ -21194,19 +23064,21 @@ fn allocRegOrMemAdvanced(self: *CodeGen, ty: Type, inst: ?Air.Inst.Index, reg_ok |
| 21194 | 23064 | }; |
| 21195 | 23065 | |
| 21196 | 23066 | if (reg_ok) need_mem: { |
| 21197 | | if (std.math.isPowerOfTwo(abi_size) and abi_size <= @as(u32, switch (ty.zigTypeTag(zcu)) { |
| 23067 | if (std.math.isPowerOfTwo(abi_size) and abi_size <= @as(u32, max_abi_size: switch (ty.zigTypeTag(zcu)) { |
| 21198 | 23068 | .float => switch (ty.floatBits(self.target.*)) { |
| 21199 | 23069 | 16, 32, 64, 128 => 16, |
| 21200 | 23070 | 80 => break :need_mem, |
| 21201 | 23071 | else => unreachable, |
| 21202 | 23072 | }, |
| 21203 | | .vector => switch (ty.childType(zcu).zigTypeTag(zcu)) { |
| 21204 | | .float => switch (ty.childType(zcu).floatBits(self.target.*)) { |
| 23073 | .vector => { |
| 23074 | const elem_ty = ty.childType(zcu); |
| 23075 | break :max_abi_size if (elem_ty.toIntern() == .bool_type) |
| 23076 | 8 |
| 23077 | else if (self.floatBits(elem_ty)) |float_bits| switch (float_bits) { |
| 21205 | 23078 | 16, 32, 64, 128 => self.vectorSize(.float), |
| 21206 | 23079 | 80 => break :need_mem, |
| 21207 | 23080 | else => unreachable, |
| 21208 | | }, |
| 21209 | | else => self.vectorSize(.int), |
| 23081 | } else self.vectorSize(.int); |
| 21210 | 23082 | }, |
| 21211 | 23083 | else => 8, |
| 21212 | 23084 | })) { |
| ... | ... | @@ -21223,17 +23095,18 @@ fn allocRegOrMemAdvanced(self: *CodeGen, ty: Type, inst: ?Air.Inst.Index, reg_ok |
| 21223 | 23095 | fn regClassForType(self: *CodeGen, ty: Type) Register.Class { |
| 21224 | 23096 | const pt = self.pt; |
| 21225 | 23097 | const zcu = pt.zcu; |
| 21226 | | return switch (ty.zigTypeTag(zcu)) { |
| 21227 | | .float => switch (ty.floatBits(self.target.*)) { |
| 21228 | | 80 => .x87, |
| 21229 | | else => .sse, |
| 21230 | | }, |
| 21231 | | .vector => switch (ty.childType(zcu).toIntern()) { |
| 21232 | | .bool_type => .general_purpose, |
| 21233 | | else => .sse, |
| 21234 | | }, |
| 21235 | | else => .general_purpose, |
| 23098 | if (self.floatBits(ty)) |float_bits| return switch (float_bits) { |
| 23099 | 80 => .x87, |
| 23100 | else => .sse, |
| 21236 | 23101 | }; |
| 23102 | if (!ty.isVector(zcu)) return .general_purpose; |
| 23103 | const elem_ty = ty.childType(zcu); |
| 23104 | return if (elem_ty.toIntern() == .bool_type) |
| 23105 | .general_purpose |
| 23106 | else if (self.floatBits(elem_ty) == 80) |
| 23107 | .x87 |
| 23108 | else |
| 23109 | .sse; |
| 21237 | 23110 | } |
| 21238 | 23111 | |
| 21239 | 23112 | fn regSetForRegClass(rc: Register.Class) RegisterManager.RegisterBitSet { |
| ... | ... | @@ -33370,10 +35243,21 @@ const MoveStrategy = union(enum) { |
| 33370 | 35243 | else => dst_reg, |
| 33371 | 35244 | .lea => if (dst_reg.bitSize() >= 32) dst_reg else dst_reg.to32(), |
| 33372 | 35245 | }, src_mem), |
| 33373 | | .x87_load_store => { |
| 35246 | .x87_load_store => if (dst_reg != .st0 and self.register_manager.isKnownRegFree(.st7)) { |
| 35247 | try self.asmMemory(.{ .f_, .ld }, src_mem); |
| 35248 | switch (dst_reg) { |
| 35249 | .st1, .st2, .st3, .st4, .st5, .st6 => try self.asmRegister(.{ .f_p, .st }, @enumFromInt(@intFromEnum(dst_reg) + 1)), |
| 35250 | .st7 => try self.asmOpOnly(.{ .f_cstp, .in }), |
| 35251 | else => unreachable, |
| 35252 | } |
| 35253 | } else { |
| 35254 | try self.asmRegister(.{ .f_p, .st }, dst_reg); |
| 33374 | 35255 | try self.asmMemory(.{ .f_, .ld }, src_mem); |
| 33375 | | assert(dst_reg != .st7); |
| 33376 | | try self.asmRegister(.{ .f_p, .st }, @enumFromInt(@intFromEnum(dst_reg) + 1)); |
| 35256 | switch (dst_reg) { |
| 35257 | .st0 => {}, |
| 35258 | .st1, .st2, .st3, .st4, .st5, .st6, .st7 => try self.asmRegister(.{ .f_, .xch }, dst_reg), |
| 35259 | else => unreachable, |
| 35260 | } |
| 33377 | 35261 | }, |
| 33378 | 35262 | .insert_extract => |ie| if (ie.insert[0] != .p_w or self.hasFeature(.sse2)) |
| 33379 | 35263 | try self.asmRegisterMemoryImmediate(ie.insert, dst_reg, src_mem, .u(0)) |
| ... | ... | @@ -33405,9 +35289,22 @@ const MoveStrategy = union(enum) { |
| 33405 | 35289 | pub fn write(strat: MoveStrategy, self: *CodeGen, dst_mem: Memory, src_reg: Register) !void { |
| 33406 | 35290 | switch (strat) { |
| 33407 | 35291 | .move => |tag| try self.asmMemoryRegister(tag, dst_mem, src_reg), |
| 33408 | | .x87_load_store => { |
| 35292 | .x87_load_store => if (self.register_manager.isKnownRegFree(.st7)) { |
| 33409 | 35293 | try self.asmRegister(.{ .f_, .ld }, src_reg); |
| 33410 | 35294 | try self.asmMemory(.{ .f_p, .st }, dst_mem); |
| 35295 | } else { |
| 35296 | switch (src_reg) { |
| 35297 | .st0 => {}, |
| 35298 | .st1, .st2, .st3, .st4, .st5, .st6, .st7 => try self.asmRegister(.{ .f_, .xch }, src_reg), |
| 35299 | else => unreachable, |
| 35300 | } |
| 35301 | try self.asmMemory(.{ .f_p, .st }, dst_mem); |
| 35302 | try self.asmMemory(.{ .f_, .ld }, dst_mem); |
| 35303 | switch (src_reg) { |
| 35304 | .st0 => {}, |
| 35305 | .st1, .st2, .st3, .st4, .st5, .st6, .st7 => try self.asmRegister(.{ .f_, .xch }, src_reg), |
| 35306 | else => unreachable, |
| 35307 | } |
| 33411 | 35308 | }, |
| 33412 | 35309 | .insert_extract, .vex_insert_extract => |ie| if (ie.extract[0] != .p_w or self.hasFeature(.sse4_1)) |
| 33413 | 35310 | try self.asmMemoryRegisterImmediate(ie.extract, dst_mem, src_reg, .u(0)) |
| ... | ... | @@ -33964,10 +35861,25 @@ fn genSetReg( |
| 33964 | 35861 | .general_purpose, .segment => unreachable, |
| 33965 | 35862 | .x87 => switch (src_reg) { |
| 33966 | 35863 | .st0 => try self.asmRegister(.{ .f_, .st }, dst_reg), |
| 33967 | | .st1, .st2, .st3, .st4, .st5, .st6 => { |
| 33968 | | try self.asmRegister(.{ .f_, .ld }, src_reg); |
| 33969 | | assert(dst_reg != .st7); |
| 33970 | | try self.asmRegister(.{ .f_p, .st }, @enumFromInt(@intFromEnum(dst_reg) + 1)); |
| 35864 | .st1, .st2, .st3, .st4, .st5, .st6 => switch (dst_reg) { |
| 35865 | .st0 => { |
| 35866 | try self.asmRegister(.{ .f_p, .st }, .st0); |
| 35867 | try self.asmRegister(.{ .f_, .ld }, @enumFromInt(@intFromEnum(src_reg) - 1)); |
| 35868 | }, |
| 35869 | .st2, .st3, .st4, .st5, .st6 => if (self.register_manager.isKnownRegFree(.st7)) { |
| 35870 | try self.asmRegister(.{ .f_, .ld }, src_reg); |
| 35871 | try self.asmRegister(.{ .f_p, .st }, @enumFromInt(@intFromEnum(dst_reg) + 1)); |
| 35872 | } else { |
| 35873 | try self.asmRegister(.{ .f_, .xch }, src_reg); |
| 35874 | try self.asmRegister(.{ .f_, .xch }, dst_reg); |
| 35875 | try self.asmRegister(.{ .f_, .xch }, src_reg); |
| 35876 | }, |
| 35877 | .st7 => { |
| 35878 | if (!self.register_manager.isKnownRegFree(.st7)) try self.asmRegister(.{ .f_, .free }, dst_reg); |
| 35879 | try self.asmRegister(.{ .f_, .ld }, src_reg); |
| 35880 | try self.asmOpOnly(.{ .f_cstp, .in }); |
| 35881 | }, |
| 35882 | else => unreachable, |
| 33971 | 35883 | }, |
| 33972 | 35884 | else => unreachable, |
| 33973 | 35885 | }, |
| ... | ... | @@ -33993,10 +35905,14 @@ fn genSetReg( |
| 33993 | 35905 | .base = .{ .frame = frame_index }, |
| 33994 | 35906 | .mod = .{ .rm = .{ .size = .fromSize(abi_size) } }, |
| 33995 | 35907 | }, registerAlias(src_reg, abi_size)); |
| 35908 | switch (frame_size) { |
| 35909 | else => {}, |
| 35910 | 8 => try self.asmRegisterRegister(.{ ._ps, .xor }, dst_reg.to128(), dst_reg.to128()), |
| 35911 | } |
| 33996 | 35912 | try self.asmRegisterMemory(switch (frame_size) { |
| 33997 | 35913 | 4 => .{ ._ss, .mov }, |
| 33998 | 35914 | 8 => .{ ._ps, .movl }, |
| 33999 | | 16 => .{ ._ps, .mov }, |
| 35915 | 16 => .{ ._ps, .mova }, |
| 34000 | 35916 | else => unreachable, |
| 34001 | 35917 | }, dst_reg.to128(), .{ |
| 34002 | 35918 | .base = .{ .frame = frame_index }, |
| ... | ... | @@ -34009,7 +35925,26 @@ fn genSetReg( |
| 34009 | 35925 | .{ .register = try self.copyToTmpRegister(ty, src_mcv) }, |
| 34010 | 35926 | opts, |
| 34011 | 35927 | ), |
| 34012 | | .x87, .mmx, .ip, .cr, .dr => unreachable, |
| 35928 | .x87 => { |
| 35929 | const frame_index = try self.allocFrameIndex(.init(.{ |
| 35930 | .size = 16, |
| 35931 | .alignment = .@"16", |
| 35932 | })); |
| 35933 | try MoveStrategy.write(.x87_load_store, self, .{ |
| 35934 | .base = .{ .frame = frame_index }, |
| 35935 | .mod = .{ .rm = .{ .size = .tbyte } }, |
| 35936 | }, src_reg); |
| 35937 | try self.asmRegisterMemory(if (self.hasFeature(.avx)) |
| 35938 | .{ .v_dqa, .mov } |
| 35939 | else if (self.hasFeature(.sse2)) |
| 35940 | .{ ._dqa, .mov } |
| 35941 | else |
| 35942 | .{ ._ps, .mova }, dst_reg.to128(), .{ |
| 35943 | .base = .{ .frame = frame_index }, |
| 35944 | .mod = .{ .rm = .{ .size = .xword } }, |
| 35945 | }); |
| 35946 | }, |
| 35947 | .mmx, .ip, .cr, .dr => unreachable, |
| 34013 | 35948 | .sse => try self.asmRegisterRegister( |
| 34014 | 35949 | @as(?Mir.Inst.FixedTag, switch (ty.scalarType(zcu).zigTypeTag(zcu)) { |
| 34015 | 35950 | else => switch (abi_size) { |
| ... | ... | @@ -38510,7 +40445,7 @@ fn resolveCallingConventionValues( |
| 38510 | 40445 | else if (ret_gpr.len >= 2 and ret_ty.isSliceAtRuntime(zcu)) |
| 38511 | 40446 | break :return_value .init(.{ .register_pair = ret_gpr[0..2].* }), |
| 38512 | 40447 | .segment, .mmx, .ip, .cr, .dr => unreachable, |
| 38513 | | .x87 => break :return_value .init(.{ .register = .st0 }), |
| 40448 | .x87 => if (ret_size <= 16) break :return_value .init(.{ .register = .st0 }), |
| 38514 | 40449 | .sse => if (ret_size <= self.vectorSize(.float)) break :return_value .init(.{ |
| 38515 | 40450 | .register = registerAlias(abi.getCAbiSseReturnRegs(cc)[0], @max(ret_size, 16)), |
| 38516 | 40451 | }), |
| ... | ... | @@ -38545,7 +40480,7 @@ fn resolveCallingConventionValues( |
| 38545 | 40480 | continue; |
| 38546 | 40481 | }, |
| 38547 | 40482 | .segment, .mmx, .ip, .cr, .dr => unreachable, |
| 38548 | | .x87 => if (param_x87.len >= 1) { |
| 40483 | .x87 => if (param_x87.len >= 1 and param_size <= 16) { |
| 38549 | 40484 | arg.* = .{ .register = param_x87[0] }; |
| 38550 | 40485 | param_x87 = param_x87[1..]; |
| 38551 | 40486 | continue; |
| ... | ... | @@ -38656,10 +40591,12 @@ fn registerAlias(reg: Register, size_bytes: u32) Register { |
| 38656 | 40591 | |
| 38657 | 40592 | fn memSize(self: *CodeGen, ty: Type) Memory.Size { |
| 38658 | 40593 | const zcu = self.pt.zcu; |
| 38659 | | return switch (ty.zigTypeTag(zcu)) { |
| 38660 | | .float => .fromBitSize(ty.floatBits(self.target.*)), |
| 38661 | | else => .fromSize(@intCast(ty.abiSize(zcu))), |
| 38662 | | }; |
| 40594 | return if (self.floatBits(ty)) |float_bits| |
| 40595 | .fromBitSize(float_bits) |
| 40596 | else if (ty.isVector(zcu) and ty.vectorLen(zcu) == 1 and self.floatBits(ty.childType(zcu)) == 80) |
| 40597 | .tbyte |
| 40598 | else |
| 40599 | .fromSize(@intCast(ty.abiSize(zcu))); |
| 38663 | 40600 | } |
| 38664 | 40601 | |
| 38665 | 40602 | fn splitType(self: *CodeGen, comptime parts_len: usize, ty: Type) ![parts_len]Type { |
| ... | ... | @@ -40762,7 +42699,7 @@ const Select = struct { |
| 40762 | 42699 | Select.Operand, |
| 40763 | 42700 | Select.Operand, |
| 40764 | 42701 | }; |
| 40765 | | const Label = enum { @"0:", @"1:", @"_" }; |
| 42702 | const Label = enum { @"0:", @"1:", @"2:", @"_" }; |
| 40766 | 42703 | const Operand = struct { |
| 40767 | 42704 | tag: Tag, |
| 40768 | 42705 | base: Ref.Sized = .none, |
| ... | ... | @@ -40992,6 +42929,8 @@ const Select = struct { |
| 40992 | 42929 | const @"0f": Select.Operand = .{ .tag = .forward_label, .base = .{ .ref = .tmp0, .size = .none } }; |
| 40993 | 42930 | const @"1b": Select.Operand = .{ .tag = .backward_label, .base = .{ .ref = .tmp1, .size = .none } }; |
| 40994 | 42931 | const @"1f": Select.Operand = .{ .tag = .forward_label, .base = .{ .ref = .tmp1, .size = .none } }; |
| 42932 | const @"2b": Select.Operand = .{ .tag = .backward_label, .base = .{ .ref = .tmp2, .size = .none } }; |
| 42933 | const @"2f": Select.Operand = .{ .tag = .forward_label, .base = .{ .ref = .tmp2, .size = .none } }; |
| 40995 | 42934 | |
| 40996 | 42935 | const tmp0b: Select.Operand = .{ .tag = .ref, .base = .tmp0b }; |
| 40997 | 42936 | const tmp0w: Select.Operand = .{ .tag = .ref, .base = .tmp0w }; |
Jacob Young <jacobly@ziglang.org> 2025-01-26 09:05:04-05:00
src