| ... | @@ -2393,7 +2393,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2393,7 +2393,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2393 | } | 2393 | } |
| 2394 | | 2394 | |
| 2395 | fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | 2395 | fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2396 | @setEvalBranchQuota(3_600); | 2396 | @setEvalBranchQuota(3_900); |
| 2397 | const pt = cg.pt; | 2397 | const pt = cg.pt; |
| 2398 | const zcu = pt.zcu; | 2398 | const zcu = pt.zcu; |
| 2399 | const ip = &zcu.intern_pool; | 2399 | const ip = &zcu.intern_pool; |
| ... | @@ -2805,10 +2805,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2805,10 +2805,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2805 | } | 2805 | } |
| 2806 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); | 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 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; | 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 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); | 2810 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 2813 | var res: [1]Temp = undefined; | 2811 | var res: [1]Temp = undefined; |
| 2814 | cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ | 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,7 +4508,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4510 | }, | 4508 | }, |
| 4511 | .extra_temps = .{ | 4509 | .extra_temps = .{ |
| 4512 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 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 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, | 4512 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 4515 | .unused, | 4513 | .unused, |
| 4516 | .unused, | 4514 | .unused, |
| ... | @@ -4647,7 +4645,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4647,7 +4645,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4647 | }, | 4645 | }, |
| 4648 | .extra_temps = .{ | 4646 | .extra_temps = .{ |
| 4649 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 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 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, | 4649 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 4652 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, | 4650 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 4653 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, | 4651 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| ... | @@ -4967,7 +4965,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4967,7 +4965,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4967 | }, | 4965 | }, |
| 4968 | .extra_temps = .{ | 4966 | .extra_temps = .{ |
| 4969 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 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 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 4969 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 4972 | .unused, | 4970 | .unused, |
| 4973 | .unused, | 4971 | .unused, |
| ... | @@ -4998,7 +4996,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4998,7 +4996,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4998 | }, | 4996 | }, |
| 4999 | .extra_temps = .{ | 4997 | .extra_temps = .{ |
| 5000 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 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 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 5000 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 5003 | .{ .type = .vector_2_u64, .kind = .{ .reg = .xmm0 } }, | 5001 | .{ .type = .vector_2_u64, .kind = .{ .reg = .xmm0 } }, |
| 5004 | .unused, | 5002 | .unused, |
| ... | @@ -5030,7 +5028,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5030,7 +5028,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5030 | }, | 5028 | }, |
| 5031 | .extra_temps = .{ | 5029 | .extra_temps = .{ |
| 5032 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 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 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, | 5032 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 5035 | .unused, | 5033 | .unused, |
| 5036 | .unused, | 5034 | .unused, |
| ... | @@ -5059,7 +5057,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5059,7 +5057,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5059 | }, | 5057 | }, |
| 5060 | .extra_temps = .{ | 5058 | .extra_temps = .{ |
| 5061 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 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 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, | 5061 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 5064 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, | 5062 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 5065 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, | 5063 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| ... | @@ -5095,7 +5093,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5095,7 +5093,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5095 | }, | 5093 | }, |
| 5096 | .extra_temps = .{ | 5094 | .extra_temps = .{ |
| 5097 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 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 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 5097 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 5100 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 5098 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 5101 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 5099 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| ... | @@ -5131,7 +5129,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5131,7 +5129,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5131 | }, | 5129 | }, |
| 5132 | .extra_temps = .{ | 5130 | .extra_temps = .{ |
| 5133 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 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 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 5133 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 5136 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 5134 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 5137 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 5135 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| ... | @@ -5383,8 +5381,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5383,8 +5381,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5383 | .{ .src = .{ .to_sse, .to_sse } }, | 5381 | .{ .src = .{ .to_sse, .to_sse } }, |
| 5384 | }, | 5382 | }, |
| 5385 | .extra_temps = .{ | 5383 | .extra_temps = .{ |
| 5386 | .{ .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, | 5384 | .{ .type = .f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 5387 | .{ .kind = .{ .rc = .sse } }, | 5385 | .{ .type = .f16, .kind = .{ .rc = .sse } }, |
| 5388 | .unused, | 5386 | .unused, |
| 5389 | .unused, | 5387 | .unused, |
| 5390 | .unused, | 5388 | .unused, |
| ... | @@ -5395,12 +5393,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5395,12 +5393,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5395 | }, | 5393 | }, |
| 5396 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 5394 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 5397 | .each = .{ .once = &.{ | 5395 | .each = .{ .once = &.{ |
| 5398 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0x, ._, ._ }, | 5396 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 5399 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1x, ._, ._ }, | 5397 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 5400 | .{ ._, .v_ss, .cmp, .tmp1x, .dst0x, .dst0x, .vp(.unord) }, | 5398 | .{ ._, .v_ss, .cmp, .tmp1x, .dst0x, .dst0x, .vp(.unord) }, |
| 5401 | .{ ._, .v_ss, .max, .dst0x, .tmp0x, .dst0x, ._ }, | 5399 | .{ ._, .v_ss, .max, .dst0x, .tmp0x, .dst0x, ._ }, |
| 5402 | .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp0x, .tmp1x }, | 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 | .required_features = .{ .sse, null, null, null }, | 5404 | .required_features = .{ .sse, null, null, null }, |
| ... | @@ -5423,11 +5421,248 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5423,11 +5421,248 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5423 | .unused, | 5421 | .unused, |
| 5424 | .unused, | 5422 | .unused, |
| 5425 | }, | 5423 | }, |
| 5426 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | | |
| 5427 | .dst_temps = .{.{ .ref = .src0 }}, | 5424 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 5425 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5428 | .each = .{ .once = &.{ | 5426 | .each = .{ .once = &.{ |
| 5429 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, | 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 | .required_features = .{ .avx, null, null, null }, | 5667 | .required_features = .{ .avx, null, null, null }, |
| 5433 | .src_constraints = .{ | 5668 | .src_constraints = .{ |
| ... | @@ -5438,7 +5673,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5438,7 +5673,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5438 | .{ .src = .{ .to_sse, .to_sse } }, | 5673 | .{ .src = .{ .to_sse, .to_sse } }, |
| 5439 | }, | 5674 | }, |
| 5440 | .extra_temps = .{ | 5675 | .extra_temps = .{ |
| 5441 | .{ .kind = .{ .rc = .sse } }, | 5676 | .{ .type = .f32, .kind = .{ .rc = .sse } }, |
| 5442 | .unused, | 5677 | .unused, |
| 5443 | .unused, | 5678 | .unused, |
| 5444 | .unused, | 5679 | .unused, |
| ... | @@ -5499,6 +5734,210 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5499,6 +5734,210 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5499 | .{ ._, ._ps, .andn, .dst0x, .src1x, ._, ._ }, | 5734 | .{ ._, ._ps, .andn, .dst0x, .src1x, ._, ._ }, |
| 5500 | .{ ._, ._ps, .@"or", .dst0x, .tmp0x, ._, ._ }, | 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 | .required_features = .{ .avx, null, null, null }, | 5942 | .required_features = .{ .avx, null, null, null }, |
| 5504 | .src_constraints = .{ | 5943 | .src_constraints = .{ |
| ... | @@ -5509,7 +5948,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5509,7 +5948,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5509 | .{ .src = .{ .to_sse, .to_sse } }, | 5948 | .{ .src = .{ .to_sse, .to_sse } }, |
| 5510 | }, | 5949 | }, |
| 5511 | .extra_temps = .{ | 5950 | .extra_temps = .{ |
| 5512 | .{ .kind = .{ .rc = .sse } }, | 5951 | .{ .type = .f64, .kind = .{ .rc = .sse } }, |
| 5513 | .unused, | 5952 | .unused, |
| 5514 | .unused, | 5953 | .unused, |
| 5515 | .unused, | 5954 | .unused, |
| ... | @@ -5591,11 +6030,249 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5591,11 +6030,249 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5591 | .unused, | 6030 | .unused, |
| 5592 | .unused, | 6031 | .unused, |
| 5593 | }, | 6032 | }, |
| 5594 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | | |
| 5595 | .dst_temps = .{.{ .ref = .src0 }}, | 6033 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 6034 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5596 | .each = .{ .once = &.{ | 6035 | .each = .{ .once = &.{ |
| 5597 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, | 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 | .required_features = .{ .x87, .cmov, null, null }, | 6277 | .required_features = .{ .x87, .cmov, null, null }, |
| 5601 | .src_constraints = .{ | 6278 | .src_constraints = .{ |
| ... | @@ -5750,6 +6427,172 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5750,6 +6427,172 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5750 | .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, | 6427 | .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, |
| 5751 | .{ .@"1:", .f_p, .st, .dst0t, ._, ._, ._ }, | 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 | .required_features = .{ .sse, null, null, null }, | 6597 | .required_features = .{ .sse, null, null, null }, |
| 5755 | .src_constraints = .{ | 6598 | .src_constraints = .{ |
| ... | @@ -5771,11 +6614,107 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5771,11 +6614,107 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5771 | .unused, | 6614 | .unused, |
| 5772 | .unused, | 6615 | .unused, |
| 5773 | }, | 6616 | }, |
| 5774 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | | |
| 5775 | .dst_temps = .{.{ .ref = .src0 }}, | 6617 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 6618 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5776 | .each = .{ .once = &.{ | 6619 | .each = .{ .once = &.{ |
| 5777 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, | 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 | } }) catch |err| switch (err) { | 6718 | } }) catch |err| switch (err) { |
| 5780 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ | 6719 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 5781 | @tagName(air_tag), | 6720 | @tagName(air_tag), |
| ... | @@ -5787,10 +6726,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5787,10 +6726,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5787 | }; | 6726 | }; |
| 5788 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); | 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 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; | 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 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); | 6731 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 5795 | var res: [1]Temp = undefined; | 6732 | var res: [1]Temp = undefined; |
| 5796 | cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ | 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,7 +8431,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7494 | }, | 8431 | }, |
| 7495 | .extra_temps = .{ | 8432 | .extra_temps = .{ |
| 7496 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 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 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, | 8435 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 7499 | .unused, | 8436 | .unused, |
| 7500 | .unused, | 8437 | .unused, |
| ... | @@ -7631,7 +8568,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7631,7 +8568,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7631 | }, | 8568 | }, |
| 7632 | .extra_temps = .{ | 8569 | .extra_temps = .{ |
| 7633 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 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 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, | 8572 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 7636 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, | 8573 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 7637 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, | 8574 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| ... | @@ -7955,7 +8892,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7955,7 +8892,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7955 | }, | 8892 | }, |
| 7956 | .extra_temps = .{ | 8893 | .extra_temps = .{ |
| 7957 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 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 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 8896 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 7960 | .unused, | 8897 | .unused, |
| 7961 | .unused, | 8898 | .unused, |
| ... | @@ -7986,7 +8923,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7986,7 +8923,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7986 | }, | 8923 | }, |
| 7987 | .extra_temps = .{ | 8924 | .extra_temps = .{ |
| 7988 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 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 | .{ .type = .vector_2_u64, .kind = .{ .reg = .xmm0 } }, | 8927 | .{ .type = .vector_2_u64, .kind = .{ .reg = .xmm0 } }, |
| 7991 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 8928 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 7992 | .unused, | 8929 | .unused, |
| ... | @@ -8018,7 +8955,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8018,7 +8955,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8018 | }, | 8955 | }, |
| 8019 | .extra_temps = .{ | 8956 | .extra_temps = .{ |
| 8020 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 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 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, | 8959 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 8023 | .unused, | 8960 | .unused, |
| 8024 | .unused, | 8961 | .unused, |
| ... | @@ -8047,7 +8984,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8047,7 +8984,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8047 | }, | 8984 | }, |
| 8048 | .extra_temps = .{ | 8985 | .extra_temps = .{ |
| 8049 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 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 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, | 8988 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 8052 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, | 8989 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 8053 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, | 8990 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| ... | @@ -8083,7 +9020,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8083,7 +9020,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8083 | }, | 9020 | }, |
| 8084 | .extra_temps = .{ | 9021 | .extra_temps = .{ |
| 8085 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 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 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 9024 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 8088 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 9025 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 8089 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 9026 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| ... | @@ -8119,7 +9056,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8119,7 +9056,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8119 | }, | 9056 | }, |
| 8120 | .extra_temps = .{ | 9057 | .extra_temps = .{ |
| 8121 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 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 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 9060 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 8124 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 9061 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 8125 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 9062 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| ... | @@ -8371,8 +9308,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8371,8 +9308,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8371 | .{ .src = .{ .to_sse, .to_sse } }, | 9308 | .{ .src = .{ .to_sse, .to_sse } }, |
| 8372 | }, | 9309 | }, |
| 8373 | .extra_temps = .{ | 9310 | .extra_temps = .{ |
| 8374 | .{ .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, | 9311 | .{ .type = .f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 8375 | .{ .kind = .{ .rc = .sse } }, | 9312 | .{ .type = .f16, .kind = .{ .rc = .sse } }, |
| 8376 | .unused, | 9313 | .unused, |
| 8377 | .unused, | 9314 | .unused, |
| 8378 | .unused, | 9315 | .unused, |
| ... | @@ -8383,12 +9320,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8383,12 +9320,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8383 | }, | 9320 | }, |
| 8384 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 9321 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 8385 | .each = .{ .once = &.{ | 9322 | .each = .{ .once = &.{ |
| 8386 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0x, ._, ._ }, | 9323 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 8387 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1x, ._, ._ }, | 9324 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 8388 | .{ ._, .v_ss, .cmp, .tmp1x, .dst0x, .dst0x, .vp(.unord) }, | 9325 | .{ ._, .v_ss, .cmp, .tmp1x, .dst0x, .dst0x, .vp(.unord) }, |
| 8389 | .{ ._, .v_ss, .min, .dst0x, .tmp0x, .dst0x, ._ }, | 9326 | .{ ._, .v_ss, .min, .dst0x, .tmp0x, .dst0x, ._ }, |
| 8390 | .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp0x, .tmp1x }, | 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 | .required_features = .{ .sse, null, null, null }, | 9331 | .required_features = .{ .sse, null, null, null }, |
| ... | @@ -8411,11 +9348,248 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8411,11 +9348,248 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8411 | .unused, | 9348 | .unused, |
| 8412 | .unused, | 9349 | .unused, |
| 8413 | }, | 9350 | }, |
| 8414 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | | |
| 8415 | .dst_temps = .{.{ .ref = .src0 }}, | 9351 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 9352 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8416 | .each = .{ .once = &.{ | 9353 | .each = .{ .once = &.{ |
| 8417 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, | 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 | .required_features = .{ .avx, null, null, null }, | 9594 | .required_features = .{ .avx, null, null, null }, |
| 8421 | .src_constraints = .{ | 9595 | .src_constraints = .{ |
| ... | @@ -8426,7 +9600,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8426,7 +9600,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8426 | .{ .src = .{ .to_sse, .to_sse } }, | 9600 | .{ .src = .{ .to_sse, .to_sse } }, |
| 8427 | }, | 9601 | }, |
| 8428 | .extra_temps = .{ | 9602 | .extra_temps = .{ |
| 8429 | .{ .kind = .{ .rc = .sse } }, | 9603 | .{ .type = .f32, .kind = .{ .rc = .sse } }, |
| 8430 | .unused, | 9604 | .unused, |
| 8431 | .unused, | 9605 | .unused, |
| 8432 | .unused, | 9606 | .unused, |
| ... | @@ -8487,6 +9661,210 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8487,6 +9661,210 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8487 | .{ ._, ._ps, .andn, .dst0x, .src1x, ._, ._ }, | 9661 | .{ ._, ._ps, .andn, .dst0x, .src1x, ._, ._ }, |
| 8488 | .{ ._, ._ps, .@"or", .dst0x, .tmp0x, ._, ._ }, | 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 | .required_features = .{ .avx, null, null, null }, | 9869 | .required_features = .{ .avx, null, null, null }, |
| 8492 | .src_constraints = .{ | 9870 | .src_constraints = .{ |
| ... | @@ -8497,7 +9875,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8497,7 +9875,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8497 | .{ .src = .{ .to_sse, .to_sse } }, | 9875 | .{ .src = .{ .to_sse, .to_sse } }, |
| 8498 | }, | 9876 | }, |
| 8499 | .extra_temps = .{ | 9877 | .extra_temps = .{ |
| 8500 | .{ .kind = .{ .rc = .sse } }, | 9878 | .{ .type = .f64, .kind = .{ .rc = .sse } }, |
| 8501 | .unused, | 9879 | .unused, |
| 8502 | .unused, | 9880 | .unused, |
| 8503 | .unused, | 9881 | .unused, |
| ... | @@ -8579,11 +9957,249 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8579,11 +9957,249 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8579 | .unused, | 9957 | .unused, |
| 8580 | .unused, | 9958 | .unused, |
| 8581 | }, | 9959 | }, |
| 8582 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | | |
| 8583 | .dst_temps = .{.{ .ref = .src0 }}, | 9960 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 9961 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8584 | .each = .{ .once = &.{ | 9962 | .each = .{ .once = &.{ |
| 8585 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, | 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 | .required_features = .{ .x87, .cmov, null, null }, | 10204 | .required_features = .{ .x87, .cmov, null, null }, |
| 8589 | .src_constraints = .{ | 10205 | .src_constraints = .{ |
| ... | @@ -8730,6 +10346,164 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8730,6 +10346,164 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8730 | .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, | 10346 | .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, |
| 8731 | .{ .@"1:", .f_p, .st, .dst0t, ._, ._, ._ }, | 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 | .required_features = .{ .sse, null, null, null }, | 10508 | .required_features = .{ .sse, null, null, null }, |
| 8735 | .src_constraints = .{ | 10509 | .src_constraints = .{ |
| ... | @@ -8751,11 +10525,107 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8751,11 +10525,107 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8751 | .unused, | 10525 | .unused, |
| 8752 | .unused, | 10526 | .unused, |
| 8753 | }, | 10527 | }, |
| 8754 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | | |
| 8755 | .dst_temps = .{.{ .ref = .src0 }}, | 10528 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 10529 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8756 | .each = .{ .once = &.{ | 10530 | .each = .{ .once = &.{ |
| 8757 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, | 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 | } }) catch |err| switch (err) { | 10629 | } }) catch |err| switch (err) { |
| 8760 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ | 10630 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 8761 | @tagName(air_tag), | 10631 | @tagName(air_tag), |
| ... | @@ -8955,7 +10825,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8955,7 +10825,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8955 | }, | 10825 | }, |
| 8956 | .extra_temps = .{ | 10826 | .extra_temps = .{ |
| 8957 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 10827 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8958 | .{ .kind = .{ .rc = .sse } }, | 10828 | .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, |
| 8959 | .unused, | 10829 | .unused, |
| 8960 | .unused, | 10830 | .unused, |
| 8961 | .unused, | 10831 | .unused, |
| ... | @@ -8982,7 +10852,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8982,7 +10852,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8982 | }, | 10852 | }, |
| 8983 | .extra_temps = .{ | 10853 | .extra_temps = .{ |
| 8984 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 10854 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8985 | .{ .kind = .{ .rc = .sse } }, | 10855 | .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, |
| 8986 | .unused, | 10856 | .unused, |
| 8987 | .unused, | 10857 | .unused, |
| 8988 | .unused, | 10858 | .unused, |
| ... | @@ -9009,7 +10879,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9009,7 +10879,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9009 | }, | 10879 | }, |
| 9010 | .extra_temps = .{ | 10880 | .extra_temps = .{ |
| 9011 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 10881 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 9012 | .{ .kind = .{ .rc = .sse } }, | 10882 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 9013 | .unused, | 10883 | .unused, |
| 9014 | .unused, | 10884 | .unused, |
| 9015 | .unused, | 10885 | .unused, |
| ... | @@ -9036,7 +10906,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9036,7 +10906,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9036 | }, | 10906 | }, |
| 9037 | .extra_temps = .{ | 10907 | .extra_temps = .{ |
| 9038 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 10908 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 9039 | .{ .kind = .{ .rc = .sse } }, | 10909 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 9040 | .unused, | 10910 | .unused, |
| 9041 | .unused, | 10911 | .unused, |
| 9042 | .unused, | 10912 | .unused, |
| ... | @@ -9063,7 +10933,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9063,7 +10933,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9063 | }, | 10933 | }, |
| 9064 | .extra_temps = .{ | 10934 | .extra_temps = .{ |
| 9065 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 10935 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 9066 | .{ .kind = .{ .rc = .sse } }, | 10936 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 9067 | .unused, | 10937 | .unused, |
| 9068 | .unused, | 10938 | .unused, |
| 9069 | .unused, | 10939 | .unused, |
| ... | @@ -15226,8 +17096,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15226,8 +17096,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15226 | .info = .{ .kind = .all, .scalar = .dword }, | 17096 | .info = .{ .kind = .all, .scalar = .dword }, |
| 15227 | } }}, | 17097 | } }}, |
| 15228 | .each = .{ .once = &.{ | 17098 | .each = .{ .once = &.{ |
| 15229 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0x, ._, ._ }, | 17099 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 15230 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1x, ._, ._ }, | 17100 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 15231 | .{ ._, .v_ss, .cmp, .dst0x, .dst0x, .tmp0x, .vp(switch (cc) { | 17101 | .{ ._, .v_ss, .cmp, .dst0x, .dst0x, .tmp0x, .vp(switch (cc) { |
| 15232 | else => unreachable, | 17102 | else => unreachable, |
| 15233 | .e => .eq, | 17103 | .e => .eq, |
| ... | @@ -15815,7 +17685,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15815,7 +17685,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15815 | .{ .type = .i32, .kind = .{ .reg = .eax } }, | 17685 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 15816 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 17686 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 15817 | .{ .type = .u32, .kind = .{ .reg = .edx } }, | 17687 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| 15818 | .{ .type = .vector_8_f16, .kind = .mem }, | 17688 | .{ .type = .f32, .kind = .mem }, |
| 15819 | .unused, | 17689 | .unused, |
| 15820 | }, | 17690 | }, |
| 15821 | .dst_temps = .{.{ .rc = .general_purpose }}, | 17691 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| ... | @@ -15825,10 +17695,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15825,10 +17695,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15825 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, | 17695 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 15826 | .{ .@"0:", ._, .movzx, .tmp4d, .memsi(.src0w, .@"2", .tmp0), ._, ._ }, | 17696 | .{ .@"0:", ._, .movzx, .tmp4d, .memsi(.src0w, .@"2", .tmp0), ._, ._ }, |
| 15827 | .{ ._, ._, .mov, .mem(.tmp7d), .tmp4d, ._, ._ }, | 17697 | .{ ._, ._, .mov, .mem(.tmp7d), .tmp4d, ._, ._ }, |
| 15828 | .{ ._, ._ps, .mova, .tmp1x, .mem(.tmp7x), ._, ._ }, | 17698 | .{ ._, ._ss, .mov, .tmp1x, .mem(.tmp7d), ._, ._ }, |
| 15829 | .{ ._, ._, .movzx, .tmp4d, .memsi(.src1w, .@"2", .tmp0), ._, ._ }, | 17699 | .{ ._, ._, .movzx, .tmp4d, .memsi(.src1w, .@"2", .tmp0), ._, ._ }, |
| 15830 | .{ ._, ._, .mov, .mem(.tmp7d), .tmp4d, ._, ._ }, | 17700 | .{ ._, ._, .mov, .mem(.tmp7d), .tmp4d, ._, ._ }, |
| 15831 | .{ ._, ._ps, .mova, .tmp2x, .mem(.tmp7x), ._, ._ }, | 17701 | .{ ._, ._ss, .mov, .tmp2x, .mem(.tmp7d), ._, ._ }, |
| 15832 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, | 17702 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 15833 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, | 17703 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| 15834 | .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ }, | 17704 | .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ }, |
| ... | @@ -15863,7 +17733,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15863,7 +17733,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15863 | .{ .type = .i32, .kind = .{ .reg = .eax } }, | 17733 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 15864 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 17734 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 15865 | .{ .type = .u32, .kind = .{ .reg = .edx } }, | 17735 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| 15866 | .{ .type = .vector_8_f16, .kind = .mem }, | 17736 | .{ .type = .f32, .kind = .mem }, |
| 15867 | .unused, | 17737 | .unused, |
| 15868 | }, | 17738 | }, |
| 15869 | .dst_temps = .{.{ .rc = .general_purpose }}, | 17739 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| ... | @@ -15873,10 +17743,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15873,10 +17743,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15873 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, | 17743 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 15874 | .{ .@"0:", ._, .movzx, .tmp4d, .memsi(.src0w, .@"2", .tmp0), ._, ._ }, | 17744 | .{ .@"0:", ._, .movzx, .tmp4d, .memsi(.src0w, .@"2", .tmp0), ._, ._ }, |
| 15875 | .{ ._, ._, .mov, .mem(.tmp7d), .tmp4d, ._, ._ }, | 17745 | .{ ._, ._, .mov, .mem(.tmp7d), .tmp4d, ._, ._ }, |
| 15876 | .{ ._, ._ps, .mova, .tmp1x, .mem(.tmp7x), ._, ._ }, | 17746 | .{ ._, ._ss, .mov, .tmp1x, .mem(.tmp7d), ._, ._ }, |
| 15877 | .{ ._, ._, .movzx, .tmp4d, .memsi(.src1w, .@"2", .tmp0), ._, ._ }, | 17747 | .{ ._, ._, .movzx, .tmp4d, .memsi(.src1w, .@"2", .tmp0), ._, ._ }, |
| 15878 | .{ ._, ._, .mov, .mem(.tmp7d), .tmp4d, ._, ._ }, | 17748 | .{ ._, ._, .mov, .mem(.tmp7d), .tmp4d, ._, ._ }, |
| 15879 | .{ ._, ._ps, .mova, .tmp2x, .mem(.tmp7x), ._, ._ }, | 17749 | .{ ._, ._ss, .mov, .tmp2x, .mem(.tmp7d), ._, ._ }, |
| 15880 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, | 17750 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 15881 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, | 17751 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| 15882 | .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ }, | 17752 | .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ }, |
| ... | @@ -16133,7 +18003,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16133,7 +18003,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16133 | .{ .type = .i32, .kind = .{ .reg = .eax } }, | 18003 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 16134 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 18004 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 16135 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, | 18005 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 16136 | .{ .type = .vector_8_f16, .kind = .mem }, | 18006 | .{ .type = .f32, .kind = .mem }, |
| 16137 | }, | 18007 | }, |
| 16138 | .dst_temps = .{.mem}, | 18008 | .dst_temps = .{.mem}, |
| 16139 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 18009 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| ... | @@ -16142,10 +18012,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16142,10 +18012,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16142 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 18012 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 16143 | .{ .@"0:", ._, .movzx, .tmp5d, .memsi(.src0w, .@"2", .tmp0), ._, ._ }, | 18013 | .{ .@"0:", ._, .movzx, .tmp5d, .memsi(.src0w, .@"2", .tmp0), ._, ._ }, |
| 16144 | .{ ._, ._, .mov, .mem(.tmp8d), .tmp5d, ._, ._ }, | 18014 | .{ ._, ._, .mov, .mem(.tmp8d), .tmp5d, ._, ._ }, |
| 16145 | .{ ._, ._ps, .mova, .tmp2x, .mem(.tmp8x), ._, ._ }, | 18015 | .{ ._, ._ss, .mov, .tmp2x, .mem(.tmp8d), ._, ._ }, |
| 16146 | .{ ._, ._, .movzx, .tmp5d, .memsi(.src1w, .@"2", .tmp0), ._, ._ }, | 18016 | .{ ._, ._, .movzx, .tmp5d, .memsi(.src1w, .@"2", .tmp0), ._, ._ }, |
| 16147 | .{ ._, ._, .mov, .mem(.tmp8d), .tmp5d, ._, ._ }, | 18017 | .{ ._, ._, .mov, .mem(.tmp8d), .tmp5d, ._, ._ }, |
| 16148 | .{ ._, ._ps, .mova, .tmp3x, .mem(.tmp8x), ._, ._ }, | 18018 | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp8d), ._, ._ }, |
| 16149 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, | 18019 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 16150 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, | 18020 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| 16151 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, | 18021 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, |
| ... | @@ -16191,7 +18061,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16191,7 +18061,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16191 | .{ .type = .i32, .kind = .{ .reg = .eax } }, | 18061 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 16192 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 18062 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 16193 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, | 18063 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 16194 | .{ .type = .vector_8_f16, .kind = .mem }, | 18064 | .{ .type = .f32, .kind = .mem }, |
| 16195 | }, | 18065 | }, |
| 16196 | .dst_temps = .{.mem}, | 18066 | .dst_temps = .{.mem}, |
| 16197 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 18067 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| ... | @@ -16200,10 +18070,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16200,10 +18070,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16200 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 18070 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 16201 | .{ .@"0:", ._, .movzx, .tmp5d, .memsi(.src0w, .@"2", .tmp0), ._, ._ }, | 18071 | .{ .@"0:", ._, .movzx, .tmp5d, .memsi(.src0w, .@"2", .tmp0), ._, ._ }, |
| 16202 | .{ ._, ._, .mov, .mem(.tmp8d), .tmp5d, ._, ._ }, | 18072 | .{ ._, ._, .mov, .mem(.tmp8d), .tmp5d, ._, ._ }, |
| 16203 | .{ ._, ._ps, .mova, .tmp2x, .mem(.tmp8x), ._, ._ }, | 18073 | .{ ._, ._ss, .mov, .tmp2x, .mem(.tmp8d), ._, ._ }, |
| 16204 | .{ ._, ._, .movzx, .tmp5d, .memsi(.src1w, .@"2", .tmp0), ._, ._ }, | 18074 | .{ ._, ._, .movzx, .tmp5d, .memsi(.src1w, .@"2", .tmp0), ._, ._ }, |
| 16205 | .{ ._, ._, .mov, .mem(.tmp8d), .tmp5d, ._, ._ }, | 18075 | .{ ._, ._, .mov, .mem(.tmp8d), .tmp5d, ._, ._ }, |
| 16206 | .{ ._, ._ps, .mova, .tmp3x, .mem(.tmp8x), ._, ._ }, | 18076 | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp8d), ._, ._ }, |
| 16207 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, | 18077 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 16208 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, | 18078 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| 16209 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, | 18079 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, |
| ... | @@ -16482,7 +18352,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16482,7 +18352,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16482 | .{ ._, ._, .@"or", .tmp4b, .tmp5b, ._, ._ }, | 18352 | .{ ._, ._, .@"or", .tmp4b, .tmp5b, ._, ._ }, |
| 16483 | .{ ._, ._, .mov, .lea(.byte, .tmp1), .tmp4b, ._, ._ }, | 18353 | .{ ._, ._, .mov, .lea(.byte, .tmp1), .tmp4b, ._, ._ }, |
| 16484 | .{ ._, ._, .lea, .tmp1p, .lead(.none, .tmp1, 1), ._, ._ }, | 18354 | .{ ._, ._, .lea, .tmp1p, .lead(.none, .tmp1, 1), ._, ._ }, |
| 16485 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, | 18355 | .{ ._, ._, .add, .tmp0p, .si(64), ._, ._ }, |
| 16486 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 18356 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 16487 | } }, | 18357 | } }, |
| 16488 | }, .{ | 18358 | }, .{ |
| ... | @@ -16528,7 +18398,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16528,7 +18398,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16528 | .{ ._, ._, .@"or", .tmp4b, .tmp5b, ._, ._ }, | 18398 | .{ ._, ._, .@"or", .tmp4b, .tmp5b, ._, ._ }, |
| 16529 | .{ ._, ._, .mov, .lea(.byte, .tmp1), .tmp4b, ._, ._ }, | 18399 | .{ ._, ._, .mov, .lea(.byte, .tmp1), .tmp4b, ._, ._ }, |
| 16530 | .{ ._, ._c, .in, .tmp1q, ._, ._, ._ }, | 18400 | .{ ._, ._c, .in, .tmp1q, ._, ._, ._ }, |
| 16531 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, | 18401 | .{ ._, ._, .add, .tmp0p, .si(64), ._, ._ }, |
| 16532 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 18402 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 16533 | } }, | 18403 | } }, |
| 16534 | }, .{ | 18404 | }, .{ |
| ... | @@ -19809,8 +21679,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19809,8 +21679,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19809 | } }}, | 21679 | } }}, |
| 19810 | .clobbers = .{ .eflags = true }, | 21680 | .clobbers = .{ .eflags = true }, |
| 19811 | .each = .{ .once = &.{ | 21681 | .each = .{ .once = &.{ |
| 19812 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src0x, ._, ._ }, | 21682 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src0q, ._, ._ }, |
| 19813 | .{ ._, .v_ps, .cvtph2, .tmp1x, .src1x, ._, ._ }, | 21683 | .{ ._, .v_ps, .cvtph2, .tmp1x, .src1q, ._, ._ }, |
| 19814 | .{ ._, .v_ss, .ucomi, .tmp0x, .tmp1x, ._, ._ }, | 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,19 +23064,21 @@ fn allocRegOrMemAdvanced(self: *CodeGen, ty: Type, inst: ?Air.Inst.Index, reg_ok |
| 21194 | }; | 23064 | }; |
| 21195 | | 23065 | |
| 21196 | if (reg_ok) need_mem: { | 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 | .float => switch (ty.floatBits(self.target.*)) { | 23068 | .float => switch (ty.floatBits(self.target.*)) { |
| 21199 | 16, 32, 64, 128 => 16, | 23069 | 16, 32, 64, 128 => 16, |
| 21200 | 80 => break :need_mem, | 23070 | 80 => break :need_mem, |
| 21201 | else => unreachable, | 23071 | else => unreachable, |
| 21202 | }, | 23072 | }, |
| 21203 | .vector => switch (ty.childType(zcu).zigTypeTag(zcu)) { | 23073 | .vector => { |
| 21204 | .float => switch (ty.childType(zcu).floatBits(self.target.*)) { | 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 | 16, 32, 64, 128 => self.vectorSize(.float), | 23078 | 16, 32, 64, 128 => self.vectorSize(.float), |
| 21206 | 80 => break :need_mem, | 23079 | 80 => break :need_mem, |
| 21207 | else => unreachable, | 23080 | else => unreachable, |
| 21208 | }, | 23081 | } else self.vectorSize(.int); |
| 21209 | else => self.vectorSize(.int), | | |
| 21210 | }, | 23082 | }, |
| 21211 | else => 8, | 23083 | else => 8, |
| 21212 | })) { | 23084 | })) { |
| ... | @@ -21223,17 +23095,18 @@ fn allocRegOrMemAdvanced(self: *CodeGen, ty: Type, inst: ?Air.Inst.Index, reg_ok | ... | @@ -21223,17 +23095,18 @@ fn allocRegOrMemAdvanced(self: *CodeGen, ty: Type, inst: ?Air.Inst.Index, reg_ok |
| 21223 | fn regClassForType(self: *CodeGen, ty: Type) Register.Class { | 23095 | fn regClassForType(self: *CodeGen, ty: Type) Register.Class { |
| 21224 | const pt = self.pt; | 23096 | const pt = self.pt; |
| 21225 | const zcu = pt.zcu; | 23097 | const zcu = pt.zcu; |
| 21226 | return switch (ty.zigTypeTag(zcu)) { | 23098 | if (self.floatBits(ty)) |float_bits| return switch (float_bits) { |
| 21227 | .float => switch (ty.floatBits(self.target.*)) { | 23099 | 80 => .x87, |
| 21228 | 80 => .x87, | 23100 | else => .sse, |
| 21229 | else => .sse, | | |
| 21230 | }, | | |
| 21231 | .vector => switch (ty.childType(zcu).toIntern()) { | | |
| 21232 | .bool_type => .general_purpose, | | |
| 21233 | else => .sse, | | |
| 21234 | }, | | |
| 21235 | else => .general_purpose, | | |
| 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 | fn regSetForRegClass(rc: Register.Class) RegisterManager.RegisterBitSet { | 23112 | fn regSetForRegClass(rc: Register.Class) RegisterManager.RegisterBitSet { |
| ... | @@ -33370,10 +35243,21 @@ const MoveStrategy = union(enum) { | ... | @@ -33370,10 +35243,21 @@ const MoveStrategy = union(enum) { |
| 33370 | else => dst_reg, | 35243 | else => dst_reg, |
| 33371 | .lea => if (dst_reg.bitSize() >= 32) dst_reg else dst_reg.to32(), | 35244 | .lea => if (dst_reg.bitSize() >= 32) dst_reg else dst_reg.to32(), |
| 33372 | }, src_mem), | 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 | try self.asmMemory(.{ .f_, .ld }, src_mem); | 35255 | try self.asmMemory(.{ .f_, .ld }, src_mem); |
| 33375 | assert(dst_reg != .st7); | 35256 | switch (dst_reg) { |
| 33376 | try self.asmRegister(.{ .f_p, .st }, @enumFromInt(@intFromEnum(dst_reg) + 1)); | 35257 | .st0 => {}, |
| | 35258 | .st1, .st2, .st3, .st4, .st5, .st6, .st7 => try self.asmRegister(.{ .f_, .xch }, dst_reg), |
| | 35259 | else => unreachable, |
| | 35260 | } |
| 33377 | }, | 35261 | }, |
| 33378 | .insert_extract => |ie| if (ie.insert[0] != .p_w or self.hasFeature(.sse2)) | 35262 | .insert_extract => |ie| if (ie.insert[0] != .p_w or self.hasFeature(.sse2)) |
| 33379 | try self.asmRegisterMemoryImmediate(ie.insert, dst_reg, src_mem, .u(0)) | 35263 | try self.asmRegisterMemoryImmediate(ie.insert, dst_reg, src_mem, .u(0)) |
| ... | @@ -33405,9 +35289,22 @@ const MoveStrategy = union(enum) { | ... | @@ -33405,9 +35289,22 @@ const MoveStrategy = union(enum) { |
| 33405 | pub fn write(strat: MoveStrategy, self: *CodeGen, dst_mem: Memory, src_reg: Register) !void { | 35289 | pub fn write(strat: MoveStrategy, self: *CodeGen, dst_mem: Memory, src_reg: Register) !void { |
| 33406 | switch (strat) { | 35290 | switch (strat) { |
| 33407 | .move => |tag| try self.asmMemoryRegister(tag, dst_mem, src_reg), | 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 | try self.asmRegister(.{ .f_, .ld }, src_reg); | 35293 | try self.asmRegister(.{ .f_, .ld }, src_reg); |
| 33410 | try self.asmMemory(.{ .f_p, .st }, dst_mem); | 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 | .insert_extract, .vex_insert_extract => |ie| if (ie.extract[0] != .p_w or self.hasFeature(.sse4_1)) | 35309 | .insert_extract, .vex_insert_extract => |ie| if (ie.extract[0] != .p_w or self.hasFeature(.sse4_1)) |
| 33413 | try self.asmMemoryRegisterImmediate(ie.extract, dst_mem, src_reg, .u(0)) | 35310 | try self.asmMemoryRegisterImmediate(ie.extract, dst_mem, src_reg, .u(0)) |
| ... | @@ -33964,10 +35861,25 @@ fn genSetReg( | ... | @@ -33964,10 +35861,25 @@ fn genSetReg( |
| 33964 | .general_purpose, .segment => unreachable, | 35861 | .general_purpose, .segment => unreachable, |
| 33965 | .x87 => switch (src_reg) { | 35862 | .x87 => switch (src_reg) { |
| 33966 | .st0 => try self.asmRegister(.{ .f_, .st }, dst_reg), | 35863 | .st0 => try self.asmRegister(.{ .f_, .st }, dst_reg), |
| 33967 | .st1, .st2, .st3, .st4, .st5, .st6 => { | 35864 | .st1, .st2, .st3, .st4, .st5, .st6 => switch (dst_reg) { |
| 33968 | try self.asmRegister(.{ .f_, .ld }, src_reg); | 35865 | .st0 => { |
| 33969 | assert(dst_reg != .st7); | 35866 | try self.asmRegister(.{ .f_p, .st }, .st0); |
| 33970 | try self.asmRegister(.{ .f_p, .st }, @enumFromInt(@intFromEnum(dst_reg) + 1)); | 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 | else => unreachable, | 35884 | else => unreachable, |
| 33973 | }, | 35885 | }, |
| ... | @@ -33993,10 +35905,14 @@ fn genSetReg( | ... | @@ -33993,10 +35905,14 @@ fn genSetReg( |
| 33993 | .base = .{ .frame = frame_index }, | 35905 | .base = .{ .frame = frame_index }, |
| 33994 | .mod = .{ .rm = .{ .size = .fromSize(abi_size) } }, | 35906 | .mod = .{ .rm = .{ .size = .fromSize(abi_size) } }, |
| 33995 | }, registerAlias(src_reg, abi_size)); | 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 | try self.asmRegisterMemory(switch (frame_size) { | 35912 | try self.asmRegisterMemory(switch (frame_size) { |
| 33997 | 4 => .{ ._ss, .mov }, | 35913 | 4 => .{ ._ss, .mov }, |
| 33998 | 8 => .{ ._ps, .movl }, | 35914 | 8 => .{ ._ps, .movl }, |
| 33999 | 16 => .{ ._ps, .mov }, | 35915 | 16 => .{ ._ps, .mova }, |
| 34000 | else => unreachable, | 35916 | else => unreachable, |
| 34001 | }, dst_reg.to128(), .{ | 35917 | }, dst_reg.to128(), .{ |
| 34002 | .base = .{ .frame = frame_index }, | 35918 | .base = .{ .frame = frame_index }, |
| ... | @@ -34009,7 +35925,26 @@ fn genSetReg( | ... | @@ -34009,7 +35925,26 @@ fn genSetReg( |
| 34009 | .{ .register = try self.copyToTmpRegister(ty, src_mcv) }, | 35925 | .{ .register = try self.copyToTmpRegister(ty, src_mcv) }, |
| 34010 | opts, | 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 | .sse => try self.asmRegisterRegister( | 35948 | .sse => try self.asmRegisterRegister( |
| 34014 | @as(?Mir.Inst.FixedTag, switch (ty.scalarType(zcu).zigTypeTag(zcu)) { | 35949 | @as(?Mir.Inst.FixedTag, switch (ty.scalarType(zcu).zigTypeTag(zcu)) { |
| 34015 | else => switch (abi_size) { | 35950 | else => switch (abi_size) { |
| ... | @@ -38510,7 +40445,7 @@ fn resolveCallingConventionValues( | ... | @@ -38510,7 +40445,7 @@ fn resolveCallingConventionValues( |
| 38510 | else if (ret_gpr.len >= 2 and ret_ty.isSliceAtRuntime(zcu)) | 40445 | else if (ret_gpr.len >= 2 and ret_ty.isSliceAtRuntime(zcu)) |
| 38511 | break :return_value .init(.{ .register_pair = ret_gpr[0..2].* }), | 40446 | break :return_value .init(.{ .register_pair = ret_gpr[0..2].* }), |
| 38512 | .segment, .mmx, .ip, .cr, .dr => unreachable, | 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 | .sse => if (ret_size <= self.vectorSize(.float)) break :return_value .init(.{ | 40449 | .sse => if (ret_size <= self.vectorSize(.float)) break :return_value .init(.{ |
| 38515 | .register = registerAlias(abi.getCAbiSseReturnRegs(cc)[0], @max(ret_size, 16)), | 40450 | .register = registerAlias(abi.getCAbiSseReturnRegs(cc)[0], @max(ret_size, 16)), |
| 38516 | }), | 40451 | }), |
| ... | @@ -38545,7 +40480,7 @@ fn resolveCallingConventionValues( | ... | @@ -38545,7 +40480,7 @@ fn resolveCallingConventionValues( |
| 38545 | continue; | 40480 | continue; |
| 38546 | }, | 40481 | }, |
| 38547 | .segment, .mmx, .ip, .cr, .dr => unreachable, | 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 | arg.* = .{ .register = param_x87[0] }; | 40484 | arg.* = .{ .register = param_x87[0] }; |
| 38550 | param_x87 = param_x87[1..]; | 40485 | param_x87 = param_x87[1..]; |
| 38551 | continue; | 40486 | continue; |
| ... | @@ -38656,10 +40591,12 @@ fn registerAlias(reg: Register, size_bytes: u32) Register { | ... | @@ -38656,10 +40591,12 @@ fn registerAlias(reg: Register, size_bytes: u32) Register { |
| 38656 | | 40591 | |
| 38657 | fn memSize(self: *CodeGen, ty: Type) Memory.Size { | 40592 | fn memSize(self: *CodeGen, ty: Type) Memory.Size { |
| 38658 | const zcu = self.pt.zcu; | 40593 | const zcu = self.pt.zcu; |
| 38659 | return switch (ty.zigTypeTag(zcu)) { | 40594 | return if (self.floatBits(ty)) |float_bits| |
| 38660 | .float => .fromBitSize(ty.floatBits(self.target.*)), | 40595 | .fromBitSize(float_bits) |
| 38661 | else => .fromSize(@intCast(ty.abiSize(zcu))), | 40596 | else if (ty.isVector(zcu) and ty.vectorLen(zcu) == 1 and self.floatBits(ty.childType(zcu)) == 80) |
| 38662 | }; | 40597 | .tbyte |
| | 40598 | else |
| | 40599 | .fromSize(@intCast(ty.abiSize(zcu))); |
| 38663 | } | 40600 | } |
| 38664 | | 40601 | |
| 38665 | fn splitType(self: *CodeGen, comptime parts_len: usize, ty: Type) ![parts_len]Type { | 40602 | fn splitType(self: *CodeGen, comptime parts_len: usize, ty: Type) ![parts_len]Type { |
| ... | @@ -40762,7 +42699,7 @@ const Select = struct { | ... | @@ -40762,7 +42699,7 @@ const Select = struct { |
| 40762 | Select.Operand, | 42699 | Select.Operand, |
| 40763 | Select.Operand, | 42700 | Select.Operand, |
| 40764 | }; | 42701 | }; |
| 40765 | const Label = enum { @"0:", @"1:", @"_" }; | 42702 | const Label = enum { @"0:", @"1:", @"2:", @"_" }; |
| 40766 | const Operand = struct { | 42703 | const Operand = struct { |
| 40767 | tag: Tag, | 42704 | tag: Tag, |
| 40768 | base: Ref.Sized = .none, | 42705 | base: Ref.Sized = .none, |
| ... | @@ -40992,6 +42929,8 @@ const Select = struct { | ... | @@ -40992,6 +42929,8 @@ const Select = struct { |
| 40992 | const @"0f": Select.Operand = .{ .tag = .forward_label, .base = .{ .ref = .tmp0, .size = .none } }; | 42929 | const @"0f": Select.Operand = .{ .tag = .forward_label, .base = .{ .ref = .tmp0, .size = .none } }; |
| 40993 | const @"1b": Select.Operand = .{ .tag = .backward_label, .base = .{ .ref = .tmp1, .size = .none } }; | 42930 | const @"1b": Select.Operand = .{ .tag = .backward_label, .base = .{ .ref = .tmp1, .size = .none } }; |
| 40994 | const @"1f": Select.Operand = .{ .tag = .forward_label, .base = .{ .ref = .tmp1, .size = .none } }; | 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 | const tmp0b: Select.Operand = .{ .tag = .ref, .base = .tmp0b }; | 42935 | const tmp0b: Select.Operand = .{ .tag = .ref, .base = .tmp0b }; |
| 40997 | const tmp0w: Select.Operand = .{ .tag = .ref, .base = .tmp0w }; | 42936 | const tmp0w: Select.Operand = .{ .tag = .ref, .base = .tmp0w }; |
Jacob Young <jacobly@ziglang.org> 2025-01-26 09:05:04-05:00
src