authorgravatar for luuk@degram.devLuuk de Gram <luuk@degram.dev> 2023-04-07 18:22:41+02:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2023-04-07 18:22:41+02:00
log4ebf483e0da2f85e00918b7900afaf73e111b727
tree53778a17ce99dbda538ebb7880305a69f8da4322
parent48f98494fda57c5eca7b4ac899046c1dd285e471
parent8ec7723992312790cb9da7ce2f36ecde838c361e
signaturebadge-question-mark Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #14668 from Techatrix/wasm-floatops

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),
......@@ -1939,19 +1953,6 @@ fn genInst(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
19391953 .is_err_ptr,
19401954 .is_non_err_ptr,
19411955
1942 .sqrt,
1943 .sin,
1944 .cos,
1945 .tan,
1946 .exp,
1947 .exp2,
1948 .log,
1949 .log2,
1950 .log10,
1951 .fabs,
1952 .round,
1953 .neg,
1954
19551956 .cmpxchg_weak,
19561957 .cmpxchg_strong,
19571958 .fence,
......@@ -2462,7 +2463,7 @@ fn airArg(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
24622463 // When we have an argument that's passed using more than a single parameter,
24632464 // we combine them into a single stack value
24642465 if (arg_classes[0] == .direct and arg_classes[1] == .direct) {
2465 if (arg_ty.zigTypeTag() != .Int) {
2466 if (arg_ty.zigTypeTag() != .Int and arg_ty.zigTypeTag() != .Float) {
24662467 return func.fail(
24672468 "TODO: Implement C-ABI argument for type '{}'",
24682469 .{arg_ty.fmt(func.bin_file.base.options.module.?)},
......@@ -2506,6 +2507,12 @@ fn airBinOp(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerError!void {
25062507/// NOTE: THis leaves the value on top of the stack.
25072508fn binOp(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, op: Op) InnerError!WValue {
25082509 assert(!(lhs != .stack and rhs == .stack));
2510
2511 if (ty.isAnyFloat()) {
2512 const float_op = FloatOp.fromOp(op);
2513 return func.floatOp(float_op, ty, &.{ lhs, rhs });
2514 }
2515
25092516 if (isByRef(ty, func.target)) {
25102517 if (ty.zigTypeTag() == .Int) {
25112518 return func.binOpBigInt(lhs, rhs, ty, op);
......@@ -2517,10 +2524,6 @@ fn binOp(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, op: Op) InnerError!
25172524 }
25182525 }
25192526
2520 if (ty.isAnyFloat() and ty.floatBits(func.target) == 16) {
2521 return func.binOpFloat16(lhs, rhs, op);
2522 }
2523
25242527 const opcode: wasm.Opcode = buildOpcode(.{
25252528 .op = op,
25262529 .valtype1 = typeToValtype(ty, func.target),
......@@ -2534,17 +2537,6 @@ fn binOp(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, op: Op) InnerError!
25342537 return WValue{ .stack = {} };
25352538}
25362539
2537/// Performs a binary operation for 16-bit floats.
2538/// NOTE: Leaves the result value on the stack
2539fn binOpFloat16(func: *CodeGen, lhs: WValue, rhs: WValue, op: Op) InnerError!WValue {
2540 const opcode: wasm.Opcode = buildOpcode(.{ .op = op, .valtype1 = .f32, .signedness = .unsigned });
2541 _ = try func.fpext(lhs, Type.f16, Type.f32);
2542 _ = try func.fpext(rhs, Type.f16, Type.f32);
2543 try func.addTag(Mir.Inst.Tag.fromOpcode(opcode));
2544
2545 return func.fptrunc(.{ .stack = {} }, Type.f32, Type.f16);
2546}
2547
25482540fn binOpBigInt(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, op: Op) InnerError!WValue {
25492541 if (ty.intInfo(func.target).bits > 128) {
25502542 return func.fail("TODO: Implement binary operation for big integer", .{});
......@@ -2580,6 +2572,155 @@ fn binOpBigInt(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, op: Op) Inner
25802572 return result;
25812573}
25822574
2575const FloatOp = enum {
2576 add,
2577 ceil,
2578 cos,
2579 div,
2580 exp,
2581 exp2,
2582 fabs,
2583 floor,
2584 fma,
2585 fmax,
2586 fmin,
2587 fmod,
2588 log,
2589 log10,
2590 log2,
2591 mul,
2592 neg,
2593 round,
2594 sin,
2595 sqrt,
2596 sub,
2597 tan,
2598 trunc,
2599
2600 pub fn fromOp(op: Op) FloatOp {
2601 return switch (op) {
2602 .add => .add,
2603 .ceil => .ceil,
2604 .div => .div,
2605 .abs => .fabs,
2606 .floor => .floor,
2607 .max => .fmax,
2608 .min => .fmin,
2609 .mul => .mul,
2610 .neg => .neg,
2611 .nearest => .round,
2612 .sqrt => .sqrt,
2613 .sub => .sub,
2614 .trunc => .trunc,
2615 else => unreachable,
2616 };
2617 }
2618
2619 pub fn toOp(float_op: FloatOp) ?Op {
2620 return switch (float_op) {
2621 .add => .add,
2622 .ceil => .ceil,
2623 .div => .div,
2624 .fabs => .abs,
2625 .floor => .floor,
2626 .fmax => .max,
2627 .fmin => .min,
2628 .mul => .mul,
2629 .neg => .neg,
2630 .round => .nearest,
2631 .sqrt => .sqrt,
2632 .sub => .sub,
2633 .trunc => .trunc,
2634
2635 .cos,
2636 .exp,
2637 .exp2,
2638 .fma,
2639 .fmod,
2640 .log,
2641 .log10,
2642 .log2,
2643 .sin,
2644 .tan,
2645 => null,
2646 };
2647 }
2648};
2649
2650fn airUnaryFloatOp(func: *CodeGen, inst: Air.Inst.Index, op: FloatOp) InnerError!void {
2651 const un_op = func.air.instructions.items(.data)[inst].un_op;
2652 if (func.liveness.isUnused(inst)) return func.finishAir(inst, .none, &.{un_op});
2653 const operand = try func.resolveInst(un_op);
2654 const ty = func.air.typeOf(un_op);
2655
2656 const result = try (try func.floatOp(op, ty, &.{operand})).toLocal(func, ty);
2657 func.finishAir(inst, result, &.{un_op});
2658}
2659
2660fn floatOp(func: *CodeGen, float_op: FloatOp, ty: Type, args: []const WValue) InnerError!WValue {
2661 if (ty.zigTypeTag() == .Vector) {
2662 return func.fail("TODO: Implement floatOps for vectors", .{});
2663 }
2664
2665 const float_bits = ty.floatBits(func.target);
2666 if (float_bits == 32 or float_bits == 64) {
2667 if (float_op.toOp()) |op| {
2668 for (args) |operand| {
2669 try func.emitWValue(operand);
2670 }
2671 const opcode = buildOpcode(.{ .op = op, .valtype1 = typeToValtype(ty, func.target) });
2672 try func.addTag(Mir.Inst.Tag.fromOpcode(opcode));
2673 return .stack;
2674 }
2675 } else if (float_bits == 16 and float_op == .neg) {
2676 try func.emitWValue(args[0]);
2677 try func.addImm32(std.math.minInt(i16));
2678 try func.addTag(Mir.Inst.Tag.fromOpcode(.i32_xor));
2679 return .stack;
2680 } else if (float_bits == 128 and float_op == .neg) {
2681 return func.fail("TODO: Implement neg for f128", .{});
2682 }
2683
2684 var fn_name_buf: [64]u8 = undefined;
2685 const fn_name = switch (float_op) {
2686 .add,
2687 .sub,
2688 .div,
2689 .mul,
2690 => std.fmt.bufPrint(&fn_name_buf, "__{s}{s}f3", .{
2691 @tagName(float_op), target_util.compilerRtFloatAbbrev(float_bits),
2692 }) catch unreachable,
2693
2694 .ceil,
2695 .cos,
2696 .exp,
2697 .exp2,
2698 .fabs,
2699 .floor,
2700 .fma,
2701 .fmax,
2702 .fmin,
2703 .fmod,
2704 .log,
2705 .log10,
2706 .log2,
2707 .round,
2708 .sin,
2709 .sqrt,
2710 .tan,
2711 .trunc,
2712 => std.fmt.bufPrint(&fn_name_buf, "{s}{s}{s}", .{
2713 target_util.libcFloatPrefix(float_bits), @tagName(float_op), target_util.libcFloatSuffix(float_bits),
2714 }) catch unreachable,
2715 .neg => unreachable, // handled above
2716 };
2717
2718 // fma requires three operands
2719 var param_types_buffer: [3]Type = .{ ty, ty, ty };
2720 const param_types = param_types_buffer[0..args.len];
2721 return func.callIntrinsic(fn_name, param_types, ty, args);
2722}
2723
25832724fn airWrapBinOp(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerError!void {
25842725 const bin_op = func.air.instructions.items(.data)[inst].bin_op;
25852726 if (func.liveness.isUnused(inst)) return func.finishAir(inst, .none, &.{ bin_op.lhs, bin_op.rhs });
......@@ -3322,6 +3463,8 @@ fn airBitcast(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
33223463fn bitcast(func: *CodeGen, wanted_ty: Type, given_ty: Type, operand: WValue) InnerError!WValue {
33233464 // if we bitcast a float to or from an integer we must use the 'reinterpret' instruction
33243465 if (!(wanted_ty.isAnyFloat() or given_ty.isAnyFloat())) return operand;
3466 if (wanted_ty.tag() == .f16 or given_ty.tag() == .f16) return operand;
3467 if (wanted_ty.bitSize(func.target) > 64) return operand;
33253468 assert((wanted_ty.isInt() and given_ty.isAnyFloat()) or (wanted_ty.isAnyFloat() and given_ty.isInt()));
33263469
33273470 const opcode = buildOpcode(.{
......@@ -4855,7 +4998,7 @@ fn fpext(func: *CodeGen, operand: WValue, given: Type, wanted: Type) InnerError!
48554998 try func.emitWValue(operand);
48564999 try func.addTag(.f64_promote_f32);
48575000 return WValue{ .stack = {} };
4858 } else if (given_bits == 16) {
5001 } else if (given_bits == 16 and wanted_bits <= 64) {
48595002 // call __extendhfsf2(f16) f32
48605003 const f32_result = try func.callIntrinsic(
48615004 "__extendhfsf2",
......@@ -4863,19 +5006,21 @@ fn fpext(func: *CodeGen, operand: WValue, given: Type, wanted: Type) InnerError!
48635006 Type.f32,
48645007 &.{operand},
48655008 );
5009 std.debug.assert(f32_result == .stack);
48665010
4867 if (wanted_bits == 32) {
4868 return f32_result;
4869 }
48705011 if (wanted_bits == 64) {
48715012 try func.addTag(.f64_promote_f32);
4872 return WValue{ .stack = {} };
48735013 }
4874 return func.fail("TODO: Implement 'fpext' for floats with bitsize: {d}", .{wanted_bits});
4875 } else {
4876 // TODO: Emit a call to compiler-rt to extend the float. e.g. __extendhfsf2
4877 return func.fail("TODO: Implement 'fpext' for floats with bitsize: {d}", .{wanted_bits});
5014 return WValue{ .stack = {} };
48785015 }
5016
5017 var fn_name_buf: [13]u8 = undefined;
5018 const fn_name = std.fmt.bufPrint(&fn_name_buf, "__extend{s}f{s}f2", .{
5019 target_util.compilerRtFloatAbbrev(given_bits),
5020 target_util.compilerRtFloatAbbrev(wanted_bits),
5021 }) catch unreachable;
5022
5023 return func.callIntrinsic(fn_name, &.{given}, wanted, &.{operand});
48795024}
48805025
48815026fn airFptrunc(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
......@@ -4899,7 +5044,7 @@ fn fptrunc(func: *CodeGen, operand: WValue, given: Type, wanted: Type) InnerErro
48995044 try func.emitWValue(operand);
49005045 try func.addTag(.f32_demote_f64);
49015046 return WValue{ .stack = {} };
4902 } else if (wanted_bits == 16) {
5047 } else if (wanted_bits == 16 and given_bits <= 64) {
49035048 const op: WValue = if (given_bits == 64) blk: {
49045049 try func.emitWValue(operand);
49055050 try func.addTag(.f32_demote_f64);
......@@ -4908,10 +5053,15 @@ fn fptrunc(func: *CodeGen, operand: WValue, given: Type, wanted: Type) InnerErro
49085053
49095054 // call __truncsfhf2(f32) f16
49105055 return func.callIntrinsic("__truncsfhf2", &.{Type.f32}, Type.f16, &.{op});
4911 } else {
4912 // TODO: Emit a call to compiler-rt to trunc the float. e.g. __truncdfhf2
4913 return func.fail("TODO: Implement 'fptrunc' for floats with bitsize: {d}", .{wanted_bits});
49145056 }
5057
5058 var fn_name_buf: [12]u8 = undefined;
5059 const fn_name = std.fmt.bufPrint(&fn_name_buf, "__trunc{s}f{s}f2", .{
5060 target_util.compilerRtFloatAbbrev(given_bits),
5061 target_util.compilerRtFloatAbbrev(wanted_bits),
5062 }) catch unreachable;
5063
5064 return func.callIntrinsic(fn_name, &.{given}, wanted, &.{operand});
49155065}
49165066
49175067fn airErrUnionPayloadPtrSet(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
......@@ -5873,38 +6023,6 @@ fn signAbsValue(func: *CodeGen, operand: WValue, ty: Type) InnerError!WValue {
58736023 return WValue{ .stack = {} };
58746024}
58756025
5876fn airCeilFloorTrunc(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerError!void {
5877 const un_op = func.air.instructions.items(.data)[inst].un_op;
5878 if (func.liveness.isUnused(inst)) return func.finishAir(inst, .none, &.{un_op});
5879
5880 const ty = func.air.typeOfIndex(inst);
5881 const float_bits = ty.floatBits(func.target);
5882 const is_f16 = float_bits == 16;
5883
5884 if (ty.zigTypeTag() == .Vector) {
5885 return func.fail("TODO: Implement `@ceil` for vectors", .{});
5886 }
5887 if (float_bits > 64) {
5888 return func.fail("TODO: implement `@ceil`, `@trunc`, `@floor` for floats larger than 64bits", .{});
5889 }
5890
5891 const operand = try func.resolveInst(un_op);
5892 const op_to_lower = if (is_f16) blk: {
5893 break :blk try func.fpext(operand, Type.f16, Type.f32);
5894 } else operand;
5895 try func.emitWValue(op_to_lower);
5896 const opcode = buildOpcode(.{ .op = op, .valtype1 = typeToValtype(ty, func.target) });
5897 try func.addTag(Mir.Inst.Tag.fromOpcode(opcode));
5898
5899 if (is_f16) {
5900 _ = try func.fptrunc(.{ .stack = {} }, Type.f32, Type.f16);
5901 }
5902
5903 const result = try func.allocLocal(ty);
5904 try func.addLabel(.local_set, result.local.value);
5905 func.finishAir(inst, result, &.{un_op});
5906}
5907
59086026fn airSatBinOp(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerError!void {
59096027 assert(op == .add or op == .sub);
59106028 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}