authorgravatar for techatrix@mailbox.orgTechatrix <techatrix@mailbox.org> 2023-03-21 18:23:33+01:00
committergravatar for techatrix@mailbox.orgTechatrix <techatrix@mailbox.org> 2023-03-26 22:48:56+02:00
log8ec7723992312790cb9da7ce2f36ecde838c361e
tree9a5e586246a8f5cf03affd9085e5cfc3e2b3bb48
parent32591c1d99297b370e34674dc135705c3849968d

wasm: implement float operations with compiler-rt

4 files changed, 198 insertions(+), 105 deletions(-)

src/arch/wasm/CodeGen.zig+195-77
......@@ -20,6 +20,7 @@ const link = @import("../../link.zig");
2020const TypedValue = @import("../../TypedValue.zig");
2121const Air = @import("../../Air.zig");
2222const Liveness = @import("../../Liveness.zig");
23const target_util = @import("../../target.zig");
2324const Mir = @import("Mir.zig");
2425const Emit = @import("Emit.zig");
2526const abi = @import("abi.zig");
......@@ -1786,9 +1787,6 @@ fn genInst(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
17861787 .div_trunc,
17871788 => func.airDiv(inst),
17881789 .div_floor => func.airDivFloor(inst),
1789 .ceil => func.airCeilFloorTrunc(inst, .ceil),
1790 .floor => func.airCeilFloorTrunc(inst, .floor),
1791 .trunc_float => func.airCeilFloorTrunc(inst, .trunc),
17921790 .bit_and => func.airBinOp(inst, .@"and"),
17931791 .bit_or => func.airBinOp(inst, .@"or"),
17941792 .bool_and => func.airBinOp(inst, .@"and"),
......@@ -1803,6 +1801,22 @@ fn genInst(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
18031801 .min => func.airMaxMin(inst, .min),
18041802 .mul_add => func.airMulAdd(inst),
18051803
1804 .sqrt => func.airUnaryFloatOp(inst, .sqrt),
1805 .sin => func.airUnaryFloatOp(inst, .sin),
1806 .cos => func.airUnaryFloatOp(inst, .cos),
1807 .tan => func.airUnaryFloatOp(inst, .tan),
1808 .exp => func.airUnaryFloatOp(inst, .exp),
1809 .exp2 => func.airUnaryFloatOp(inst, .exp2),
1810 .log => func.airUnaryFloatOp(inst, .log),
1811 .log2 => func.airUnaryFloatOp(inst, .log2),
1812 .log10 => func.airUnaryFloatOp(inst, .log10),
1813 .fabs => func.airUnaryFloatOp(inst, .fabs),
1814 .floor => func.airUnaryFloatOp(inst, .floor),
1815 .ceil => func.airUnaryFloatOp(inst, .ceil),
1816 .round => func.airUnaryFloatOp(inst, .round),
1817 .trunc_float => func.airUnaryFloatOp(inst, .trunc),
1818 .neg => func.airUnaryFloatOp(inst, .neg),
1819
18061820 .add_with_overflow => func.airAddSubWithOverflow(inst, .add),
18071821 .sub_with_overflow => func.airAddSubWithOverflow(inst, .sub),
18081822 .shl_with_overflow => func.airShlWithOverflow(inst),
......@@ -1938,19 +1952,6 @@ fn genInst(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
19381952 .is_err_ptr,
19391953 .is_non_err_ptr,
19401954
1941 .sqrt,
1942 .sin,
1943 .cos,
1944 .tan,
1945 .exp,
1946 .exp2,
1947 .log,
1948 .log2,
1949 .log10,
1950 .fabs,
1951 .round,
1952 .neg,
1953
19541955 .cmpxchg_weak,
19551956 .cmpxchg_strong,
19561957 .fence,
......@@ -2456,7 +2457,7 @@ fn airArg(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
24562457 // When we have an argument that's passed using more than a single parameter,
24572458 // we combine them into a single stack value
24582459 if (arg_classes[0] == .direct and arg_classes[1] == .direct) {
2459 if (arg_ty.zigTypeTag() != .Int) {
2460 if (arg_ty.zigTypeTag() != .Int and arg_ty.zigTypeTag() != .Float) {
24602461 return func.fail(
24612462 "TODO: Implement C-ABI argument for type '{}'",
24622463 .{arg_ty.fmt(func.bin_file.base.options.module.?)},
......@@ -2500,6 +2501,12 @@ fn airBinOp(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerError!void {
25002501/// NOTE: THis leaves the value on top of the stack.
25012502fn binOp(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, op: Op) InnerError!WValue {
25022503 assert(!(lhs != .stack and rhs == .stack));
2504
2505 if (ty.isAnyFloat()) {
2506 const float_op = FloatOp.fromOp(op);
2507 return func.floatOp(float_op, ty, &.{ lhs, rhs });
2508 }
2509
25032510 if (isByRef(ty, func.target)) {
25042511 if (ty.zigTypeTag() == .Int) {
25052512 return func.binOpBigInt(lhs, rhs, ty, op);
......@@ -2511,10 +2518,6 @@ fn binOp(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, op: Op) InnerError!
25112518 }
25122519 }
25132520
2514 if (ty.isAnyFloat() and ty.floatBits(func.target) == 16) {
2515 return func.binOpFloat16(lhs, rhs, op);
2516 }
2517
25182521 const opcode: wasm.Opcode = buildOpcode(.{
25192522 .op = op,
25202523 .valtype1 = typeToValtype(ty, func.target),
......@@ -2528,17 +2531,6 @@ fn binOp(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, op: Op) InnerError!
25282531 return WValue{ .stack = {} };
25292532}
25302533
2531/// Performs a binary operation for 16-bit floats.
2532/// NOTE: Leaves the result value on the stack
2533fn binOpFloat16(func: *CodeGen, lhs: WValue, rhs: WValue, op: Op) InnerError!WValue {
2534 const opcode: wasm.Opcode = buildOpcode(.{ .op = op, .valtype1 = .f32, .signedness = .unsigned });
2535 _ = try func.fpext(lhs, Type.f16, Type.f32);
2536 _ = try func.fpext(rhs, Type.f16, Type.f32);
2537 try func.addTag(Mir.Inst.Tag.fromOpcode(opcode));
2538
2539 return func.fptrunc(.{ .stack = {} }, Type.f32, Type.f16);
2540}
2541
25422534fn binOpBigInt(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, op: Op) InnerError!WValue {
25432535 if (ty.intInfo(func.target).bits > 128) {
25442536 return func.fail("TODO: Implement binary operation for big integer", .{});
......@@ -2574,6 +2566,155 @@ fn binOpBigInt(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, op: Op) Inner
25742566 return result;
25752567}
25762568
2569const FloatOp = enum {
2570 add,
2571 ceil,
2572 cos,
2573 div,
2574 exp,
2575 exp2,
2576 fabs,
2577 floor,
2578 fma,
2579 fmax,
2580 fmin,
2581 fmod,
2582 log,
2583 log10,
2584 log2,
2585 mul,
2586 neg,
2587 round,
2588 sin,
2589 sqrt,
2590 sub,
2591 tan,
2592 trunc,
2593
2594 pub fn fromOp(op: Op) FloatOp {
2595 return switch (op) {
2596 .add => .add,
2597 .ceil => .ceil,
2598 .div => .div,
2599 .abs => .fabs,
2600 .floor => .floor,
2601 .max => .fmax,
2602 .min => .fmin,
2603 .mul => .mul,
2604 .neg => .neg,
2605 .nearest => .round,
2606 .sqrt => .sqrt,
2607 .sub => .sub,
2608 .trunc => .trunc,
2609 else => unreachable,
2610 };
2611 }
2612
2613 pub fn toOp(float_op: FloatOp) ?Op {
2614 return switch (float_op) {
2615 .add => .add,
2616 .ceil => .ceil,
2617 .div => .div,
2618 .fabs => .abs,
2619 .floor => .floor,
2620 .fmax => .max,
2621 .fmin => .min,
2622 .mul => .mul,
2623 .neg => .neg,
2624 .round => .nearest,
2625 .sqrt => .sqrt,
2626 .sub => .sub,
2627 .trunc => .trunc,
2628
2629 .cos,
2630 .exp,
2631 .exp2,
2632 .fma,
2633 .fmod,
2634 .log,
2635 .log10,
2636 .log2,
2637 .sin,
2638 .tan,
2639 => null,
2640 };
2641 }
2642};
2643
2644fn airUnaryFloatOp(func: *CodeGen, inst: Air.Inst.Index, op: FloatOp) InnerError!void {
2645 const un_op = func.air.instructions.items(.data)[inst].un_op;
2646 if (func.liveness.isUnused(inst)) return func.finishAir(inst, .none, &.{un_op});
2647 const operand = try func.resolveInst(un_op);
2648 const ty = func.air.typeOf(un_op);
2649
2650 const result = try (try func.floatOp(op, ty, &.{operand})).toLocal(func, ty);
2651 func.finishAir(inst, result, &.{un_op});
2652}
2653
2654fn floatOp(func: *CodeGen, float_op: FloatOp, ty: Type, args: []const WValue) InnerError!WValue {
2655 if (ty.zigTypeTag() == .Vector) {
2656 return func.fail("TODO: Implement floatOps for vectors", .{});
2657 }
2658
2659 const float_bits = ty.floatBits(func.target);
2660 if (float_bits == 32 or float_bits == 64) {
2661 if (float_op.toOp()) |op| {
2662 for (args) |operand| {
2663 try func.emitWValue(operand);
2664 }
2665 const opcode = buildOpcode(.{ .op = op, .valtype1 = typeToValtype(ty, func.target) });
2666 try func.addTag(Mir.Inst.Tag.fromOpcode(opcode));
2667 return .stack;
2668 }
2669 } else if (float_bits == 16 and float_op == .neg) {
2670 try func.emitWValue(args[0]);
2671 try func.addImm32(std.math.minInt(i16));
2672 try func.addTag(Mir.Inst.Tag.fromOpcode(.i32_xor));
2673 return .stack;
2674 } else if (float_bits == 128 and float_op == .neg) {
2675 return func.fail("TODO: Implement neg for f128", .{});
2676 }
2677
2678 var fn_name_buf: [64]u8 = undefined;
2679 const fn_name = switch (float_op) {
2680 .add,
2681 .sub,
2682 .div,
2683 .mul,
2684 => std.fmt.bufPrint(&fn_name_buf, "__{s}{s}f3", .{
2685 @tagName(float_op), target_util.compilerRtFloatAbbrev(float_bits),
2686 }) catch unreachable,
2687
2688 .ceil,
2689 .cos,
2690 .exp,
2691 .exp2,
2692 .fabs,
2693 .floor,
2694 .fma,
2695 .fmax,
2696 .fmin,
2697 .fmod,
2698 .log,
2699 .log10,
2700 .log2,
2701 .round,
2702 .sin,
2703 .sqrt,
2704 .tan,
2705 .trunc,
2706 => std.fmt.bufPrint(&fn_name_buf, "{s}{s}{s}", .{
2707 target_util.libcFloatPrefix(float_bits), @tagName(float_op), target_util.libcFloatSuffix(float_bits),
2708 }) catch unreachable,
2709 .neg => unreachable, // handled above
2710 };
2711
2712 // fma requires three operands
2713 var param_types_buffer: [3]Type = .{ ty, ty, ty };
2714 const param_types = param_types_buffer[0..args.len];
2715 return func.callIntrinsic(fn_name, param_types, ty, args);
2716}
2717
25772718fn airWrapBinOp(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerError!void {
25782719 const bin_op = func.air.instructions.items(.data)[inst].bin_op;
25792720 if (func.liveness.isUnused(inst)) return func.finishAir(inst, .none, &.{ bin_op.lhs, bin_op.rhs });
......@@ -3310,6 +3451,8 @@ fn airBitcast(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
33103451fn bitcast(func: *CodeGen, wanted_ty: Type, given_ty: Type, operand: WValue) InnerError!WValue {
33113452 // if we bitcast a float to or from an integer we must use the 'reinterpret' instruction
33123453 if (!(wanted_ty.isAnyFloat() or given_ty.isAnyFloat())) return operand;
3454 if (wanted_ty.tag() == .f16 or given_ty.tag() == .f16) return operand;
3455 if (wanted_ty.bitSize(func.target) > 64) return operand;
33133456 assert((wanted_ty.isInt() and given_ty.isAnyFloat()) or (wanted_ty.isAnyFloat() and given_ty.isInt()));
33143457
33153458 const opcode = buildOpcode(.{
......@@ -4843,7 +4986,7 @@ fn fpext(func: *CodeGen, operand: WValue, given: Type, wanted: Type) InnerError!
48434986 try func.emitWValue(operand);
48444987 try func.addTag(.f64_promote_f32);
48454988 return WValue{ .stack = {} };
4846 } else if (given_bits == 16) {
4989 } else if (given_bits == 16 and wanted_bits <= 64) {
48474990 // call __extendhfsf2(f16) f32
48484991 const f32_result = try func.callIntrinsic(
48494992 "__extendhfsf2",
......@@ -4851,19 +4994,21 @@ fn fpext(func: *CodeGen, operand: WValue, given: Type, wanted: Type) InnerError!
48514994 Type.f32,
48524995 &.{operand},
48534996 );
4997 std.debug.assert(f32_result == .stack);
48544998
4855 if (wanted_bits == 32) {
4856 return f32_result;
4857 }
48584999 if (wanted_bits == 64) {
48595000 try func.addTag(.f64_promote_f32);
4860 return WValue{ .stack = {} };
48615001 }
4862 return func.fail("TODO: Implement 'fpext' for floats with bitsize: {d}", .{wanted_bits});
4863 } else {
4864 // TODO: Emit a call to compiler-rt to extend the float. e.g. __extendhfsf2
4865 return func.fail("TODO: Implement 'fpext' for floats with bitsize: {d}", .{wanted_bits});
5002 return WValue{ .stack = {} };
48665003 }
5004
5005 var fn_name_buf: [13]u8 = undefined;
5006 const fn_name = std.fmt.bufPrint(&fn_name_buf, "__extend{s}f{s}f2", .{
5007 target_util.compilerRtFloatAbbrev(given_bits),
5008 target_util.compilerRtFloatAbbrev(wanted_bits),
5009 }) catch unreachable;
5010
5011 return func.callIntrinsic(fn_name, &.{given}, wanted, &.{operand});
48675012}
48685013
48695014fn airFptrunc(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
......@@ -4887,7 +5032,7 @@ fn fptrunc(func: *CodeGen, operand: WValue, given: Type, wanted: Type) InnerErro
48875032 try func.emitWValue(operand);
48885033 try func.addTag(.f32_demote_f64);
48895034 return WValue{ .stack = {} };
4890 } else if (wanted_bits == 16) {
5035 } else if (wanted_bits == 16 and given_bits <= 64) {
48915036 const op: WValue = if (given_bits == 64) blk: {
48925037 try func.emitWValue(operand);
48935038 try func.addTag(.f32_demote_f64);
......@@ -4896,10 +5041,15 @@ fn fptrunc(func: *CodeGen, operand: WValue, given: Type, wanted: Type) InnerErro
48965041
48975042 // call __truncsfhf2(f32) f16
48985043 return func.callIntrinsic("__truncsfhf2", &.{Type.f32}, Type.f16, &.{op});
4899 } else {
4900 // TODO: Emit a call to compiler-rt to trunc the float. e.g. __truncdfhf2
4901 return func.fail("TODO: Implement 'fptrunc' for floats with bitsize: {d}", .{wanted_bits});
49025044 }
5045
5046 var fn_name_buf: [12]u8 = undefined;
5047 const fn_name = std.fmt.bufPrint(&fn_name_buf, "__trunc{s}f{s}f2", .{
5048 target_util.compilerRtFloatAbbrev(given_bits),
5049 target_util.compilerRtFloatAbbrev(wanted_bits),
5050 }) catch unreachable;
5051
5052 return func.callIntrinsic(fn_name, &.{given}, wanted, &.{operand});
49035053}
49045054
49055055fn airErrUnionPayloadPtrSet(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
......@@ -5857,38 +6007,6 @@ fn signAbsValue(func: *CodeGen, operand: WValue, ty: Type) InnerError!WValue {
58576007 return WValue{ .stack = {} };
58586008}
58596009
5860fn airCeilFloorTrunc(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerError!void {
5861 const un_op = func.air.instructions.items(.data)[inst].un_op;
5862 if (func.liveness.isUnused(inst)) return func.finishAir(inst, .none, &.{un_op});
5863
5864 const ty = func.air.typeOfIndex(inst);
5865 const float_bits = ty.floatBits(func.target);
5866 const is_f16 = float_bits == 16;
5867
5868 if (ty.zigTypeTag() == .Vector) {
5869 return func.fail("TODO: Implement `@ceil` for vectors", .{});
5870 }
5871 if (float_bits > 64) {
5872 return func.fail("TODO: implement `@ceil`, `@trunc`, `@floor` for floats larger than 64bits", .{});
5873 }
5874
5875 const operand = try func.resolveInst(un_op);
5876 const op_to_lower = if (is_f16) blk: {
5877 break :blk try func.fpext(operand, Type.f16, Type.f32);
5878 } else operand;
5879 try func.emitWValue(op_to_lower);
5880 const opcode = buildOpcode(.{ .op = op, .valtype1 = typeToValtype(ty, func.target) });
5881 try func.addTag(Mir.Inst.Tag.fromOpcode(opcode));
5882
5883 if (is_f16) {
5884 _ = try func.fptrunc(.{ .stack = {} }, Type.f32, Type.f16);
5885 }
5886
5887 const result = try func.allocLocal(ty);
5888 try func.addLabel(.local_set, result.local.value);
5889 func.finishAir(inst, result, &.{un_op});
5890}
5891
58926010fn airSatBinOp(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerError!void {
58936011 assert(op == .add or op == .sub);
58946012 const bin_op = func.air.instructions.items(.data)[inst].bin_op;
test/behavior/floatop.zig+2-26
......@@ -20,7 +20,6 @@ fn epsForType(comptime T: type) T {
2020}
2121
2222test "floating point comparisons" {
23 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
2423 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2524
2625 try testFloatComparisons();
......@@ -53,7 +52,6 @@ fn testFloatComparisons() !void {
5352}
5453
5554test "different sized float comparisons" {
56 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
5755 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
5856 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
5957 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
......@@ -89,7 +87,6 @@ fn testDifferentSizedFloatComparisons() !void {
8987//}
9088
9189test "negative f128 floatToInt at compile-time" {
92 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
9390 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
9491 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
9592
......@@ -99,7 +96,6 @@ test "negative f128 floatToInt at compile-time" {
9996}
10097
10198test "@sqrt" {
102 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
10399 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
104100 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
105101 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
......@@ -157,7 +153,6 @@ fn testSqrtWithVectors() !void {
157153}
158154
159155test "more @sqrt f16 tests" {
160 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
161156 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
162157 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
163158 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
......@@ -183,7 +178,6 @@ test "more @sqrt f16 tests" {
183178}
184179
185180test "another, possibly redundant @sqrt test" {
186 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
187181 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
188182 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
189183 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
......@@ -209,7 +203,6 @@ fn testSqrtLegacy(comptime T: type, x: T) !void {
209203}
210204
211205test "@sin" {
212 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
213206 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
214207 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
215208 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
......@@ -249,7 +242,6 @@ fn testSinWithVectors() !void {
249242}
250243
251244test "@cos" {
252 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
253245 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
254246 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
255247 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
......@@ -289,7 +281,6 @@ fn testCosWithVectors() !void {
289281}
290282
291283test "@exp" {
292 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
293284 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
294285 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
295286 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
......@@ -328,7 +319,7 @@ fn testExpWithVectors() !void {
328319}
329320
330321test "@exp2" {
331 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
322 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
332323 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
333324 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
334325 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -346,7 +337,7 @@ fn testExp2() !void {
346337 }
347338}
348339
349test "@exp2" {
340test "@exp2 with @vectors" {
350341 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
351342 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
352343 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
......@@ -366,7 +357,6 @@ fn testExp2WithVectors() !void {
366357}
367358
368359test "@log" {
369 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
370360 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
371361 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
372362 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
......@@ -414,7 +404,6 @@ test "@log with @vectors" {
414404}
415405
416406test "@log2" {
417 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
418407 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
419408 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
420409 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
......@@ -457,7 +446,6 @@ fn testLog2WithVectors() !void {
457446}
458447
459448test "@log10" {
460 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
461449 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
462450 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
463451 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
......@@ -496,7 +484,6 @@ fn testLog10WithVectors() !void {
496484}
497485
498486test "@fabs" {
499 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
500487 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
501488 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
502489 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -622,7 +609,6 @@ test "a third @fabs test, surely there should not be three fabs tests" {
622609}
623610
624611test "@floor" {
625 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
626612 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
627613 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
628614 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -664,7 +650,6 @@ fn testFloorWithVectors() !void {
664650}
665651
666652test "another, possibly redundant, @floor test" {
667 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
668653 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
669654 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
670655 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
......@@ -714,7 +699,6 @@ fn testFloorLegacy(comptime T: type, x: T) !void {
714699}
715700
716701test "@ceil" {
717 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
718702 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
719703 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
720704 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -756,7 +740,6 @@ fn testCeilWithVectors() !void {
756740}
757741
758742test "another, possibly redundant, @ceil test" {
759 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
760743 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
761744 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
762745 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
......@@ -806,7 +789,6 @@ fn testCeilLegacy(comptime T: type, x: T) !void {
806789}
807790
808791test "@trunc" {
809 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
810792 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
811793 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
812794 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -848,7 +830,6 @@ fn testTruncWithVectors() !void {
848830}
849831
850832test "another, possibly redundant, @trunc test" {
851 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
852833 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
853834 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
854835 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
......@@ -912,7 +893,6 @@ fn testTruncLegacy(comptime T: type, x: T) !void {
912893}
913894
914895test "negation f16" {
915 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
916896 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
917897 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
918898 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
......@@ -941,7 +921,6 @@ test "negation f32" {
941921 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
942922 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
943923 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
944 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
945924 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
946925
947926 const S = struct {
......@@ -962,7 +941,6 @@ test "negation f64" {
962941 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
963942 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
964943 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
965 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
966944 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
967945
968946 const S = struct {
......@@ -1084,7 +1062,6 @@ test "comptime_float zero divided by zero produces zero" {
10841062}
10851063
10861064test "nan negation f16" {
1087 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
10881065 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
10891066 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
10901067 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
......@@ -1104,7 +1081,6 @@ test "nan negation f16" {
11041081}
11051082
11061083test "nan negation f32" {
1107 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
11081084 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
11091085 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
11101086 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
test/behavior/muladd.zig-1
......@@ -27,7 +27,6 @@ fn testMulAdd() !void {
2727}
2828
2929test "@mulAdd f16" {
30 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
3130 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
3231 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
3332 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
test/link/wasm/archive/build.zig+1-1
......@@ -27,7 +27,7 @@ fn add(b: *std.Build, test_step: *std.Build.Step, optimize: std.builtin.Optimize
2727
2828 const check = lib.checkObject();
2929 check.checkStart("Section custom");
30 check.checkNext("name __truncsfhf2"); // Ensure it was imported and resolved
30 check.checkNext("name __trunch"); // Ensure it was imported and resolved
3131
3232 test_step.dependOn(&check.step);
3333}