authorgravatar for kubkon@jakubkonka.comJakub Konka <kubkon@jakubkonka.com> 2023-09-11 07:59:30+02:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2023-09-11 07:59:30+02:00
log975cb235cce2f713c39c0c0f7040c8ea0eb536a5
tree152166f023e13ee3ac3a90bfb0efe5fbcff175ea
parentacc9471915d74fc2cb475ea3220a249d81e3036e
parentab970094abe674b3cb33fc98db47c0cdef5f247d
signaturebadge-question-mark Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #17081 from Techatrix/wasm-float-op

wasm: implement more float operations on f80 and f128

8 files changed, 152 insertions(+), 82 deletions(-)

src/arch/wasm/CodeGen.zig+152-45
......@@ -992,13 +992,12 @@ fn addExtraAssumeCapacity(func: *CodeGen, extra: anytype) error{OutOfMemory}!u32
992992fn typeToValtype(ty: Type, mod: *Module) wasm.Valtype {
993993 const target = mod.getTarget();
994994 return switch (ty.zigTypeTag(mod)) {
995 .Float => blk: {
996 const bits = ty.floatBits(target);
997 if (bits == 16) return wasm.Valtype.i32; // stored/loaded as u16
998 if (bits == 32) break :blk wasm.Valtype.f32;
999 if (bits == 64) break :blk wasm.Valtype.f64;
1000 if (bits == 128) break :blk wasm.Valtype.i64;
1001 return wasm.Valtype.i32; // represented as pointer to stack
995 .Float => switch (ty.floatBits(target)) {
996 16 => wasm.Valtype.i32, // stored/loaded as u16
997 32 => wasm.Valtype.f32,
998 64 => wasm.Valtype.f64,
999 80, 128 => wasm.Valtype.i64,
1000 else => unreachable,
10021001 },
10031002 .Int, .Enum => blk: {
10041003 const info = ty.intInfo(mod);
......@@ -2559,7 +2558,7 @@ fn airArg(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
25592558 const result = try func.allocStack(arg_ty);
25602559 try func.store(result, arg, Type.u64, 0);
25612560 try func.store(result, func.args[arg_index + 1], Type.u64, 8);
2562 return func.finishAir(inst, arg, &.{});
2561 return func.finishAir(inst, result, &.{});
25632562 }
25642563 } else {
25652564 func.arg_index += 1;
......@@ -2651,12 +2650,18 @@ fn binOp(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, op: Op) InnerError!
26512650
26522651fn binOpBigInt(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, op: Op) InnerError!WValue {
26532652 const mod = func.bin_file.base.options.module.?;
2654 if (ty.intInfo(mod).bits > 128) {
2653 const int_info = ty.intInfo(mod);
2654 if (int_info.bits > 128) {
26552655 return func.fail("TODO: Implement binary operation for big integers larger than 128 bits", .{});
26562656 }
26572657
26582658 switch (op) {
26592659 .mul => return func.callIntrinsic("__multi3", &.{ ty.toIntern(), ty.toIntern() }, ty, &.{ lhs, rhs }),
2660 .div => switch (int_info.signedness) {
2661 .signed => return func.callIntrinsic("__udivti3", &.{ ty.toIntern(), ty.toIntern() }, ty, &.{ lhs, rhs }),
2662 .unsigned => return func.callIntrinsic("__divti3", &.{ ty.toIntern(), ty.toIntern() }, ty, &.{ lhs, rhs }),
2663 },
2664 .rem => return func.callIntrinsic("__umodti3", &.{ ty.toIntern(), ty.toIntern() }, ty, &.{ lhs, rhs }),
26602665 .shr => return func.callIntrinsic("__lshrti3", &.{ ty.toIntern(), .i32_type }, ty, &.{ lhs, rhs }),
26612666 .shl => return func.callIntrinsic("__ashlti3", &.{ ty.toIntern(), .i32_type }, ty, &.{ lhs, rhs }),
26622667 .xor => {
......@@ -2795,6 +2800,11 @@ fn floatOp(func: *CodeGen, float_op: FloatOp, ty: Type, args: []const WValue) In
27952800 }
27962801
27972802 const float_bits = ty.floatBits(func.target);
2803
2804 if (float_op == .neg) {
2805 return func.floatNeg(ty, args[0]);
2806 }
2807
27982808 if (float_bits == 32 or float_bits == 64) {
27992809 if (float_op.toOp()) |op| {
28002810 for (args) |operand| {
......@@ -2804,13 +2814,6 @@ fn floatOp(func: *CodeGen, float_op: FloatOp, ty: Type, args: []const WValue) In
28042814 try func.addTag(Mir.Inst.Tag.fromOpcode(opcode));
28052815 return .stack;
28062816 }
2807 } else if (float_bits == 16 and float_op == .neg) {
2808 try func.emitWValue(args[0]);
2809 try func.addImm32(std.math.minInt(i16));
2810 try func.addTag(Mir.Inst.Tag.fromOpcode(.i32_xor));
2811 return .stack;
2812 } else if (float_bits == 128 and float_op == .neg) {
2813 return func.fail("TODO: Implement neg for f128", .{});
28142817 }
28152818
28162819 var fn_name_buf: [64]u8 = undefined;
......@@ -2853,6 +2856,49 @@ fn floatOp(func: *CodeGen, float_op: FloatOp, ty: Type, args: []const WValue) In
28532856 return func.callIntrinsic(fn_name, param_types, ty, args);
28542857}
28552858
2859/// NOTE: The result value remains on top of the stack.
2860fn floatNeg(func: *CodeGen, ty: Type, arg: WValue) InnerError!WValue {
2861 const float_bits = ty.floatBits(func.target);
2862 switch (float_bits) {
2863 16 => {
2864 try func.emitWValue(arg);
2865 try func.addImm32(std.math.minInt(i16));
2866 try func.addTag(.i32_xor);
2867 return .stack;
2868 },
2869 32, 64 => {
2870 try func.emitWValue(arg);
2871 const val_type: wasm.Valtype = if (float_bits == 32) .f32 else .f64;
2872 const opcode = buildOpcode(.{ .op = .neg, .valtype1 = val_type });
2873 try func.addTag(Mir.Inst.Tag.fromOpcode(opcode));
2874 return .stack;
2875 },
2876 80, 128 => {
2877 const result = try func.allocStack(ty);
2878 try func.emitWValue(result);
2879 try func.emitWValue(arg);
2880 try func.addMemArg(.i64_load, .{ .offset = 0 + arg.offset(), .alignment = 2 });
2881 try func.addMemArg(.i64_store, .{ .offset = 0 + result.offset(), .alignment = 2 });
2882
2883 try func.emitWValue(result);
2884 try func.emitWValue(arg);
2885 try func.addMemArg(.i64_load, .{ .offset = 8 + arg.offset(), .alignment = 2 });
2886
2887 if (float_bits == 80) {
2888 try func.addImm64(0x8000);
2889 try func.addTag(.i64_xor);
2890 try func.addMemArg(.i64_store16, .{ .offset = 8 + result.offset(), .alignment = 2 });
2891 } else {
2892 try func.addImm64(0x8000000000000000);
2893 try func.addTag(.i64_xor);
2894 try func.addMemArg(.i64_store, .{ .offset = 8 + result.offset(), .alignment = 2 });
2895 }
2896 return result;
2897 },
2898 else => unreachable,
2899 }
2900}
2901
28562902fn airWrapBinOp(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerError!void {
28572903 const mod = func.bin_file.base.options.module.?;
28582904 const bin_op = func.air.instructions.items(.data)[inst].bin_op;
......@@ -3430,10 +3476,10 @@ fn cmp(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, op: std.math.CompareO
34303476 // both lhs and rhs, as well as checking the payload are matching of lhs and rhs
34313477 return func.cmpOptionals(lhs, rhs, ty, op);
34323478 }
3479 } else if (ty.isAnyFloat()) {
3480 return func.cmpFloat(ty, lhs, rhs, op);
34333481 } else if (isByRef(ty, mod)) {
34343482 return func.cmpBigInt(lhs, rhs, ty, op);
3435 } else if (ty.isAnyFloat() and ty.floatBits(func.target) == 16) {
3436 return func.cmpFloat16(lhs, rhs, op);
34373483 }
34383484
34393485 // ensure that when we compare pointers, we emit
......@@ -3465,26 +3511,47 @@ fn cmp(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, op: std.math.CompareO
34653511 return WValue{ .stack = {} };
34663512}
34673513
3468/// Compares 16-bit floats
3469/// NOTE: The result value remains on top of the stack.
3470fn cmpFloat16(func: *CodeGen, lhs: WValue, rhs: WValue, op: std.math.CompareOperator) InnerError!WValue {
3471 const opcode: wasm.Opcode = buildOpcode(.{
3472 .op = switch (op) {
3473 .lt => .lt,
3474 .lte => .le,
3475 .eq => .eq,
3476 .neq => .ne,
3477 .gte => .ge,
3478 .gt => .gt,
3479 },
3480 .valtype1 = .f32,
3481 .signedness = .unsigned,
3482 });
3483 _ = try func.fpext(lhs, Type.f16, Type.f32);
3484 _ = try func.fpext(rhs, Type.f16, Type.f32);
3485 try func.addTag(Mir.Inst.Tag.fromOpcode(opcode));
3514/// Compares two floats.
3515/// NOTE: Leaves the result of the comparison on top of the stack.
3516fn cmpFloat(func: *CodeGen, ty: Type, lhs: WValue, rhs: WValue, cmp_op: std.math.CompareOperator) InnerError!WValue {
3517 const float_bits = ty.floatBits(func.target);
34863518
3487 return WValue{ .stack = {} };
3519 const op: Op = switch (cmp_op) {
3520 .lt => .lt,
3521 .lte => .le,
3522 .eq => .eq,
3523 .neq => .ne,
3524 .gte => .ge,
3525 .gt => .gt,
3526 };
3527
3528 switch (float_bits) {
3529 16 => {
3530 _ = try func.fpext(lhs, Type.f16, Type.f32);
3531 _ = try func.fpext(rhs, Type.f16, Type.f32);
3532 const opcode = buildOpcode(.{ .op = op, .valtype1 = .f32 });
3533 try func.addTag(Mir.Inst.Tag.fromOpcode(opcode));
3534 return .stack;
3535 },
3536 32, 64 => {
3537 try func.emitWValue(lhs);
3538 try func.emitWValue(rhs);
3539 const val_type: wasm.Valtype = if (float_bits == 32) .f32 else .f64;
3540 const opcode = buildOpcode(.{ .op = op, .valtype1 = val_type });
3541 try func.addTag(Mir.Inst.Tag.fromOpcode(opcode));
3542 return .stack;
3543 },
3544 80, 128 => {
3545 var fn_name_buf: [32]u8 = undefined;
3546 const fn_name = std.fmt.bufPrint(&fn_name_buf, "__{s}{s}f2", .{
3547 @tagName(op), target_util.compilerRtFloatAbbrev(float_bits),
3548 }) catch unreachable;
3549
3550 const result = try func.callIntrinsic(fn_name, &.{ ty.ip_index, ty.ip_index }, Type.bool, &.{ lhs, rhs });
3551 return func.cmp(result, WValue{ .imm32 = 0 }, Type.i32, cmp_op);
3552 },
3553 else => unreachable,
3554 }
34883555}
34893556
34903557fn airCmpVector(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
......@@ -4796,11 +4863,31 @@ fn airIntFromFloat(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
47964863 const ty_op = func.air.instructions.items(.data)[inst].ty_op;
47974864
47984865 const operand = try func.resolveInst(ty_op.operand);
4799 const dest_ty = func.typeOfIndex(inst);
48004866 const op_ty = func.typeOf(ty_op.operand);
4867 const op_bits = op_ty.floatBits(func.target);
4868
4869 const dest_ty = func.typeOfIndex(inst);
4870 const dest_info = dest_ty.intInfo(mod);
4871
4872 if (dest_info.bits > 128) {
4873 return func.fail("TODO: intFromFloat for integers/floats with bitsize {}", .{dest_info.bits});
4874 }
4875
4876 if ((op_bits != 32 and op_bits != 64) or dest_info.bits > 64) {
4877 const dest_bitsize = if (dest_info.bits <= 16) 16 else std.math.ceilPowerOfTwoAssert(u16, dest_info.bits);
4878
4879 var fn_name_buf: [16]u8 = undefined;
4880 const fn_name = std.fmt.bufPrint(&fn_name_buf, "__fix{s}{s}f{s}i", .{
4881 switch (dest_info.signedness) {
4882 .signed => "",
4883 .unsigned => "uns",
4884 },
4885 target_util.compilerRtFloatAbbrev(op_bits),
4886 target_util.compilerRtIntAbbrev(dest_bitsize),
4887 }) catch unreachable;
48014888
4802 if (op_ty.abiSize(mod) > 8) {
4803 return func.fail("TODO: intFromFloat for integers/floats with bitsize larger than 64 bits", .{});
4889 const result = try (try func.callIntrinsic(fn_name, &.{op_ty.ip_index}, dest_ty, &.{operand})).toLocal(func, dest_ty);
4890 return func.finishAir(inst, result, &.{ty_op.operand});
48044891 }
48054892
48064893 try func.emitWValue(operand);
......@@ -4808,7 +4895,7 @@ fn airIntFromFloat(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
48084895 .op = .trunc,
48094896 .valtype1 = typeToValtype(dest_ty, mod),
48104897 .valtype2 = typeToValtype(op_ty, mod),
4811 .signedness = if (dest_ty.isSignedInt(mod)) .signed else .unsigned,
4898 .signedness = dest_info.signedness,
48124899 });
48134900 try func.addTag(Mir.Inst.Tag.fromOpcode(op));
48144901 const wrapped = try func.wrapOperand(.{ .stack = {} }, dest_ty);
......@@ -4821,11 +4908,31 @@ fn airFloatFromInt(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
48214908 const ty_op = func.air.instructions.items(.data)[inst].ty_op;
48224909
48234910 const operand = try func.resolveInst(ty_op.operand);
4824 const dest_ty = func.typeOfIndex(inst);
48254911 const op_ty = func.typeOf(ty_op.operand);
4912 const op_info = op_ty.intInfo(mod);
4913
4914 const dest_ty = func.typeOfIndex(inst);
4915 const dest_bits = dest_ty.floatBits(func.target);
4916
4917 if (op_info.bits > 128) {
4918 return func.fail("TODO: floatFromInt for integers/floats with bitsize {d} bits", .{op_info.bits});
4919 }
4920
4921 if (op_info.bits > 64 or (dest_bits > 64 or dest_bits < 32)) {
4922 const op_bitsize = if (op_info.bits <= 16) 16 else std.math.ceilPowerOfTwoAssert(u16, op_info.bits);
4923
4924 var fn_name_buf: [16]u8 = undefined;
4925 const fn_name = std.fmt.bufPrint(&fn_name_buf, "__float{s}{s}i{s}f", .{
4926 switch (op_info.signedness) {
4927 .signed => "",
4928 .unsigned => "un",
4929 },
4930 target_util.compilerRtIntAbbrev(op_bitsize),
4931 target_util.compilerRtFloatAbbrev(dest_bits),
4932 }) catch unreachable;
48264933
4827 if (op_ty.abiSize(mod) > 8) {
4828 return func.fail("TODO: floatFromInt for integers/floats with bitsize larger than 64 bits", .{});
4934 const result = try (try func.callIntrinsic(fn_name, &.{op_ty.ip_index}, dest_ty, &.{operand})).toLocal(func, dest_ty);
4935 return func.finishAir(inst, result, &.{ty_op.operand});
48294936 }
48304937
48314938 try func.emitWValue(operand);
......@@ -4833,7 +4940,7 @@ fn airFloatFromInt(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
48334940 .op = .convert,
48344941 .valtype1 = typeToValtype(dest_ty, mod),
48354942 .valtype2 = typeToValtype(op_ty, mod),
4836 .signedness = if (op_ty.isSignedInt(mod)) .signed else .unsigned,
4943 .signedness = op_info.signedness,
48374944 });
48384945 try func.addTag(Mir.Inst.Tag.fromOpcode(op));
48394946
test/behavior/bitcast.zig-1
......@@ -416,7 +416,6 @@ test "bitcast nan float does not modify signaling bit" {
416416 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
417417 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
418418 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
419 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
420419 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
421420 // TODO: https://github.com/ziglang/zig/issues/14366
422421 if (builtin.zig_backend == .stage2_llvm and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
test/behavior/cast.zig-5
......@@ -120,7 +120,6 @@ test "@floatFromInt(f80)" {
120120 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
121121 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
122122 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
123 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
124123 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
125124 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
126125 if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
......@@ -1248,7 +1247,6 @@ fn castToOptionalSlice() ?[]const u8 {
12481247test "cast u128 to f128 and back" {
12491248 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
12501249 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1251 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
12521250 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
12531251 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
12541252
......@@ -1392,7 +1390,6 @@ test "cast f16 to wider types" {
13921390 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
13931391 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
13941392 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1395 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
13961393 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
13971394 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
13981395 if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
......@@ -1413,7 +1410,6 @@ test "cast f128 to narrower types" {
14131410 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
14141411 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
14151412 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1416 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
14171413 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
14181414 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
14191415
......@@ -1503,7 +1499,6 @@ test "coerce between pointers of compatible differently-named floats" {
15031499 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
15041500 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
15051501 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1506 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
15071502 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
15081503 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
15091504
test/behavior/floatop.zig-17
......@@ -71,7 +71,6 @@ fn testDifferentSizedFloatComparisons() !void {
7171}
7272
7373test "f80 comparisons" {
74 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
7574 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
7675 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
7776 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
......@@ -571,7 +570,6 @@ fn testFabsWithVectors() !void {
571570}
572571
573572test "another, possibly redundant, @fabs test" {
574 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
575573 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
576574 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
577575 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
......@@ -594,7 +592,6 @@ test "another, possibly redundant, @fabs test" {
594592}
595593
596594test "@fabs f80" {
597 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
598595 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
599596 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
600597 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
......@@ -612,7 +609,6 @@ fn testFabsLegacy(comptime T: type, x: T) !void {
612609}
613610
614611test "a third @fabs test, surely there should not be three fabs tests" {
615 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
616612 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
617613 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
618614 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
......@@ -704,7 +700,6 @@ test "another, possibly redundant, @floor test" {
704700}
705701
706702test "@floor f80" {
707 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
708703 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
709704 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
710705 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
......@@ -721,7 +716,6 @@ test "@floor f80" {
721716}
722717
723718test "@floor f128" {
724 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
725719 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
726720 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
727721 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
......@@ -802,7 +796,6 @@ test "another, possibly redundant, @ceil test" {
802796}
803797
804798test "@ceil f80" {
805 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
806799 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
807800 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
808801 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
......@@ -819,7 +812,6 @@ test "@ceil f80" {
819812}
820813
821814test "@ceil f128" {
822 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
823815 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
824816 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
825817 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
......@@ -899,7 +891,6 @@ test "another, possibly redundant, @trunc test" {
899891}
900892
901893test "@trunc f80" {
902 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
903894 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
904895 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
905896 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
......@@ -922,7 +913,6 @@ test "@trunc f80" {
922913}
923914
924915test "@trunc f128" {
925 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
926916 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
927917 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
928918 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
......@@ -1017,7 +1007,6 @@ test "negation f80" {
10171007 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
10181008 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10191009 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1020 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
10211010 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10221011 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
10231012
......@@ -1039,7 +1028,6 @@ test "negation f128" {
10391028 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
10401029 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10411030 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1042 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
10431031 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10441032 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
10451033
......@@ -1081,7 +1069,6 @@ test "f128 at compile time is lossy" {
10811069}
10821070
10831071test "comptime fixed-width float zero divided by zero produces NaN" {
1084 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
10851072 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
10861073 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10871074 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
......@@ -1094,7 +1081,6 @@ test "comptime fixed-width float zero divided by zero produces NaN" {
10941081}
10951082
10961083test "comptime fixed-width float non-zero divided by zero produces signed Inf" {
1097 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
10981084 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10991085 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
11001086 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -1153,7 +1139,6 @@ test "nan negation f32" {
11531139}
11541140
11551141test "nan negation f64" {
1156 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
11571142 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
11581143 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11591144 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -1173,7 +1158,6 @@ test "nan negation f64" {
11731158}
11741159
11751160test "nan negation f128" {
1176 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
11771161 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
11781162 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11791163 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -1193,7 +1177,6 @@ test "nan negation f128" {
11931177}
11941178
11951179test "nan negation f80" {
1196 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
11971180 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
11981181 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
11991182 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
test/behavior/math.zig-8
......@@ -628,7 +628,6 @@ fn testShrTrunc(x: u16) !void {
628628}
629629
630630test "f128" {
631 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
632631 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
633632 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
634633 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
......@@ -1430,7 +1429,6 @@ fn fmodOne(comptime T: type, a: T, b: T, c: T, epsilon: T) !void {
14301429}
14311430
14321431test "@round" {
1433 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
14341432 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
14351433 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
14361434 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
......@@ -1451,7 +1449,6 @@ test "@round" {
14511449}
14521450
14531451test "@round f80" {
1454 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
14551452 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
14561453 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
14571454 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
......@@ -1464,7 +1461,6 @@ test "@round f80" {
14641461}
14651462
14661463test "@round f128" {
1467 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
14681464 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
14691465 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
14701466 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
......@@ -1505,7 +1501,6 @@ test "vector integer addition" {
15051501}
15061502
15071503test "NaN comparison" {
1508 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
15091504 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
15101505 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
15111506 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
......@@ -1523,7 +1518,6 @@ test "NaN comparison" {
15231518}
15241519
15251520test "NaN comparison f80" {
1526 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
15271521 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
15281522 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
15291523 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
......@@ -1577,7 +1571,6 @@ test "compare undefined literal with comptime_int" {
15771571}
15781572
15791573test "signed zeros are represented properly" {
1580 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
15811574 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
15821575 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
15831576 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -1612,7 +1605,6 @@ test "comptime sin and ln" {
16121605}
16131606
16141607test "absFloat" {
1615 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
16161608 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
16171609 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
16181610 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
test/behavior/maximum_minimum.zig-2
......@@ -104,7 +104,6 @@ test "@min for vectors" {
104104}
105105
106106test "@min/max for floats" {
107 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
108107 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
109108 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
110109 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
......@@ -198,7 +197,6 @@ test "@min/@max notices vector bounds" {
198197}
199198
200199test "@min/@max on comptime_int" {
201 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
202200 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
203201 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
204202 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
test/behavior/muladd.zig-2
......@@ -50,7 +50,6 @@ fn testMulAdd16() !void {
5050}
5151
5252test "@mulAdd f80" {
53 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
5453 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
5554 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
5655 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
......@@ -70,7 +69,6 @@ fn testMulAdd80() !void {
7069}
7170
7271test "@mulAdd f128" {
73 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
7472 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
7573 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
7674 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
test/behavior/widening.zig-2
......@@ -40,7 +40,6 @@ test "implicit unsigned integer to signed integer" {
4040}
4141
4242test "float widening" {
43 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
4443 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
4544 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
4645 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
......@@ -61,7 +60,6 @@ test "float widening" {
6160}
6261
6362test "float widening f16 to f128" {
64 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
6563 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
6664 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
6765 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO