Morph MORPH
SIGN IN SIGN UP
ziglang / zig UNCLAIMED

Moved to Codeberg

0 0 0 Zig
Normal View History Raw
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
const builtin = @import("builtin");
remove @minValue,@maxValue; add std.math.minInt,maxInt closes #1466 closes #1476
2018-10-26 14:59:58 -04:00
const std = @import("std");
test/behavior: replace all 'comptime expect' with 'comptime assert'
2024-01-15 16:01:13 +11:00
const assert = std.debug.assert;
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
const expect = std.testing.expect;
implement vector math safety with ext and trunc
2019-02-09 15:23:29 -05:00
const expectEqual = std.testing.expectEqual;
const expectEqualSlices = std.testing.expectEqualSlices;
remove @minValue,@maxValue; add std.math.minInt,maxInt closes #1466 closes #1476
2018-10-26 14:59:58 -04:00
const maxInt = std.math.maxInt;
const minInt = std.math.minInt;
add behavior test for vector comparison
2019-12-16 11:22:28 -05:00
const mem = std.mem;
compiler-rt: math functions reorg * unify the logic for exporting math functions from compiler-rt, with the appropriate suffixes and prefixes. - add all missing f128 and f80 exports. Functions with missing implementations call other functions and have TODO comments. - also add f16 functions * move math functions from freestanding libc to compiler-rt (#7265) * enable all the f128 and f80 code in the stage2 compiler and behavior tests (#11161). * update std lib to use builtins rather than `std.math`.
2022-04-26 10:13:55 -07:00
const math = std.math;
self hosted tests import std library
2017-01-05 03:57:48 -05:00
builtin functions for division and remainder division * add `@divTrunc` and `@divFloor` functions * add `@rem` and `@mod` functions * add compile error for `/` and `%` with signed integers * add `.bit_count` for float primitive types closes #217
2017-05-06 23:13:12 -04:00
test "assignment operators" {
behavior tests cleanup: promote math.zig
2022-03-03 01:23:50 -07:00
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
behavior tests cleanup: promote math.zig
2022-03-03 01:23:50 -07:00
builtin functions for division and remainder division * add `@divTrunc` and `@divFloor` functions * add `@rem` and `@mod` functions * add compile error for `/` and `%` with signed integers * add `.bit_count` for float primitive types closes #217
2017-05-06 23:13:12 -04:00
var i: u32 = 0;
[breaking] delete ptr deref prefix op start using zig-fmt-pointer-reform branch build of zig fmt to fix code to use the new syntax all of test/cases/* are processed, but there are more left to be done - all the std lib used by the behavior tests
2018-04-30 20:35:54 -04:00
i += 5;
update usage of std.testing in behavior and standalone tests
2021-05-04 21:23:22 +03:00
try expect(i == 5);
[breaking] delete ptr deref prefix op start using zig-fmt-pointer-reform branch build of zig fmt to fix code to use the new syntax all of test/cases/* are processed, but there are more left to be done - all the std lib used by the behavior tests
2018-04-30 20:35:54 -04:00
i -= 2;
update usage of std.testing in behavior and standalone tests
2021-05-04 21:23:22 +03:00
try expect(i == 3);
[breaking] delete ptr deref prefix op start using zig-fmt-pointer-reform branch build of zig fmt to fix code to use the new syntax all of test/cases/* are processed, but there are more left to be done - all the std lib used by the behavior tests
2018-04-30 20:35:54 -04:00
i *= 20;
update usage of std.testing in behavior and standalone tests
2021-05-04 21:23:22 +03:00
try expect(i == 60);
[breaking] delete ptr deref prefix op start using zig-fmt-pointer-reform branch build of zig fmt to fix code to use the new syntax all of test/cases/* are processed, but there are more left to be done - all the std lib used by the behavior tests
2018-04-30 20:35:54 -04:00
i /= 3;
update usage of std.testing in behavior and standalone tests
2021-05-04 21:23:22 +03:00
try expect(i == 20);
[breaking] delete ptr deref prefix op start using zig-fmt-pointer-reform branch build of zig fmt to fix code to use the new syntax all of test/cases/* are processed, but there are more left to be done - all the std lib used by the behavior tests
2018-04-30 20:35:54 -04:00
i %= 11;
update usage of std.testing in behavior and standalone tests
2021-05-04 21:23:22 +03:00
try expect(i == 9);
[breaking] delete ptr deref prefix op start using zig-fmt-pointer-reform branch build of zig fmt to fix code to use the new syntax all of test/cases/* are processed, but there are more left to be done - all the std lib used by the behavior tests
2018-04-30 20:35:54 -04:00
i <<= 1;
update usage of std.testing in behavior and standalone tests
2021-05-04 21:23:22 +03:00
try expect(i == 18);
[breaking] delete ptr deref prefix op start using zig-fmt-pointer-reform branch build of zig fmt to fix code to use the new syntax all of test/cases/* are processed, but there are more left to be done - all the std lib used by the behavior tests
2018-04-30 20:35:54 -04:00
i >>= 2;
update usage of std.testing in behavior and standalone tests
2021-05-04 21:23:22 +03:00
try expect(i == 4);
IR: port some tests
2016-12-22 00:55:21 -05:00
i = 6;
[breaking] delete ptr deref prefix op start using zig-fmt-pointer-reform branch build of zig fmt to fix code to use the new syntax all of test/cases/* are processed, but there are more left to be done - all the std lib used by the behavior tests
2018-04-30 20:35:54 -04:00
i &= 5;
update usage of std.testing in behavior and standalone tests
2021-05-04 21:23:22 +03:00
try expect(i == 4);
[breaking] delete ptr deref prefix op start using zig-fmt-pointer-reform branch build of zig fmt to fix code to use the new syntax all of test/cases/* are processed, but there are more left to be done - all the std lib used by the behavior tests
2018-04-30 20:35:54 -04:00
i ^= 6;
update usage of std.testing in behavior and standalone tests
2021-05-04 21:23:22 +03:00
try expect(i == 2);
IR: port some tests
2016-12-22 00:55:21 -05:00
i = 6;
[breaking] delete ptr deref prefix op start using zig-fmt-pointer-reform branch build of zig fmt to fix code to use the new syntax all of test/cases/* are processed, but there are more left to be done - all the std lib used by the behavior tests
2018-04-30 20:35:54 -04:00
i |= 3;
update usage of std.testing in behavior and standalone tests
2021-05-04 21:23:22 +03:00
try expect(i == 7);
IR: port some tests
2016-12-22 00:55:21 -05:00
}
clean up behavior test names
2017-05-23 21:38:31 -04:00
test "three expr in a row" {
update usage of std.testing in behavior and standalone tests
2021-05-04 21:23:22 +03:00
try testThreeExprInARow(false, true);
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime testThreeExprInARow(false, true);
update usage of std.testing in behavior and standalone tests
2021-05-04 21:23:22 +03:00
}
fn testThreeExprInARow(f: bool, t: bool) !void {
try assertFalse(f or f or f);
try assertFalse(t and t and f);
try assertFalse(1 | 2 | 4 != 7);
try assertFalse(3 ^ 6 ^ 8 != 13);
try assertFalse(7 & 14 & 28 != 4);
try assertFalse(9 << 1 << 2 != 9 << 3);
try assertFalse(90 >> 1 >> 2 != 90 >> 3);
try assertFalse(100 - 1 + 1000 != 1099);
try assertFalse(5 * 4 / 2 % 3 != 1);
try assertFalse(@as(i32, @as(i32, 5)) != 5);
try assertFalse(!!false);
try assertFalse(@as(i32, 7) != --(@as(i32, 7)));
}
fn assertFalse(b: bool) !void {
try expect(!b);
IR: port more tests
2016-12-22 01:20:08 -05:00
}
stage2: implement `@clz` and `@ctz` Also improve the LLVM backend to support lowering bigints to LLVM values. Moves over a bunch of math.zig test cases to the "passing for stage2" section.
2021-09-28 22:38:51 -07:00
test "@clz" {
behavior tests cleanup: promote math.zig
2022-03-03 01:23:50 -07:00
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
behavior tests cleanup: promote math.zig
2022-03-03 01:23:50 -07:00
stage2: implement `@clz` and `@ctz` Also improve the LLVM backend to support lowering bigints to LLVM values. Moves over a bunch of math.zig test cases to the "passing for stage2" section.
2021-09-28 22:38:51 -07:00
try testClz();
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime testClz();
stage2: implement `@clz` and `@ctz` Also improve the LLVM backend to support lowering bigints to LLVM values. Moves over a bunch of math.zig test cases to the "passing for stage2" section.
2021-09-28 22:38:51 -07:00
}
fn testClz() !void {
try expect(testOneClz(u8, 0b10001010) == 0);
try expect(testOneClz(u8, 0b00001010) == 4);
try expect(testOneClz(u8, 0b00011010) == 3);
try expect(testOneClz(u8, 0b00000000) == 8);
CBE: implement clz, ctz for ints <= 128 bits
2022-03-11 11:48:11 +00:00
}
test "@clz big ints" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
setup spirv backend in behavior tests
2023-05-11 09:23:34 +03:30
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
x86_64+macho: pass more behavior tests
2024-01-29 15:33:45 +01:00
if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
CBE: implement clz, ctz for ints <= 128 bits
2022-03-11 11:48:11 +00:00
try testClzBigInts();
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime testClzBigInts();
CBE: implement clz, ctz for ints <= 128 bits
2022-03-11 11:48:11 +00:00
}
fn testClzBigInts() !void {
stage2: implement `@clz` and `@ctz` Also improve the LLVM backend to support lowering bigints to LLVM values. Moves over a bunch of math.zig test cases to the "passing for stage2" section.
2021-09-28 22:38:51 -07:00
try expect(testOneClz(u128, 0xffffffffffffffff) == 64);
try expect(testOneClz(u128, 0x10000000000000000) == 63);
}
fn testOneClz(comptime T: type, x: T) u32 {
stage2+stage1: remove type parameter from bit builtins Closes #12529 Closes #12511 Closes #6835
2022-08-21 17:24:04 +03:00
return @clz(x);
stage2: implement `@clz` and `@ctz` Also improve the LLVM backend to support lowering bigints to LLVM values. Moves over a bunch of math.zig test cases to the "passing for stage2" section.
2021-09-28 22:38:51 -07:00
}
stage2: implement `@ctz` and `@clz` including SIMD AIR: * `array_elem_val` is now allowed to be used with a vector as the array type. * New instructions: splat, vector_init AstGen: * The splat ZIR instruction uses coerced_ty for the ResultLoc, avoiding an unnecessary `as` instruction, since the coercion will be performed in Sema. * Builtins that accept vectors now ignore the type parameter. Comment from this commit reproduced here: The accepted proposal #6835 tells us to remove the type parameter from these builtins. To stay source-compatible with stage1, we still observe the parameter here, but we do not encode it into the ZIR. To implement this proposal in stage2, only AstGen code will need to be changed. Sema: * `clz` and `ctz` ZIR instructions are now handled by the same function which accept AIR tag and comptime eval function pointer to differentiate. * `@typeInfo` for vectors is implemented. * `@splat` is implemented. It takes advantage of `Value.Tag.repeated` 😎 * `elemValue` is implemented for vectors, when the index is a scalar. Handling a vector index is still TODO. * Element-wise coercion is implemented for vectors. It could probably be optimized a bit, but it is at least complete & correct. * `Type.intInfo` supports vectors, returning int info for the element. * `Value.ctz` initial implementation. Needs work. * `Value.eql` is implemented for arrays and vectors. LLVM backend: * Implement vector support when lowering `array_elem_val`. * Implement vector support when lowering `ctz` and `clz`. * Implement `splat` and `vector_init`.
2022-01-12 23:53:26 -07:00
test "@clz vectors" {
behavior tests cleanup: promote math.zig
2022-03-03 01:23:50 -07:00
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
setup spirv backend in behavior tests
2023-05-11 09:23:34 +03:30
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
behavior tests cleanup: promote math.zig
2022-03-03 01:23:50 -07:00
stage2: implement `@ctz` and `@clz` including SIMD AIR: * `array_elem_val` is now allowed to be used with a vector as the array type. * New instructions: splat, vector_init AstGen: * The splat ZIR instruction uses coerced_ty for the ResultLoc, avoiding an unnecessary `as` instruction, since the coercion will be performed in Sema. * Builtins that accept vectors now ignore the type parameter. Comment from this commit reproduced here: The accepted proposal #6835 tells us to remove the type parameter from these builtins. To stay source-compatible with stage1, we still observe the parameter here, but we do not encode it into the ZIR. To implement this proposal in stage2, only AstGen code will need to be changed. Sema: * `clz` and `ctz` ZIR instructions are now handled by the same function which accept AIR tag and comptime eval function pointer to differentiate. * `@typeInfo` for vectors is implemented. * `@splat` is implemented. It takes advantage of `Value.Tag.repeated` 😎 * `elemValue` is implemented for vectors, when the index is a scalar. Handling a vector index is still TODO. * Element-wise coercion is implemented for vectors. It could probably be optimized a bit, but it is at least complete & correct. * `Type.intInfo` supports vectors, returning int info for the element. * `Value.ctz` initial implementation. Needs work. * `Value.eql` is implemented for arrays and vectors. LLVM backend: * Implement vector support when lowering `array_elem_val`. * Implement vector support when lowering `ctz` and `clz`. * Implement `splat` and `vector_init`.
2022-01-12 23:53:26 -07:00
try testClzVectors();
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime testClzVectors();
stage2: implement `@ctz` and `@clz` including SIMD AIR: * `array_elem_val` is now allowed to be used with a vector as the array type. * New instructions: splat, vector_init AstGen: * The splat ZIR instruction uses coerced_ty for the ResultLoc, avoiding an unnecessary `as` instruction, since the coercion will be performed in Sema. * Builtins that accept vectors now ignore the type parameter. Comment from this commit reproduced here: The accepted proposal #6835 tells us to remove the type parameter from these builtins. To stay source-compatible with stage1, we still observe the parameter here, but we do not encode it into the ZIR. To implement this proposal in stage2, only AstGen code will need to be changed. Sema: * `clz` and `ctz` ZIR instructions are now handled by the same function which accept AIR tag and comptime eval function pointer to differentiate. * `@typeInfo` for vectors is implemented. * `@splat` is implemented. It takes advantage of `Value.Tag.repeated` 😎 * `elemValue` is implemented for vectors, when the index is a scalar. Handling a vector index is still TODO. * Element-wise coercion is implemented for vectors. It could probably be optimized a bit, but it is at least complete & correct. * `Type.intInfo` supports vectors, returning int info for the element. * `Value.ctz` initial implementation. Needs work. * `Value.eql` is implemented for arrays and vectors. LLVM backend: * Implement vector support when lowering `array_elem_val`. * Implement vector support when lowering `ctz` and `clz`. * Implement `splat` and `vector_init`.
2022-01-12 23:53:26 -07:00
}
fn testClzVectors() !void {
Update tests to new splat syntax
2023-07-07 20:41:33 +02:00
const Vu4 = @Vector(64, u4);
const Vu8 = @Vector(64, u8);
const Vu128 = @Vector(64, u128);
stage2: implement `@ctz` and `@clz` including SIMD AIR: * `array_elem_val` is now allowed to be used with a vector as the array type. * New instructions: splat, vector_init AstGen: * The splat ZIR instruction uses coerced_ty for the ResultLoc, avoiding an unnecessary `as` instruction, since the coercion will be performed in Sema. * Builtins that accept vectors now ignore the type parameter. Comment from this commit reproduced here: The accepted proposal #6835 tells us to remove the type parameter from these builtins. To stay source-compatible with stage1, we still observe the parameter here, but we do not encode it into the ZIR. To implement this proposal in stage2, only AstGen code will need to be changed. Sema: * `clz` and `ctz` ZIR instructions are now handled by the same function which accept AIR tag and comptime eval function pointer to differentiate. * `@typeInfo` for vectors is implemented. * `@splat` is implemented. It takes advantage of `Value.Tag.repeated` 😎 * `elemValue` is implemented for vectors, when the index is a scalar. Handling a vector index is still TODO. * Element-wise coercion is implemented for vectors. It could probably be optimized a bit, but it is at least complete & correct. * `Type.intInfo` supports vectors, returning int info for the element. * `Value.ctz` initial implementation. Needs work. * `Value.eql` is implemented for arrays and vectors. LLVM backend: * Implement vector support when lowering `array_elem_val`. * Implement vector support when lowering `ctz` and `clz`. * Implement `splat` and `vector_init`.
2022-01-12 23:53:26 -07:00
@setEvalBranchQuota(10_000);
Update tests to new splat syntax
2023-07-07 20:41:33 +02:00
try testOneClzVector(u8, 64, @as(Vu8, @splat(0b10001010)), @as(Vu4, @splat(0)));
try testOneClzVector(u8, 64, @as(Vu8, @splat(0b00001010)), @as(Vu4, @splat(4)));
try testOneClzVector(u8, 64, @as(Vu8, @splat(0b00011010)), @as(Vu4, @splat(3)));
try testOneClzVector(u8, 64, @as(Vu8, @splat(0b00000000)), @as(Vu4, @splat(8)));
try testOneClzVector(u128, 64, @as(Vu128, @splat(0xffffffffffffffff)), @as(Vu8, @splat(64)));
try testOneClzVector(u128, 64, @as(Vu128, @splat(0x10000000000000000)), @as(Vu8, @splat(63)));
stage2: implement `@ctz` and `@clz` including SIMD AIR: * `array_elem_val` is now allowed to be used with a vector as the array type. * New instructions: splat, vector_init AstGen: * The splat ZIR instruction uses coerced_ty for the ResultLoc, avoiding an unnecessary `as` instruction, since the coercion will be performed in Sema. * Builtins that accept vectors now ignore the type parameter. Comment from this commit reproduced here: The accepted proposal #6835 tells us to remove the type parameter from these builtins. To stay source-compatible with stage1, we still observe the parameter here, but we do not encode it into the ZIR. To implement this proposal in stage2, only AstGen code will need to be changed. Sema: * `clz` and `ctz` ZIR instructions are now handled by the same function which accept AIR tag and comptime eval function pointer to differentiate. * `@typeInfo` for vectors is implemented. * `@splat` is implemented. It takes advantage of `Value.Tag.repeated` 😎 * `elemValue` is implemented for vectors, when the index is a scalar. Handling a vector index is still TODO. * Element-wise coercion is implemented for vectors. It could probably be optimized a bit, but it is at least complete & correct. * `Type.intInfo` supports vectors, returning int info for the element. * `Value.ctz` initial implementation. Needs work. * `Value.eql` is implemented for arrays and vectors. LLVM backend: * Implement vector support when lowering `array_elem_val`. * Implement vector support when lowering `ctz` and `clz`. * Implement `splat` and `vector_init`.
2022-01-12 23:53:26 -07:00
}
fn testOneClzVector(
comptime T: type,
comptime len: u32,
x: @Vector(len, T),
expected: @Vector(len, u32),
) !void {
stage2+stage1: remove type parameter from bit builtins Closes #12529 Closes #12511 Closes #6835
2022-08-21 17:24:04 +03:00
try expectVectorsEqual(@clz(x), expected);
stage2: implement `@ctz` and `@clz` including SIMD AIR: * `array_elem_val` is now allowed to be used with a vector as the array type. * New instructions: splat, vector_init AstGen: * The splat ZIR instruction uses coerced_ty for the ResultLoc, avoiding an unnecessary `as` instruction, since the coercion will be performed in Sema. * Builtins that accept vectors now ignore the type parameter. Comment from this commit reproduced here: The accepted proposal #6835 tells us to remove the type parameter from these builtins. To stay source-compatible with stage1, we still observe the parameter here, but we do not encode it into the ZIR. To implement this proposal in stage2, only AstGen code will need to be changed. Sema: * `clz` and `ctz` ZIR instructions are now handled by the same function which accept AIR tag and comptime eval function pointer to differentiate. * `@typeInfo` for vectors is implemented. * `@splat` is implemented. It takes advantage of `Value.Tag.repeated` 😎 * `elemValue` is implemented for vectors, when the index is a scalar. Handling a vector index is still TODO. * Element-wise coercion is implemented for vectors. It could probably be optimized a bit, but it is at least complete & correct. * `Type.intInfo` supports vectors, returning int info for the element. * `Value.ctz` initial implementation. Needs work. * `Value.eql` is implemented for arrays and vectors. LLVM backend: * Implement vector support when lowering `array_elem_val`. * Implement vector support when lowering `ctz` and `clz`. * Implement `splat` and `vector_init`.
2022-01-12 23:53:26 -07:00
}
fn expectVectorsEqual(a: anytype, b: anytype) !void {
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
const len_a = @typeInfo(@TypeOf(a)).vector.len;
const len_b = @typeInfo(@TypeOf(b)).vector.len;
stage2: implement `@ctz` and `@clz` including SIMD AIR: * `array_elem_val` is now allowed to be used with a vector as the array type. * New instructions: splat, vector_init AstGen: * The splat ZIR instruction uses coerced_ty for the ResultLoc, avoiding an unnecessary `as` instruction, since the coercion will be performed in Sema. * Builtins that accept vectors now ignore the type parameter. Comment from this commit reproduced here: The accepted proposal #6835 tells us to remove the type parameter from these builtins. To stay source-compatible with stage1, we still observe the parameter here, but we do not encode it into the ZIR. To implement this proposal in stage2, only AstGen code will need to be changed. Sema: * `clz` and `ctz` ZIR instructions are now handled by the same function which accept AIR tag and comptime eval function pointer to differentiate. * `@typeInfo` for vectors is implemented. * `@splat` is implemented. It takes advantage of `Value.Tag.repeated` 😎 * `elemValue` is implemented for vectors, when the index is a scalar. Handling a vector index is still TODO. * Element-wise coercion is implemented for vectors. It could probably be optimized a bit, but it is at least complete & correct. * `Type.intInfo` supports vectors, returning int info for the element. * `Value.ctz` initial implementation. Needs work. * `Value.eql` is implemented for arrays and vectors. LLVM backend: * Implement vector support when lowering `array_elem_val`. * Implement vector support when lowering `ctz` and `clz`. * Implement `splat` and `vector_init`.
2022-01-12 23:53:26 -07:00
try expect(len_a == len_b);
var i: usize = 0;
while (i < len_a) : (i += 1) {
try expect(a[i] == b[i]);
}
}
test "@ctz" {
behavior tests cleanup: promote math.zig
2022-03-03 01:23:50 -07:00
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
behavior tests cleanup: promote math.zig
2022-03-03 01:23:50 -07:00
stage2: implement `@ctz` and `@clz` including SIMD AIR: * `array_elem_val` is now allowed to be used with a vector as the array type. * New instructions: splat, vector_init AstGen: * The splat ZIR instruction uses coerced_ty for the ResultLoc, avoiding an unnecessary `as` instruction, since the coercion will be performed in Sema. * Builtins that accept vectors now ignore the type parameter. Comment from this commit reproduced here: The accepted proposal #6835 tells us to remove the type parameter from these builtins. To stay source-compatible with stage1, we still observe the parameter here, but we do not encode it into the ZIR. To implement this proposal in stage2, only AstGen code will need to be changed. Sema: * `clz` and `ctz` ZIR instructions are now handled by the same function which accept AIR tag and comptime eval function pointer to differentiate. * `@typeInfo` for vectors is implemented. * `@splat` is implemented. It takes advantage of `Value.Tag.repeated` 😎 * `elemValue` is implemented for vectors, when the index is a scalar. Handling a vector index is still TODO. * Element-wise coercion is implemented for vectors. It could probably be optimized a bit, but it is at least complete & correct. * `Type.intInfo` supports vectors, returning int info for the element. * `Value.ctz` initial implementation. Needs work. * `Value.eql` is implemented for arrays and vectors. LLVM backend: * Implement vector support when lowering `array_elem_val`. * Implement vector support when lowering `ctz` and `clz`. * Implement `splat` and `vector_init`.
2022-01-12 23:53:26 -07:00
try testCtz();
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime testCtz();
stage2: implement `@ctz` and `@clz` including SIMD AIR: * `array_elem_val` is now allowed to be used with a vector as the array type. * New instructions: splat, vector_init AstGen: * The splat ZIR instruction uses coerced_ty for the ResultLoc, avoiding an unnecessary `as` instruction, since the coercion will be performed in Sema. * Builtins that accept vectors now ignore the type parameter. Comment from this commit reproduced here: The accepted proposal #6835 tells us to remove the type parameter from these builtins. To stay source-compatible with stage1, we still observe the parameter here, but we do not encode it into the ZIR. To implement this proposal in stage2, only AstGen code will need to be changed. Sema: * `clz` and `ctz` ZIR instructions are now handled by the same function which accept AIR tag and comptime eval function pointer to differentiate. * `@typeInfo` for vectors is implemented. * `@splat` is implemented. It takes advantage of `Value.Tag.repeated` 😎 * `elemValue` is implemented for vectors, when the index is a scalar. Handling a vector index is still TODO. * Element-wise coercion is implemented for vectors. It could probably be optimized a bit, but it is at least complete & correct. * `Type.intInfo` supports vectors, returning int info for the element. * `Value.ctz` initial implementation. Needs work. * `Value.eql` is implemented for arrays and vectors. LLVM backend: * Implement vector support when lowering `array_elem_val`. * Implement vector support when lowering `ctz` and `clz`. * Implement `splat` and `vector_init`.
2022-01-12 23:53:26 -07:00
}
fn testCtz() !void {
try expect(testOneCtz(u8, 0b10100000) == 5);
try expect(testOneCtz(u8, 0b10001010) == 1);
try expect(testOneCtz(u8, 0b00000000) == 8);
try expect(testOneCtz(u16, 0b00000000) == 16);
}
fn testOneCtz(comptime T: type, x: T) u32 {
stage2+stage1: remove type parameter from bit builtins Closes #12529 Closes #12511 Closes #6835
2022-08-21 17:24:04 +03:00
return @ctz(x);
stage2: implement `@ctz` and `@clz` including SIMD AIR: * `array_elem_val` is now allowed to be used with a vector as the array type. * New instructions: splat, vector_init AstGen: * The splat ZIR instruction uses coerced_ty for the ResultLoc, avoiding an unnecessary `as` instruction, since the coercion will be performed in Sema. * Builtins that accept vectors now ignore the type parameter. Comment from this commit reproduced here: The accepted proposal #6835 tells us to remove the type parameter from these builtins. To stay source-compatible with stage1, we still observe the parameter here, but we do not encode it into the ZIR. To implement this proposal in stage2, only AstGen code will need to be changed. Sema: * `clz` and `ctz` ZIR instructions are now handled by the same function which accept AIR tag and comptime eval function pointer to differentiate. * `@typeInfo` for vectors is implemented. * `@splat` is implemented. It takes advantage of `Value.Tag.repeated` 😎 * `elemValue` is implemented for vectors, when the index is a scalar. Handling a vector index is still TODO. * Element-wise coercion is implemented for vectors. It could probably be optimized a bit, but it is at least complete & correct. * `Type.intInfo` supports vectors, returning int info for the element. * `Value.ctz` initial implementation. Needs work. * `Value.eql` is implemented for arrays and vectors. LLVM backend: * Implement vector support when lowering `array_elem_val`. * Implement vector support when lowering `ctz` and `clz`. * Implement `splat` and `vector_init`.
2022-01-12 23:53:26 -07:00
}
categorize `behavior/bugs/<issueno>.zig` tests
2024-01-02 17:33:41 +02:00
test "@ctz 128-bit integers" {
x86_64+macho: pass more behavior tests
2024-01-29 15:33:45 +01:00
if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
categorize `behavior/bugs/<issueno>.zig` tests
2024-01-02 17:33:41 +02:00
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
categorize `behavior/bugs/<issueno>.zig` tests
2024-01-02 17:33:41 +02:00
try testCtz128();
try comptime testCtz128();
}
fn testCtz128() !void {
try expect(testOneCtz(u128, @as(u128, 0x40000000000000000000000000000000)) == 126);
try expect(math.rotl(u128, @as(u128, 0x40000000000000000000000000000000), @as(u8, 1)) == @as(u128, 0x80000000000000000000000000000000));
try expect(testOneCtz(u128, @as(u128, 0x80000000000000000000000000000000)) == 127);
try expect(testOneCtz(u128, math.rotl(u128, @as(u128, 0x40000000000000000000000000000000), @as(u8, 1))) == 127);
}
stage2: implement `@ctz` and `@clz` including SIMD AIR: * `array_elem_val` is now allowed to be used with a vector as the array type. * New instructions: splat, vector_init AstGen: * The splat ZIR instruction uses coerced_ty for the ResultLoc, avoiding an unnecessary `as` instruction, since the coercion will be performed in Sema. * Builtins that accept vectors now ignore the type parameter. Comment from this commit reproduced here: The accepted proposal #6835 tells us to remove the type parameter from these builtins. To stay source-compatible with stage1, we still observe the parameter here, but we do not encode it into the ZIR. To implement this proposal in stage2, only AstGen code will need to be changed. Sema: * `clz` and `ctz` ZIR instructions are now handled by the same function which accept AIR tag and comptime eval function pointer to differentiate. * `@typeInfo` for vectors is implemented. * `@splat` is implemented. It takes advantage of `Value.Tag.repeated` 😎 * `elemValue` is implemented for vectors, when the index is a scalar. Handling a vector index is still TODO. * Element-wise coercion is implemented for vectors. It could probably be optimized a bit, but it is at least complete & correct. * `Type.intInfo` supports vectors, returning int info for the element. * `Value.ctz` initial implementation. Needs work. * `Value.eql` is implemented for arrays and vectors. LLVM backend: * Implement vector support when lowering `array_elem_val`. * Implement vector support when lowering `ctz` and `clz`. * Implement `splat` and `vector_init`.
2022-01-12 23:53:26 -07:00
test "@ctz vectors" {
behavior tests cleanup: promote math.zig
2022-03-03 01:23:50 -07:00
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
behavior tests cleanup: promote math.zig
2022-03-03 01:23:50 -07:00
stage2: implement `@ctz` and `@clz` including SIMD AIR: * `array_elem_val` is now allowed to be used with a vector as the array type. * New instructions: splat, vector_init AstGen: * The splat ZIR instruction uses coerced_ty for the ResultLoc, avoiding an unnecessary `as` instruction, since the coercion will be performed in Sema. * Builtins that accept vectors now ignore the type parameter. Comment from this commit reproduced here: The accepted proposal #6835 tells us to remove the type parameter from these builtins. To stay source-compatible with stage1, we still observe the parameter here, but we do not encode it into the ZIR. To implement this proposal in stage2, only AstGen code will need to be changed. Sema: * `clz` and `ctz` ZIR instructions are now handled by the same function which accept AIR tag and comptime eval function pointer to differentiate. * `@typeInfo` for vectors is implemented. * `@splat` is implemented. It takes advantage of `Value.Tag.repeated` 😎 * `elemValue` is implemented for vectors, when the index is a scalar. Handling a vector index is still TODO. * Element-wise coercion is implemented for vectors. It could probably be optimized a bit, but it is at least complete & correct. * `Type.intInfo` supports vectors, returning int info for the element. * `Value.ctz` initial implementation. Needs work. * `Value.eql` is implemented for arrays and vectors. LLVM backend: * Implement vector support when lowering `array_elem_val`. * Implement vector support when lowering `ctz` and `clz`. * Implement `splat` and `vector_init`.
2022-01-12 23:53:26 -07:00
try testCtzVectors();
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime testCtzVectors();
stage2: implement `@ctz` and `@clz` including SIMD AIR: * `array_elem_val` is now allowed to be used with a vector as the array type. * New instructions: splat, vector_init AstGen: * The splat ZIR instruction uses coerced_ty for the ResultLoc, avoiding an unnecessary `as` instruction, since the coercion will be performed in Sema. * Builtins that accept vectors now ignore the type parameter. Comment from this commit reproduced here: The accepted proposal #6835 tells us to remove the type parameter from these builtins. To stay source-compatible with stage1, we still observe the parameter here, but we do not encode it into the ZIR. To implement this proposal in stage2, only AstGen code will need to be changed. Sema: * `clz` and `ctz` ZIR instructions are now handled by the same function which accept AIR tag and comptime eval function pointer to differentiate. * `@typeInfo` for vectors is implemented. * `@splat` is implemented. It takes advantage of `Value.Tag.repeated` 😎 * `elemValue` is implemented for vectors, when the index is a scalar. Handling a vector index is still TODO. * Element-wise coercion is implemented for vectors. It could probably be optimized a bit, but it is at least complete & correct. * `Type.intInfo` supports vectors, returning int info for the element. * `Value.ctz` initial implementation. Needs work. * `Value.eql` is implemented for arrays and vectors. LLVM backend: * Implement vector support when lowering `array_elem_val`. * Implement vector support when lowering `ctz` and `clz`. * Implement `splat` and `vector_init`.
2022-01-12 23:53:26 -07:00
}
fn testCtzVectors() !void {
Update tests to new splat syntax
2023-07-07 20:41:33 +02:00
const Vu4 = @Vector(64, u4);
const Vu8 = @Vector(64, u8);
stage2: implement `@ctz` and `@clz` including SIMD AIR: * `array_elem_val` is now allowed to be used with a vector as the array type. * New instructions: splat, vector_init AstGen: * The splat ZIR instruction uses coerced_ty for the ResultLoc, avoiding an unnecessary `as` instruction, since the coercion will be performed in Sema. * Builtins that accept vectors now ignore the type parameter. Comment from this commit reproduced here: The accepted proposal #6835 tells us to remove the type parameter from these builtins. To stay source-compatible with stage1, we still observe the parameter here, but we do not encode it into the ZIR. To implement this proposal in stage2, only AstGen code will need to be changed. Sema: * `clz` and `ctz` ZIR instructions are now handled by the same function which accept AIR tag and comptime eval function pointer to differentiate. * `@typeInfo` for vectors is implemented. * `@splat` is implemented. It takes advantage of `Value.Tag.repeated` 😎 * `elemValue` is implemented for vectors, when the index is a scalar. Handling a vector index is still TODO. * Element-wise coercion is implemented for vectors. It could probably be optimized a bit, but it is at least complete & correct. * `Type.intInfo` supports vectors, returning int info for the element. * `Value.ctz` initial implementation. Needs work. * `Value.eql` is implemented for arrays and vectors. LLVM backend: * Implement vector support when lowering `array_elem_val`. * Implement vector support when lowering `ctz` and `clz`. * Implement `splat` and `vector_init`.
2022-01-12 23:53:26 -07:00
@setEvalBranchQuota(10_000);
Update tests to new splat syntax
2023-07-07 20:41:33 +02:00
try testOneCtzVector(u8, 64, @as(Vu8, @splat(0b10100000)), @as(Vu4, @splat(5)));
try testOneCtzVector(u8, 64, @as(Vu8, @splat(0b10001010)), @as(Vu4, @splat(1)));
try testOneCtzVector(u8, 64, @as(Vu8, @splat(0b00000000)), @as(Vu4, @splat(8)));
try testOneCtzVector(u16, 64, @as(@Vector(64, u16), @splat(0b00000000)), @as(@Vector(64, u5), @splat(16)));
stage2: implement `@ctz` and `@clz` including SIMD AIR: * `array_elem_val` is now allowed to be used with a vector as the array type. * New instructions: splat, vector_init AstGen: * The splat ZIR instruction uses coerced_ty for the ResultLoc, avoiding an unnecessary `as` instruction, since the coercion will be performed in Sema. * Builtins that accept vectors now ignore the type parameter. Comment from this commit reproduced here: The accepted proposal #6835 tells us to remove the type parameter from these builtins. To stay source-compatible with stage1, we still observe the parameter here, but we do not encode it into the ZIR. To implement this proposal in stage2, only AstGen code will need to be changed. Sema: * `clz` and `ctz` ZIR instructions are now handled by the same function which accept AIR tag and comptime eval function pointer to differentiate. * `@typeInfo` for vectors is implemented. * `@splat` is implemented. It takes advantage of `Value.Tag.repeated` 😎 * `elemValue` is implemented for vectors, when the index is a scalar. Handling a vector index is still TODO. * Element-wise coercion is implemented for vectors. It could probably be optimized a bit, but it is at least complete & correct. * `Type.intInfo` supports vectors, returning int info for the element. * `Value.ctz` initial implementation. Needs work. * `Value.eql` is implemented for arrays and vectors. LLVM backend: * Implement vector support when lowering `array_elem_val`. * Implement vector support when lowering `ctz` and `clz`. * Implement `splat` and `vector_init`.
2022-01-12 23:53:26 -07:00
}
fn testOneCtzVector(
comptime T: type,
comptime len: u32,
x: @Vector(len, T),
expected: @Vector(len, u32),
) !void {
stage2+stage1: remove type parameter from bit builtins Closes #12529 Closes #12511 Closes #6835
2022-08-21 17:24:04 +03:00
try expectVectorsEqual(@ctz(x), expected);
stage2: implement `@ctz` and `@clz` including SIMD AIR: * `array_elem_val` is now allowed to be used with a vector as the array type. * New instructions: splat, vector_init AstGen: * The splat ZIR instruction uses coerced_ty for the ResultLoc, avoiding an unnecessary `as` instruction, since the coercion will be performed in Sema. * Builtins that accept vectors now ignore the type parameter. Comment from this commit reproduced here: The accepted proposal #6835 tells us to remove the type parameter from these builtins. To stay source-compatible with stage1, we still observe the parameter here, but we do not encode it into the ZIR. To implement this proposal in stage2, only AstGen code will need to be changed. Sema: * `clz` and `ctz` ZIR instructions are now handled by the same function which accept AIR tag and comptime eval function pointer to differentiate. * `@typeInfo` for vectors is implemented. * `@splat` is implemented. It takes advantage of `Value.Tag.repeated` 😎 * `elemValue` is implemented for vectors, when the index is a scalar. Handling a vector index is still TODO. * Element-wise coercion is implemented for vectors. It could probably be optimized a bit, but it is at least complete & correct. * `Type.intInfo` supports vectors, returning int info for the element. * `Value.ctz` initial implementation. Needs work. * `Value.eql` is implemented for arrays and vectors. LLVM backend: * Implement vector support when lowering `array_elem_val`. * Implement vector support when lowering `ctz` and `clz`. * Implement `splat` and `vector_init`.
2022-01-12 23:53:26 -07:00
}
stage2: implement `@clz` and `@ctz` Also improve the LLVM backend to support lowering bigints to LLVM values. Moves over a bunch of math.zig test cases to the "passing for stage2" section.
2021-09-28 22:38:51 -07:00
test "const number literal" {
const one = 1;
const eleven = ten + one;
try expect(eleven == 11);
}
const ten = 10;
test "float equality" {
behavior tests cleanup: promote math.zig
2022-03-03 01:23:50 -07:00
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
behavior tests cleanup: promote math.zig
2022-03-03 01:23:50 -07:00
stage2: implement `@clz` and `@ctz` Also improve the LLVM backend to support lowering bigints to LLVM values. Moves over a bunch of math.zig test cases to the "passing for stage2" section.
2021-09-28 22:38:51 -07:00
const x: f64 = 0.012;
const y: f64 = x + 1.0;
try testFloatEqualityImpl(x, y);
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime testFloatEqualityImpl(x, y);
stage2: implement `@clz` and `@ctz` Also improve the LLVM backend to support lowering bigints to LLVM values. Moves over a bunch of math.zig test cases to the "passing for stage2" section.
2021-09-28 22:38:51 -07:00
}
fn testFloatEqualityImpl(x: f64, y: f64) !void {
const y2 = x + 1.0;
try expect(y == y2);
}
test "hex float literal parsing" {
test/behavior: replace all 'comptime expect' with 'comptime assert'
2024-01-15 16:01:13 +11:00
comptime assert(0x1.0 == 1.0);
stage2: implement `@clz` and `@ctz` Also improve the LLVM backend to support lowering bigints to LLVM values. Moves over a bunch of math.zig test cases to the "passing for stage2" section.
2021-09-28 22:38:51 -07:00
}
behavior tests cleanup: promote math.zig
2022-03-03 01:23:50 -07:00
test "hex float literal within range" {
const a = 0x1.0p16383;
const b = 0x0.1p16387;
const c = 0x1.0p-16382;
_ = a;
_ = b;
_ = c;
}
stage2: implement `@clz` and `@ctz` Also improve the LLVM backend to support lowering bigints to LLVM values. Moves over a bunch of math.zig test cases to the "passing for stage2" section.
2021-09-28 22:38:51 -07:00
test "quad hex float literal parsing in range" {
const a = 0x1.af23456789bbaaab347645365cdep+5;
const b = 0x1.dedafcff354b6ae9758763545432p-9;
const c = 0x1.2f34dd5f437e849b4baab754cdefp+4534;
const d = 0x1.edcbff8ad76ab5bf46463233214fp-435;
_ = a;
_ = b;
_ = c;
_ = d;
}
test "underscore separator parsing" {
try expect(1_234_567 == 1234567);
AstGen: disallow leading zeroes in int literals and int types This makes `0123` and `u0123` etc. illegal. I'm now confident that this is a good change because I actually caught two C header translation mistakes in `haiku.zig` with this. Clearly, `0123` being octal in C (TIL) can cause confusion, and we make this easier to read by requiring `0o` as the prefix and now also disallowing leading zeroes in integers. For consistency and because it looks weird, we disallow it for integer types too (e.g. `u0123`). Fixes #11963 Fixes #12417
2022-08-18 18:54:51 +02:00
try expect(1_234_567 == 1234567);
try expect(1_2_3_4_5_6_7 == 1234567);
stage2: implement `@clz` and `@ctz` Also improve the LLVM backend to support lowering bigints to LLVM values. Moves over a bunch of math.zig test cases to the "passing for stage2" section.
2021-09-28 22:38:51 -07:00
try expect(0b0_0_0_0 == 0);
try expect(0b1010_1010 == 0b10101010);
try expect(0b0000_1010_1010 == 0b10101010);
try expect(0b1_0_1_0_1_0_1_0 == 0b10101010);
try expect(0o0_0_0_0 == 0);
try expect(0o1010_1010 == 0o10101010);
try expect(0o0000_1010_1010 == 0o10101010);
try expect(0o1_0_1_0_1_0_1_0 == 0o10101010);
try expect(0x0_0_0_0 == 0);
try expect(0x1010_1010 == 0x10101010);
try expect(0x0000_1010_1010 == 0x10101010);
try expect(0x1_0_1_0_1_0_1_0 == 0x10101010);
try expect(123_456.789_000e1_0 == 123456.789000e10);
AstGen: disallow leading zeroes in int literals and int types This makes `0123` and `u0123` etc. illegal. I'm now confident that this is a good change because I actually caught two C header translation mistakes in `haiku.zig` with this. Clearly, `0123` being octal in C (TIL) can cause confusion, and we make this easier to read by requiring `0o` as the prefix and now also disallowing leading zeroes in integers. For consistency and because it looks weird, we disallow it for integer types too (e.g. `u0123`). Fixes #11963 Fixes #12417
2022-08-18 18:54:51 +02:00
try expect(1_2_3_4_5_6.7_8_9_0_0_0e0_0_1_0 == 123456.789000e10);
stage2: implement `@clz` and `@ctz` Also improve the LLVM backend to support lowering bigints to LLVM values. Moves over a bunch of math.zig test cases to the "passing for stage2" section.
2021-09-28 22:38:51 -07:00
try expect(0x1234_5678.9ABC_DEF0p-1_0 == 0x12345678.9ABCDEF0p-10);
try expect(0x1_2_3_4_5_6_7_8.9_A_B_C_D_E_F_0p-0_0_0_1_0 == 0x12345678.9ABCDEF0p-10);
}
test "comptime_int addition" {
comptime {
try expect(35361831660712422535336160538497375248 + 101752735581729509668353361206450473702 == 137114567242441932203689521744947848950);
try expect(594491908217841670578297176641415611445982232488944558774612 + 390603545391089362063884922208143568023166603618446395589768 == 985095453608931032642182098849559179469148836107390954364380);
}
}
test "comptime_int multiplication" {
comptime {
try expect(
45960427431263824329884196484953148229 * 128339149605334697009938835852565949723 == 5898522172026096622534201617172456926982464453350084962781392314016180490567,
);
try expect(
594491908217841670578297176641415611445982232488944558774612 * 390603545391089362063884922208143568023166603618446395589768 == 232210647056203049913662402532976186578842425262306016094292237500303028346593132411865381225871291702600263463125370016,
);
}
}
test "comptime_int shifting" {
comptime {
try expect((@as(u128, 1) << 127) == 0x80000000000000000000000000000000);
}
}
test "comptime_int multi-limb shift and mask" {
comptime {
var a = 0xefffffffa0000001eeeeeeefaaaaaaab;
try expect(@as(u32, a & 0xffffffff) == 0xaaaaaaab);
a >>= 32;
try expect(@as(u32, a & 0xffffffff) == 0xeeeeeeef);
a >>= 32;
try expect(@as(u32, a & 0xffffffff) == 0xa0000001);
a >>= 32;
try expect(@as(u32, a & 0xffffffff) == 0xefffffff);
a >>= 32;
try expect(a == 0);
}
}
test "comptime_int multi-limb partial shift right" {
comptime {
var a = 0x1ffffffffeeeeeeee;
a >>= 16;
try expect(a == 0x1ffffffffeeee);
}
}
test "xor" {
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
stage2: implement `@clz` and `@ctz` Also improve the LLVM backend to support lowering bigints to LLVM values. Moves over a bunch of math.zig test cases to the "passing for stage2" section.
2021-09-28 22:38:51 -07:00
try test_xor();
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime test_xor();
stage2: implement `@clz` and `@ctz` Also improve the LLVM backend to support lowering bigints to LLVM values. Moves over a bunch of math.zig test cases to the "passing for stage2" section.
2021-09-28 22:38:51 -07:00
}
fn test_xor() !void {
try testOneXor(0xFF, 0x00, 0xFF);
try testOneXor(0xF0, 0x0F, 0xFF);
try testOneXor(0xFF, 0xF0, 0x0F);
try testOneXor(0xFF, 0x0F, 0xF0);
try testOneXor(0xFF, 0xFF, 0x00);
}
fn testOneXor(a: u8, b: u8, c: u8) !void {
try expect(a ^ b == c);
}
test "comptime_int xor" {
comptime {
try expect(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF ^ 0x00000000000000000000000000000000 == 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
try expect(0xFFFFFFFFFFFFFFFF0000000000000000 ^ 0x0000000000000000FFFFFFFFFFFFFFFF == 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
try expect(0xFFFFFFFFFFFFFFFF0000000000000000 ^ 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF == 0x0000000000000000FFFFFFFFFFFFFFFF);
try expect(0x0000000000000000FFFFFFFFFFFFFFFF ^ 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF == 0xFFFFFFFFFFFFFFFF0000000000000000);
try expect(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF ^ 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF == 0x00000000000000000000000000000000);
try expect(0xFFFFFFFF00000000FFFFFFFF00000000 ^ 0x00000000FFFFFFFF00000000FFFFFFFF == 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
try expect(0xFFFFFFFF00000000FFFFFFFF00000000 ^ 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF == 0x00000000FFFFFFFF00000000FFFFFFFF);
try expect(0x00000000FFFFFFFF00000000FFFFFFFF ^ 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF == 0xFFFFFFFF00000000FFFFFFFF00000000);
}
}
test "comptime_int param and return" {
const a = comptimeAdd(35361831660712422535336160538497375248, 101752735581729509668353361206450473702);
try expect(a == 137114567242441932203689521744947848950);
const b = comptimeAdd(594491908217841670578297176641415611445982232488944558774612, 390603545391089362063884922208143568023166603618446395589768);
try expect(b == 985095453608931032642182098849559179469148836107390954364380);
}
fn comptimeAdd(comptime a: comptime_int, comptime b: comptime_int) comptime_int {
return a + b;
}
stage2: bitNot
2021-10-16 14:47:55 +02:00
stage2-wasm: not op for <= 128 bits ints
2024-06-28 00:39:49 +02:00
fn not(comptime T: type, a: T) T {
return ~a;
}
stage2: bitNot
2021-10-16 14:47:55 +02:00
test "binary not" {
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
stage2-wasm: not op for <= 128 bits ints
2024-06-28 00:39:49 +02:00
try expect(not(u0, 0) == 0);
try expect(not(u1, 0) == 1);
try expect(not(u1, 1) == 0);
try expect(not(u5, 0b01001) == 0b10110);
try expect(not(u5, 0b10110) == 0b01001);
try expect(not(u16, 0b10101010_10101010) == 0b01010101_01010101);
try expect(not(u16, 0b01010101_01010101) == 0b10101010_10101010);
try expect(not(u32, 0xAAAA_3333) == 0x5555_CCCC);
try expect(not(u32, 0x5555_CCCC) == 0xAAAA_3333);
try expect(not(u35, 0x4_1111_FFFF) == 0x3_EEEE_0000);
try expect(not(u35, 0x3_EEEE_0000) == 0x4_1111_FFFF);
try expect(not(u48, 0x4567_89AB_CDEF) == 0xBA98_7654_3210);
try expect(not(u48, 0xBA98_7654_3210) == 0x4567_89AB_CDEF);
try expect(not(u64, 0x0123_4567_89AB_CDEF) == 0xFEDC_BA98_7654_3210);
try expect(not(u64, 0xFEDC_BA98_7654_3210) == 0x0123_4567_89AB_CDEF);
try expect(not(i0, 0) == 0);
try expect(not(i1, 0) == -1);
try expect(not(i1, -1) == 0);
try expect(not(i5, -2) == 1);
try expect(not(i5, 3) == -4);
try expect(not(i32, 0) == -1);
try expect(not(i32, -2147483648) == 2147483647);
try expect(not(i64, -1) == 0);
try expect(not(i64, 0) == -1);
stage2: bitNot
2021-10-16 14:47:55 +02:00
try expect(comptime x: {
break :x ~@as(u16, 0b1010101010101010) == 0b0101010101010101;
});
try expect(comptime x: {
break :x ~@as(u64, 2147483647) == 18446744071562067968;
});
stage2: bit_not on u0 is always 0
2022-03-16 21:22:02 -07:00
try expect(comptime x: {
break :x ~@as(u0, 0) == 0;
});
stage2: bitNot
2021-10-16 14:47:55 +02:00
}
stage2-wasm: not op for <= 128 bits ints
2024-06-28 00:39:49 +02:00
test "binary not big int <= 128 bits" {
skip "binary not 128-bit" on non-llvm
2022-12-30 19:15:17 -05:00
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
setup spirv backend in behavior tests
2023-05-11 09:23:34 +03:30
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
skip "binary not 128-bit" on non-llvm
2022-12-30 19:15:17 -05:00
stage2-wasm: not op for <= 128 bits ints
2024-06-28 00:39:49 +02:00
try expect(not(u65, 1) == 0x1_FFFFFFFF_FFFFFFFE);
try expect(not(u65, 0x1_FFFFFFFF_FFFFFFFE) == 1);
try expect(not(u96, 0x01234567_89ABCDEF_00000001) == 0xFEDCBA98_76543210_FFFFFFFE);
try expect(not(u96, 0xFEDCBA98_76543210_FFFFFFFE) == 0x01234567_89ABCDEF_00000001);
try expect(not(u128, 0xAAAAAAAA_AAAAAAAA_AAAAAAAA_AAAAAAAA) == 0x55555555_55555555_55555555_55555555);
try expect(not(u128, 0x55555555_55555555_55555555_55555555) == 0xAAAAAAAA_AAAAAAAA_AAAAAAAA_AAAAAAAA);
try expect(not(i65, -1) == 0);
try expect(not(i65, 0) == -1);
try expect(not(i65, -18446744073709551616) == 18446744073709551615);
try expect(not(i65, 18446744073709551615) == -18446744073709551616);
try expect(not(i128, -1) == 0);
try expect(not(i128, 0) == -1);
try expect(not(i128, -200) == 199);
try expect(not(i128, 199) == -200);
tests: add more coverage for 128 bit operations - fixup 128-bit atomics test to only run on x86_64 - add truncation test for 128-bit types, including non power of two targets (there was a bug with broken non-power-of-two truncation in the cbe) - add 128-bit binary not test (covers another bug fixed in the cbe)
2022-12-29 13:44:40 -05:00
try expect(comptime x: {
break :x ~@as(u128, 0x55555555_55555555_55555555_55555555) == 0xaaaaaaaa_aaaaaaaa_aaaaaaaa_aaaaaaaa;
});
try expect(comptime x: {
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
break :x ~@as(i128, 0x55555555_55555555_55555555_55555555) == @as(i128, @bitCast(@as(u128, 0xaaaaaaaa_aaaaaaaa_aaaaaaaa_aaaaaaaa)));
tests: add more coverage for 128 bit operations - fixup 128-bit atomics test to only run on x86_64 - add truncation test for 128-bit types, including non power of two targets (there was a bug with broken non-power-of-two truncation in the cbe) - add 128-bit binary not test (covers another bug fixed in the cbe)
2022-12-29 13:44:40 -05:00
});
}
stage2: more division support AIR: * div is renamed to div_trunc. * Add div_float, div_floor, div_exact. - Implemented in Sema and LLVM codegen. C backend has a stub. Improvements to std.math.big.Int: * Add `eqZero` function to `Mutable`. * Fix incorrect results for `divFloor`. Compiler-rt: * Add muloti4 to the stage2 section.
2021-10-21 19:05:26 -07:00
test "division" {
behavior tests cleanup: promote math.zig
2022-03-03 01:23:50 -07:00
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
stage2-wasm: fix div and rem
2024-06-21 22:26:21 +02:00
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
x86_64+macho: pass more behavior tests
2024-01-29 15:33:45 +01:00
if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
behavior tests cleanup: promote math.zig
2022-03-03 01:23:50 -07:00
stage2-wasm: fix div and rem
2024-06-21 22:26:21 +02:00
try testIntDivision();
try comptime testIntDivision();
try testFloatDivision();
try comptime testFloatDivision();
stage2: more division support AIR: * div is renamed to div_trunc. * Add div_float, div_floor, div_exact. - Implemented in Sema and LLVM codegen. C backend has a stub. Improvements to std.math.big.Int: * Add `eqZero` function to `Mutable`. * Fix incorrect results for `divFloor`. Compiler-rt: * Add muloti4 to the stage2 section.
2021-10-21 19:05:26 -07:00
}
CBE: implement mod, divFloor, divTrunc
2022-03-13 21:37:36 +00:00
stage2-wasm: fix div and rem
2024-06-21 22:26:21 +02:00
fn testIntDivision() !void {
stage2: more division support AIR: * div is renamed to div_trunc. * Add div_float, div_floor, div_exact. - Implemented in Sema and LLVM codegen. C backend has a stub. Improvements to std.math.big.Int: * Add `eqZero` function to `Mutable`. * Fix incorrect results for `divFloor`. Compiler-rt: * Add muloti4 to the stage2 section.
2021-10-21 19:05:26 -07:00
try expect(div(u32, 13, 3) == 4);
stage2-wasm: fix div and rem
2024-06-21 22:26:21 +02:00
try expect(div(u64, 13, 3) == 4);
try expect(div(u8, 13, 3) == 4);
stage2: more division support AIR: * div is renamed to div_trunc. * Add div_float, div_floor, div_exact. - Implemented in Sema and LLVM codegen. C backend has a stub. Improvements to std.math.big.Int: * Add `eqZero` function to `Mutable`. * Fix incorrect results for `divFloor`. Compiler-rt: * Add muloti4 to the stage2 section.
2021-10-21 19:05:26 -07:00
try expect(divExact(u32, 55, 11) == 5);
try expect(divExact(i32, -55, 11) == -5);
stage2-wasm: fix div and rem
2024-06-21 22:26:21 +02:00
try expect(divExact(i64, -55, 11) == -5);
try expect(divExact(i16, -55, 11) == -5);
stage2: more division support AIR: * div is renamed to div_trunc. * Add div_float, div_floor, div_exact. - Implemented in Sema and LLVM codegen. C backend has a stub. Improvements to std.math.big.Int: * Add `eqZero` function to `Mutable`. * Fix incorrect results for `divFloor`. Compiler-rt: * Add muloti4 to the stage2 section.
2021-10-21 19:05:26 -07:00
try expect(divFloor(i32, 5, 3) == 1);
try expect(divFloor(i32, -5, 3) == -2);
try expect(divFloor(i32, -0x80000000, -2) == 0x40000000);
try expect(divFloor(i32, 0, -0x80000000) == 0);
try expect(divFloor(i32, -0x40000001, 0x40000000) == -2);
try expect(divFloor(i32, -0x80000000, 1) == -0x80000000);
try expect(divFloor(i32, 10, 12) == 0);
try expect(divFloor(i32, -14, 12) == -2);
try expect(divFloor(i32, -2, 12) == -1);
stage2-wasm: fix div and rem
2024-06-21 22:26:21 +02:00
try expect(divFloor(i8, 5, 3) == 1);
try expect(divFloor(i16, -5, 3) == -2);
try expect(divFloor(i64, -0x80000000, -2) == 0x40000000);
try expect(divFloor(i64, -0x40000001, 0x40000000) == -2);
stage2: more division support AIR: * div is renamed to div_trunc. * Add div_float, div_floor, div_exact. - Implemented in Sema and LLVM codegen. C backend has a stub. Improvements to std.math.big.Int: * Add `eqZero` function to `Mutable`. * Fix incorrect results for `divFloor`. Compiler-rt: * Add muloti4 to the stage2 section.
2021-10-21 19:05:26 -07:00
try expect(divTrunc(i32, 5, 3) == 1);
try expect(divTrunc(i32, -5, 3) == -1);
stage1/stage2: Simplify divTrunc impl According to the documentation, `divTrunc` is "Truncated division. Rounds toward zero". Lower it as a straightforward fdiv + trunc sequence to make it behave as expected with mixed positive/negative operands. Closes #10001
2021-10-24 17:11:43 +02:00
try expect(divTrunc(i32, 9, -10) == 0);
try expect(divTrunc(i32, -9, 10) == 0);
stage2: more division support AIR: * div is renamed to div_trunc. * Add div_float, div_floor, div_exact. - Implemented in Sema and LLVM codegen. C backend has a stub. Improvements to std.math.big.Int: * Add `eqZero` function to `Mutable`. * Fix incorrect results for `divFloor`. Compiler-rt: * Add muloti4 to the stage2 section.
2021-10-21 19:05:26 -07:00
try expect(divTrunc(i32, 10, 12) == 0);
try expect(divTrunc(i32, -14, 12) == -1);
try expect(divTrunc(i32, -2, 12) == 0);
try expect(mod(i32, 10, 12) == 10);
try expect(mod(i32, -14, 12) == 10);
try expect(mod(i32, -2, 12) == 10);
llvm/cbe: fix signed `@mod`/`@divFloor` computations Closes #15636
2023-05-10 01:56:48 -04:00
try expect(mod(i32, 10, -12) == -2);
try expect(mod(i32, -14, -12) == -2);
try expect(mod(i32, -2, -12) == -2);
stage2: more division support AIR: * div is renamed to div_trunc. * Add div_float, div_floor, div_exact. - Implemented in Sema and LLVM codegen. C backend has a stub. Improvements to std.math.big.Int: * Add `eqZero` function to `Mutable`. * Fix incorrect results for `divFloor`. Compiler-rt: * Add muloti4 to the stage2 section.
2021-10-21 19:05:26 -07:00
stage2-wasm: fix div and rem
2024-06-21 22:26:21 +02:00
try expect(mod(i64, -118, 12) == 2);
try expect(mod(u32, 10, 12) == 10);
try expect(mod(i64, -14, 12) == 10);
try expect(mod(i16, -2, 12) == 10);
try expect(mod(i16, -118, 12) == 2);
try expect(mod(i8, -2, 12) == 10); // TODO: fails in x86_64
try expect(rem(i64, -118, 12) == -10);
try expect(rem(i32, 10, 12) == 10);
try expect(rem(i32, -14, 12) == -2);
try expect(rem(i32, -2, 12) == -2);
try expect(rem(i16, -118, 12) == -10);
spirv: sign-extension for strange integers
2023-10-08 18:52:58 +02:00
try expect(divTrunc(i20, 20, -5) == -4);
try expect(divTrunc(i20, -20, -4) == 5);
stage2: more division support AIR: * div is renamed to div_trunc. * Add div_float, div_floor, div_exact. - Implemented in Sema and LLVM codegen. C backend has a stub. Improvements to std.math.big.Int: * Add `eqZero` function to `Mutable`. * Fix incorrect results for `divFloor`. Compiler-rt: * Add muloti4 to the stage2 section.
2021-10-21 19:05:26 -07:00
comptime {
try expect(
1194735857077236777412821811143690633098347576 % 508740759824825164163191790951174292733114988 == 177254337427586449086438229241342047632117600,
);
try expect(
@rem(-1194735857077236777412821811143690633098347576, 508740759824825164163191790951174292733114988) == -177254337427586449086438229241342047632117600,
);
try expect(
1194735857077236777412821811143690633098347576 / 508740759824825164163191790951174292733114988 == 2,
);
try expect(
@divTrunc(-1194735857077236777412821811143690633098347576, 508740759824825164163191790951174292733114988) == -2,
);
try expect(
@divTrunc(1194735857077236777412821811143690633098347576, -508740759824825164163191790951174292733114988) == -2,
);
try expect(
@divTrunc(-1194735857077236777412821811143690633098347576, -508740759824825164163191790951174292733114988) == 2,
);
try expect(
4126227191251978491697987544882340798050766755606969681711 % 10 == 1,
);
}
}
CBE: implement mod, divFloor, divTrunc
2022-03-13 21:37:36 +00:00
stage2-wasm: fix div and rem
2024-06-21 22:26:21 +02:00
fn testFloatDivision() !void {
try expect(div(f32, 1.0, 2.0) == 0.5);
try expect(divExact(f32, 55.0, 11.0) == 5.0);
try expect(divExact(f32, -55.0, 11.0) == -5.0);
try expect(divFloor(f32, 5.0, 3.0) == 1.0);
try expect(divFloor(f32, -5.0, 3.0) == -2.0);
try expect(divFloor(f32, 56.0, 9.0) == 6.0);
try expect(divFloor(f32, 1053.0, -41.0) == -26.0);
try expect(divFloor(f16, -43.0, 12.0) == -4.0);
try expect(divFloor(f64, -90.0, -9.0) == 10.0);
try expect(divTrunc(f32, 5.0, 3.0) == 1.0);
try expect(divTrunc(f32, -5.0, 3.0) == -1.0);
try expect(divTrunc(f32, 9.0, -10.0) == 0.0);
try expect(divTrunc(f32, -9.0, 10.0) == 0.0);
try expect(divTrunc(f64, 5.0, 3.0) == 1.0);
try expect(divTrunc(f64, -5.0, 3.0) == -1.0);
try expect(divTrunc(f64, 9.0, -10.0) == 0.0);
try expect(divTrunc(f64, -9.0, 10.0) == 0.0);
}
test "large integer division" {
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
{
var numerator: u256 = 99999999999999999997315645440;
var divisor: u256 = 10000000000000000000000000000;
_ = .{ &numerator, &divisor };
try expect(numerator / divisor == 9);
}
{
var numerator: u256 = 99999999999999999999000000000000000000000;
var divisor: u256 = 10000000000000000000000000000000000000000;
_ = .{ &numerator, &divisor };
try expect(numerator / divisor == 9);
}
}
CBE: implement mod, divFloor, divTrunc
2022-03-13 21:37:36 +00:00
test "division half-precision floats" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
x86_64+macho: pass more behavior tests
2024-01-29 15:33:45 +01:00
if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
CBE: implement mod, divFloor, divTrunc
2022-03-13 21:37:36 +00:00
try testDivisionFP16();
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime testDivisionFP16();
CBE: implement mod, divFloor, divTrunc
2022-03-13 21:37:36 +00:00
}
fn testDivisionFP16() !void {
try expect(div(f16, 1.0, 2.0) == 0.5);
try expect(divExact(f16, 55.0, 11.0) == 5.0);
try expect(divExact(f16, -55.0, 11.0) == -5.0);
try expect(divFloor(f16, 5.0, 3.0) == 1.0);
try expect(divFloor(f16, -5.0, 3.0) == -2.0);
try expect(divTrunc(f16, 5.0, 3.0) == 1.0);
try expect(divTrunc(f16, -5.0, 3.0) == -1.0);
try expect(divTrunc(f16, 9.0, -10.0) == 0.0);
try expect(divTrunc(f16, -9.0, 10.0) == 0.0);
}
stage2: more division support AIR: * div is renamed to div_trunc. * Add div_float, div_floor, div_exact. - Implemented in Sema and LLVM codegen. C backend has a stub. Improvements to std.math.big.Int: * Add `eqZero` function to `Mutable`. * Fix incorrect results for `divFloor`. Compiler-rt: * Add muloti4 to the stage2 section.
2021-10-21 19:05:26 -07:00
fn div(comptime T: type, a: T, b: T) T {
return a / b;
}
fn divExact(comptime T: type, a: T, b: T) T {
return @divExact(a, b);
}
fn divFloor(comptime T: type, a: T, b: T) T {
return @divFloor(a, b);
}
fn divTrunc(comptime T: type, a: T, b: T) T {
return @divTrunc(a, b);
}
fn mod(comptime T: type, a: T, b: T) T {
return @mod(a, b);
}
stage2-wasm: fix div and rem
2024-06-21 22:26:21 +02:00
fn rem(comptime T: type, a: T, b: T) T {
return @rem(a, b);
}
stage2: more division support AIR: * div is renamed to div_trunc. * Add div_float, div_floor, div_exact. - Implemented in Sema and LLVM codegen. C backend has a stub. Improvements to std.math.big.Int: * Add `eqZero` function to `Mutable`. * Fix incorrect results for `divFloor`. Compiler-rt: * Add muloti4 to the stage2 section.
2021-10-21 19:05:26 -07:00
test "unsigned wrapping" {
try testUnsignedWrappingEval(maxInt(u32));
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime testUnsignedWrappingEval(maxInt(u32));
stage2: more division support AIR: * div is renamed to div_trunc. * Add div_float, div_floor, div_exact. - Implemented in Sema and LLVM codegen. C backend has a stub. Improvements to std.math.big.Int: * Add `eqZero` function to `Mutable`. * Fix incorrect results for `divFloor`. Compiler-rt: * Add muloti4 to the stage2 section.
2021-10-21 19:05:26 -07:00
}
fn testUnsignedWrappingEval(x: u32) !void {
const zero = x +% 1;
try expect(zero == 0);
const orig = zero -% 1;
try expect(orig == maxInt(u32));
}
test "signed wrapping" {
try testSignedWrappingEval(maxInt(i32));
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime testSignedWrappingEval(maxInt(i32));
stage2: more division support AIR: * div is renamed to div_trunc. * Add div_float, div_floor, div_exact. - Implemented in Sema and LLVM codegen. C backend has a stub. Improvements to std.math.big.Int: * Add `eqZero` function to `Mutable`. * Fix incorrect results for `divFloor`. Compiler-rt: * Add muloti4 to the stage2 section.
2021-10-21 19:05:26 -07:00
}
fn testSignedWrappingEval(x: i32) !void {
const min_val = x +% 1;
try expect(min_val == minInt(i32));
const max_val = min_val -% 1;
try expect(max_val == maxInt(i32));
}
test "signed negation wrapping" {
try testSignedNegationWrappingEval(minInt(i16));
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime testSignedNegationWrappingEval(minInt(i16));
stage2: more division support AIR: * div is renamed to div_trunc. * Add div_float, div_floor, div_exact. - Implemented in Sema and LLVM codegen. C backend has a stub. Improvements to std.math.big.Int: * Add `eqZero` function to `Mutable`. * Fix incorrect results for `divFloor`. Compiler-rt: * Add muloti4 to the stage2 section.
2021-10-21 19:05:26 -07:00
}
fn testSignedNegationWrappingEval(x: i16) !void {
try expect(x == -32768);
const neg = -%x;
try expect(neg == -32768);
}
test "unsigned negation wrapping" {
try testUnsignedNegationWrappingEval(1);
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime testUnsignedNegationWrappingEval(1);
stage2: more division support AIR: * div is renamed to div_trunc. * Add div_float, div_floor, div_exact. - Implemented in Sema and LLVM codegen. C backend has a stub. Improvements to std.math.big.Int: * Add `eqZero` function to `Mutable`. * Fix incorrect results for `divFloor`. Compiler-rt: * Add muloti4 to the stage2 section.
2021-10-21 19:05:26 -07:00
}
fn testUnsignedNegationWrappingEval(x: u16) !void {
try expect(x == 1);
const neg = -%x;
try expect(neg == maxInt(u16));
}
CBE: fix bitwise not Closes #13911
2022-12-20 21:31:44 -05:00
test "negation wrapping" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
update uses of overflow arithmetic builtins
2022-12-21 16:40:30 +02:00
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
CBE: fix bitwise not Closes #13911
2022-12-20 21:31:44 -05:00
try expectEqual(@as(u1, 1), negateWrap(u1, 1));
}
fn negateWrap(comptime T: type, x: T) T {
// This is specifically testing a safety-checked add, so
// special case minInt(T) which would overflow otherwise.
return if (x == minInt(T)) minInt(T) else ~x + 1;
}
stage2: more division support AIR: * div is renamed to div_trunc. * Add div_float, div_floor, div_exact. - Implemented in Sema and LLVM codegen. C backend has a stub. Improvements to std.math.big.Int: * Add `eqZero` function to `Mutable`. * Fix incorrect results for `divFloor`. Compiler-rt: * Add muloti4 to the stage2 section.
2021-10-21 19:05:26 -07:00
test "unsigned 64-bit division" {
behavior tests cleanup: promote math.zig
2022-03-03 01:23:50 -07:00
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
behavior tests cleanup: promote math.zig
2022-03-03 01:23:50 -07:00
stage2: more division support AIR: * div is renamed to div_trunc. * Add div_float, div_floor, div_exact. - Implemented in Sema and LLVM codegen. C backend has a stub. Improvements to std.math.big.Int: * Add `eqZero` function to `Mutable`. * Fix incorrect results for `divFloor`. Compiler-rt: * Add muloti4 to the stage2 section.
2021-10-21 19:05:26 -07:00
try test_u64_div();
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime test_u64_div();
stage2: more division support AIR: * div is renamed to div_trunc. * Add div_float, div_floor, div_exact. - Implemented in Sema and LLVM codegen. C backend has a stub. Improvements to std.math.big.Int: * Add `eqZero` function to `Mutable`. * Fix incorrect results for `divFloor`. Compiler-rt: * Add muloti4 to the stage2 section.
2021-10-21 19:05:26 -07:00
}
fn test_u64_div() !void {
const result = divWithResult(1152921504606846976, 34359738365);
try expect(result.quotient == 33554432);
try expect(result.remainder == 100663296);
}
fn divWithResult(a: u64, b: u64) DivResult {
return DivResult{
.quotient = a / b,
.remainder = a % b,
};
}
const DivResult = struct {
quotient: u64,
remainder: u64,
};
Sema: make `align(a) T` same as `align(a:0:N) T` where `@sizeOf(T) == N`.
2022-02-26 15:19:13 -07:00
test "bit shift a u1" {
var x: u1 = 1;
test: update behavior to silence 'var is never mutated' errors
2023-11-16 13:21:18 +00:00
_ = &x;
const y = x << 0;
Sema: make `align(a) T` same as `align(a:0:N) T` where `@sizeOf(T) == N`.
2022-02-26 15:19:13 -07:00
try expect(y == 1);
}
stage2: more division support AIR: * div is renamed to div_trunc. * Add div_float, div_floor, div_exact. - Implemented in Sema and LLVM codegen. C backend has a stub. Improvements to std.math.big.Int: * Add `eqZero` function to `Mutable`. * Fix incorrect results for `divFloor`. Compiler-rt: * Add muloti4 to the stage2 section.
2021-10-21 19:05:26 -07:00
test "truncating shift right" {
try testShrTrunc(maxInt(u16));
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime testShrTrunc(maxInt(u16));
stage2: more division support AIR: * div is renamed to div_trunc. * Add div_float, div_floor, div_exact. - Implemented in Sema and LLVM codegen. C backend has a stub. Improvements to std.math.big.Int: * Add `eqZero` function to `Mutable`. * Fix incorrect results for `divFloor`. Compiler-rt: * Add muloti4 to the stage2 section.
2021-10-21 19:05:26 -07:00
}
fn testShrTrunc(x: u16) !void {
const shifted = x >> 1;
try expect(shifted == 32767);
}
test "f128" {
behavior tests cleanup: promote math.zig
2022-03-03 01:23:50 -07:00
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
setup spirv backend in behavior tests
2023-05-11 09:23:34 +03:30
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
x86_64+macho: pass more behavior tests
2024-01-29 15:33:45 +01:00
if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
behavior tests cleanup: promote math.zig
2022-03-03 01:23:50 -07:00
stage2: more division support AIR: * div is renamed to div_trunc. * Add div_float, div_floor, div_exact. - Implemented in Sema and LLVM codegen. C backend has a stub. Improvements to std.math.big.Int: * Add `eqZero` function to `Mutable`. * Fix incorrect results for `divFloor`. Compiler-rt: * Add muloti4 to the stage2 section.
2021-10-21 19:05:26 -07:00
try test_f128();
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime test_f128();
stage2: more division support AIR: * div is renamed to div_trunc. * Add div_float, div_floor, div_exact. - Implemented in Sema and LLVM codegen. C backend has a stub. Improvements to std.math.big.Int: * Add `eqZero` function to `Mutable`. * Fix incorrect results for `divFloor`. Compiler-rt: * Add muloti4 to the stage2 section.
2021-10-21 19:05:26 -07:00
}
fn make_f128(x: f128) f128 {
return x;
}
fn test_f128() !void {
try expect(@sizeOf(f128) == 16);
try expect(make_f128(1.0) == 1.0);
try expect(make_f128(1.0) != 1.1);
try expect(make_f128(1.0) > 0.9);
try expect(make_f128(1.0) >= 0.9);
try expect(make_f128(1.0) >= 1.0);
try should_not_be_zero(1.0);
}
fn should_not_be_zero(x: f128) !void {
try expect(x != 0.0);
}
test "128-bit multiplication" {
behavior tests cleanup: promote math.zig
2022-03-03 01:23:50 -07:00
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
setup spirv backend in behavior tests
2023-05-11 09:23:34 +03:30
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
x86_64+macho: pass more behavior tests
2024-01-29 15:33:45 +01:00
if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
std.Target: Replace isARM() with isArmOrThumb() and rename it to isArm(). The old isARM() function was a portability trap. With the name it had, it seemed like the obviously correct function to use, but it didn't include Thumb. In the vast majority of cases where someone wants to ask "is the target Arm?", Thumb *should* be included. There are exactly 3 cases in the codebase where we do actually need to exclude Thumb, although one of those is in Aro and mirrors a check in Clang that is itself likely a bug. These rare cases can just add an extra isThumb() check.
2024-10-03 08:34:19 +02:00
if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArm()) return error.SkipZigTest;
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
behavior tests cleanup: promote math.zig
2022-03-03 01:23:50 -07:00
cbe: fixes for compiling zig2.c under msvc - add zig_mul_i128 - render slice structs in static initializers without casts / c99 style init - add negative numbers and u128 to 128-bit multiply test
2022-12-23 23:48:44 -05:00
{
var a: i128 = 3;
var b: i128 = 2;
var c = a * b;
try expect(c == 6);
a = -3;
b = 2;
c = a * b;
try expect(c == -6);
}
{
var a: u128 = 0xffffffffffffffff;
var b: u128 = 100;
test: update behavior to silence 'var is never mutated' errors
2023-11-16 13:21:18 +00:00
_ = .{ &a, &b };
const c = a * b;
cbe: fixes for compiling zig2.c under msvc - add zig_mul_i128 - render slice structs in static initializers without casts / c99 style init - add negative numbers and u128 to 128-bit multiply test
2022-12-23 23:48:44 -05:00
try expect(c == 0x63ffffffffffffff9c);
}
stage2: more division support AIR: * div is renamed to div_trunc. * Add div_float, div_floor, div_exact. - Implemented in Sema and LLVM codegen. C backend has a stub. Improvements to std.math.big.Int: * Add `eqZero` function to `Mutable`. * Fix incorrect results for `divFloor`. Compiler-rt: * Add muloti4 to the stage2 section.
2021-10-21 19:05:26 -07:00
}
stage2: @addWithOverflow
2021-12-18 04:42:13 +01:00
stage2-wasm: enhance add/subWithOverflow Added behavior tests to verify implementation
2024-07-18 17:54:44 +02:00
fn testAddWithOverflow(comptime T: type, a: T, b: T, add: T, bit: u1) !void {
const ov = @addWithOverflow(a, b);
try expect(ov[0] == add);
try expect(ov[1] == bit);
}
stage2: @addWithOverflow
2021-12-18 04:42:13 +01:00
test "@addWithOverflow" {
update uses of overflow arithmetic builtins
2022-12-21 16:40:30 +02:00
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
stage2-wasm: enhance add/subWithOverflow Added behavior tests to verify implementation
2024-07-18 17:54:44 +02:00
try testAddWithOverflow(u8, 250, 100, 94, 1);
try testAddWithOverflow(u8, 100, 150, 250, 0);
aarch64: sub_with_overflow should always track V flag
2022-05-14 21:24:48 +02:00
stage2-wasm: enhance add/subWithOverflow Added behavior tests to verify implementation
2024-07-18 17:54:44 +02:00
try testAddWithOverflow(u8, 200, 99, 43, 1);
try testAddWithOverflow(u8, 200, 55, 255, 0);
aarch64: sub_with_overflow should always track V flag
2022-05-14 21:24:48 +02:00
stage2-wasm: enhance add/subWithOverflow Added behavior tests to verify implementation
2024-07-18 17:54:44 +02:00
try testAddWithOverflow(usize, 6, 6, 12, 0);
try testAddWithOverflow(usize, maxInt(usize), 6, 5, 1);
try testAddWithOverflow(isize, -6, -6, -12, 0);
try testAddWithOverflow(isize, minInt(isize), -6, maxInt(isize) - 5, 1);
}
test "@addWithOverflow > 64 bits" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
spirv: skip range switch tests This is not yet implemented
2024-10-13 01:58:11 +02:00
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
stage2-wasm: enhance add/subWithOverflow Added behavior tests to verify implementation
2024-07-18 17:54:44 +02:00
try testAddWithOverflow(u65, 4, 105, 109, 0);
try testAddWithOverflow(u65, 1000, 100, 1100, 0);
try testAddWithOverflow(u65, 100, maxInt(u65) - 99, 0, 1);
try testAddWithOverflow(u65, maxInt(u65), maxInt(u65), maxInt(u65) - 1, 1);
try testAddWithOverflow(u65, maxInt(u65) - 1, maxInt(u65), maxInt(u65) - 2, 1);
try testAddWithOverflow(u65, maxInt(u65), maxInt(u65) - 1, maxInt(u65) - 2, 1);
try testAddWithOverflow(u128, 4, 105, 109, 0);
try testAddWithOverflow(u128, 1000, 100, 1100, 0);
try testAddWithOverflow(u128, 100, maxInt(u128) - 99, 0, 1);
try testAddWithOverflow(u128, maxInt(u128), maxInt(u128), maxInt(u128) - 1, 1);
try testAddWithOverflow(u128, maxInt(u128) - 1, maxInt(u128), maxInt(u128) - 2, 1);
try testAddWithOverflow(u128, maxInt(u128), maxInt(u128) - 1, maxInt(u128) - 2, 1);
try testAddWithOverflow(i65, 4, -105, -101, 0);
try testAddWithOverflow(i65, 1000, 100, 1100, 0);
try testAddWithOverflow(i65, minInt(i65), 1, minInt(i65) + 1, 0);
try testAddWithOverflow(i65, maxInt(i65), minInt(i65), -1, 0);
try testAddWithOverflow(i65, minInt(i65), maxInt(i65), -1, 0);
try testAddWithOverflow(i65, maxInt(i65), -2, maxInt(i65) - 2, 0);
try testAddWithOverflow(i65, maxInt(i65), maxInt(i65), -2, 1);
try testAddWithOverflow(i65, minInt(i65), minInt(i65), 0, 1);
try testAddWithOverflow(i65, maxInt(i65) - 1, maxInt(i65), -3, 1);
try testAddWithOverflow(i65, maxInt(i65), maxInt(i65) - 1, -3, 1);
try testAddWithOverflow(i128, 4, -105, -101, 0);
try testAddWithOverflow(i128, 1000, 100, 1100, 0);
try testAddWithOverflow(i128, minInt(i128), 1, minInt(i128) + 1, 0);
try testAddWithOverflow(i128, maxInt(i128), minInt(i128), -1, 0);
try testAddWithOverflow(i128, minInt(i128), maxInt(i128), -1, 0);
try testAddWithOverflow(i128, maxInt(i128), -2, maxInt(i128) - 2, 0);
try testAddWithOverflow(i128, maxInt(i128), maxInt(i128), -2, 1);
try testAddWithOverflow(i128, minInt(i128), minInt(i128), 0, 1);
try testAddWithOverflow(i128, maxInt(i128) - 1, maxInt(i128), -3, 1);
try testAddWithOverflow(i128, maxInt(i128), maxInt(i128) - 1, -3, 1);
stage2: @addWithOverflow
2021-12-18 04:42:13 +01:00
}
test "small int addition" {
update uses of overflow arithmetic builtins
2022-12-21 16:40:30 +02:00
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
stage2: @addWithOverflow
2021-12-18 04:42:13 +01:00
var x: u2 = 0;
try expect(x == 0);
x += 1;
try expect(x == 1);
x += 1;
try expect(x == 2);
x += 1;
try expect(x == 3);
update uses of overflow arithmetic builtins
2022-12-21 16:40:30 +02:00
const ov = @addWithOverflow(x, 1);
try expect(ov[0] == 0);
try expect(ov[1] == 1);
stage2: @addWithOverflow
2021-12-18 04:42:13 +01:00
}
stage2: @mulWithOverflow
2021-12-20 02:06:09 +01:00
stage2-wasm: @mulWithOverflow fixes + 128 bit signed
2024-07-20 13:21:46 +02:00
fn testMulWithOverflow(comptime T: type, a: T, b: T, mul: T, bit: u1) !void {
const ov = @mulWithOverflow(a, b);
try expect(ov[0] == mul);
try expect(ov[1] == bit);
}
test: test more int sizes for @mulWithOverflow builtin
2022-05-04 23:12:59 +02:00
test "basic @mulWithOverflow" {
update uses of overflow arithmetic builtins
2022-12-21 16:40:30 +02:00
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
stage2-wasm: @mulWithOverflow fixes + 128 bit signed
2024-07-20 13:21:46 +02:00
try testMulWithOverflow(u8, 86, 3, 2, 1);
try testMulWithOverflow(u8, 85, 3, 255, 0);
x64: partially fix genImul, enable overflow tests
2022-03-28 17:45:50 +02:00
stage2-wasm: @mulWithOverflow fixes + 128 bit signed
2024-07-20 13:21:46 +02:00
try testMulWithOverflow(u8, 123, 2, 246, 0);
try testMulWithOverflow(u8, 123, 4, 236, 1);
stage2: @mulWithOverflow
2021-12-20 02:06:09 +01:00
}
stage2: @subWithOverflow
2021-12-20 21:53:40 +01:00
test: test more int sizes for @mulWithOverflow builtin
2022-05-04 23:12:59 +02:00
test "extensive @mulWithOverflow" {
update uses of overflow arithmetic builtins
2022-12-21 16:40:30 +02:00
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
test: test more int sizes for @mulWithOverflow builtin
2022-05-04 23:12:59 +02:00
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
test: test more int sizes for @mulWithOverflow builtin
2022-05-04 23:12:59 +02:00
stage2-wasm: @mulWithOverflow fixes + 128 bit signed
2024-07-20 13:21:46 +02:00
try testMulWithOverflow(u5, 3, 10, 30, 0);
try testMulWithOverflow(u5, 3, 11, 1, 1);
try testMulWithOverflow(i5, 3, -5, -15, 0);
try testMulWithOverflow(i5, 3, -6, 14, 1);
test: test more int sizes for @mulWithOverflow builtin
2022-05-04 23:12:59 +02:00
stage2-wasm: @mulWithOverflow fixes + 128 bit signed
2024-07-20 13:21:46 +02:00
try testMulWithOverflow(u8, 3, 85, 255, 0);
try testMulWithOverflow(u8, 3, 86, 2, 1);
try testMulWithOverflow(i8, 3, -42, -126, 0);
try testMulWithOverflow(i8, 3, -43, 127, 1);
test: test more int sizes for @mulWithOverflow builtin
2022-05-04 23:12:59 +02:00
stage2-wasm: @mulWithOverflow fixes + 128 bit signed
2024-07-20 13:21:46 +02:00
try testMulWithOverflow(u14, 3, 0x1555, 0x3fff, 0);
try testMulWithOverflow(u14, 3, 0x1556, 2, 1);
try testMulWithOverflow(i14, 3, -0xaaa, -0x1ffe, 0);
try testMulWithOverflow(i14, 3, -0xaab, 0x1fff, 1);
test: test bitwidths between 1...8 and 8...16 for mul_with_overflow
2022-05-05 21:43:31 +02:00
stage2-wasm: @mulWithOverflow fixes + 128 bit signed
2024-07-20 13:21:46 +02:00
try testMulWithOverflow(u16, 3, 0x5555, 0xffff, 0);
try testMulWithOverflow(u16, 3, 0x5556, 2, 1);
try testMulWithOverflow(i16, 3, -0x2aaa, -0x7ffe, 0);
try testMulWithOverflow(i16, 3, -0x2aab, 0x7fff, 1);
test: test bitwidths between 1...8 and 8...16 for mul_with_overflow
2022-05-05 21:43:31 +02:00
stage2-wasm: @mulWithOverflow fixes + 128 bit signed
2024-07-20 13:21:46 +02:00
try testMulWithOverflow(u30, 3, 0x15555555, 0x3fffffff, 0);
try testMulWithOverflow(u30, 3, 0x15555556, 2, 1);
try testMulWithOverflow(i30, 3, -0xaaaaaaa, -0x1ffffffe, 0);
try testMulWithOverflow(i30, 3, -0xaaaaaab, 0x1fffffff, 1);
test: test more int sizes for @mulWithOverflow builtin
2022-05-04 23:12:59 +02:00
stage2-wasm: @mulWithOverflow fixes + 128 bit signed
2024-07-20 13:21:46 +02:00
try testMulWithOverflow(u32, 3, 0x55555555, 0xffffffff, 0);
try testMulWithOverflow(u32, 3, 0x55555556, 2, 1);
try testMulWithOverflow(i32, 3, -0x2aaaaaaa, -0x7ffffffe, 0);
try testMulWithOverflow(i32, 3, -0x2aaaaaab, 0x7fffffff, 1);
test: test more int sizes for @mulWithOverflow builtin
2022-05-04 23:12:59 +02:00
stage2-wasm: @mulWithOverflow fixes + 128 bit signed
2024-07-20 13:21:46 +02:00
try testMulWithOverflow(u31, 1 << 30, 1 << 30, 0, 1);
try testMulWithOverflow(i31, minInt(i31), minInt(i31), 0, 1);
stage2: Split `@mulWithOverflow` tests
2022-05-07 17:09:09 +02:00
}
test "@mulWithOverflow bitsize > 32" {
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
update uses of overflow arithmetic builtins
2022-12-21 16:40:30 +02:00
// aarch64 fails on a release build of the compiler.
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
stage2: Split `@mulWithOverflow` tests
2022-05-07 17:09:09 +02:00
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
test: test more int sizes for @mulWithOverflow builtin
2022-05-04 23:12:59 +02:00
stage2-wasm: @mulWithOverflow fixes + 128 bit signed
2024-07-20 13:21:46 +02:00
try testMulWithOverflow(u40, 3, 0x55_5555_5555, 0xff_ffff_ffff, 0);
try testMulWithOverflow(u40, 3, 0x55_5555_5556, 2, 1);
try testMulWithOverflow(u40, 0x10_0000_0000, 0x10_0000_0000, 0, 1);
spirv: new vectorization helper The old vectorization helper (WipElementWise) was clunky and a bit annoying to use, and it wasn't really flexible enough. This introduces a new vectorization helper, which uses Temporary and Operation types to deduce a Vectorization to perform the operation in a reasonably efficient manner. It removes the outer loop required by WipElementWise so that implementations of AIR instructions are cleaner. This helps with sanity when we start to introduce support for composite integers. airShift, convertToDirect, convertToIndirect, and normalize are initially implemented using this new method.
2024-06-03 00:44:08 +02:00
stage2-wasm: @mulWithOverflow fixes + 128 bit signed
2024-07-20 13:21:46 +02:00
try testMulWithOverflow(i40, 3, -0x2a_aaaa_aaaa, -0x7f_ffff_fffe, 0);
try testMulWithOverflow(i40, 3, -0x2a_aaaa_aaab, 0x7f_ffff_ffff, 1);
try testMulWithOverflow(i40, 6, -0x2a_aaaa_aaab, -2, 1);
try testMulWithOverflow(i40, 0x08_0000_0000, -0x08_0000_0001, -0x8_0000_0000, 1);
spirv: new vectorization helper The old vectorization helper (WipElementWise) was clunky and a bit annoying to use, and it wasn't really flexible enough. This introduces a new vectorization helper, which uses Temporary and Operation types to deduce a Vectorization to perform the operation in a reasonably efficient manner. It removes the outer loop required by WipElementWise so that implementations of AIR instructions are cleaner. This helps with sanity when we start to introduce support for composite integers. airShift, convertToDirect, convertToIndirect, and normalize are initially implemented using this new method.
2024-06-03 00:44:08 +02:00
stage2-wasm: @mulWithOverflow fixes + 128 bit signed
2024-07-20 13:21:46 +02:00
try testMulWithOverflow(u62, 3, 0x1555555555555555, 0x3fffffffffffffff, 0);
try testMulWithOverflow(u62, 3, 0x1555555555555556, 2, 1);
try testMulWithOverflow(i62, 3, -0xaaaaaaaaaaaaaaa, -0x1ffffffffffffffe, 0);
try testMulWithOverflow(i62, 3, -0xaaaaaaaaaaaaaab, 0x1fffffffffffffff, 1);
test: test more int sizes for @mulWithOverflow builtin
2022-05-04 23:12:59 +02:00
stage2-wasm: @mulWithOverflow fixes + 128 bit signed
2024-07-20 13:21:46 +02:00
try testMulWithOverflow(u64, 3, 0x5555555555555555, 0xffffffffffffffff, 0);
try testMulWithOverflow(u64, 3, 0x5555555555555556, 2, 1);
try testMulWithOverflow(i64, 3, -0x2aaaaaaaaaaaaaaa, -0x7ffffffffffffffe, 0);
try testMulWithOverflow(i64, 3, -0x2aaaaaaaaaaaaaab, 0x7fffffffffffffff, 1);
test: test more int sizes for @mulWithOverflow builtin
2022-05-04 23:12:59 +02:00
stage2-wasm: @mulWithOverflow fixes + 128 bit signed
2024-07-20 13:21:46 +02:00
try testMulWithOverflow(u63, 1 << 62, 1 << 62, 0, 1);
try testMulWithOverflow(i63, minInt(i63), minInt(i63), 0, 1);
}
test: test more int sizes for @mulWithOverflow builtin
2022-05-04 23:12:59 +02:00
stage2-wasm: @mulWithOverflow fixes + 128 bit signed
2024-07-20 13:21:46 +02:00
test "@mulWithOverflow bitsize 128 bits" {
disable failing tests on stage2 backends
2024-07-20 14:58:41 +02:00
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
stage2-wasm: @mulWithOverflow fixes + 128 bit signed
2024-07-20 13:21:46 +02:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
spirv: skip range switch tests This is not yet implemented
2024-10-13 01:58:11 +02:00
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
stage2-wasm: @mulWithOverflow fixes + 128 bit signed
2024-07-20 13:21:46 +02:00
try testMulWithOverflow(u128, 3, 0x5555555555555555_5555555555555555, 0xffffffffffffffff_ffffffffffffffff, 0);
try testMulWithOverflow(u128, 3, 0x5555555555555555_5555555555555556, 2, 1);
try testMulWithOverflow(u128, 1 << 100, 1 << 27, 1 << 127, 0);
try testMulWithOverflow(u128, maxInt(u128), maxInt(u128), 1, 1);
try testMulWithOverflow(u128, 1 << 100, 1 << 28, 0, 1);
try testMulWithOverflow(u128, 1 << 127, 1 << 127, 0, 1);
try testMulWithOverflow(i128, 3, -0x2aaaaaaaaaaaaaaa_aaaaaaaaaaaaaaaa, -0x7fffffffffffffff_fffffffffffffffe, 0);
try testMulWithOverflow(i128, 3, -0x2aaaaaaaaaaaaaaa_aaaaaaaaaaaaaaab, 0x7fffffffffffffff_ffffffffffffffff, 1);
try testMulWithOverflow(i128, -1, -1, 1, 0);
try testMulWithOverflow(i128, minInt(i128), minInt(i128), 0, 1);
test: test more int sizes for @mulWithOverflow builtin
2022-05-04 23:12:59 +02:00
}
x86_64: implement mul, div, and mod of large integers This enables the last compiler-rt test disabled for the x86_64 backend.
2024-02-05 05:31:57 +01:00
test "@mulWithOverflow u256" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
test: skip new failing tests for spirv
2024-02-15 18:44:24 +03:30
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
x86_64: implement mul, div, and mod of large integers This enables the last compiler-rt test disabled for the x86_64 backend.
2024-02-05 05:31:57 +01:00
{
const const_lhs: u256 = 8035709466408580321693645878924206181189;
const const_rhs: u256 = 343954217539185679456797259115612849079;
const const_result = @mulWithOverflow(const_lhs, const_rhs);
comptime assert(const_result[0] == 100698109432518020450541558444080472799095368135495022414802684874680804056403);
comptime assert(const_result[1] == 1);
var var_lhs = const_lhs;
var var_rhs = const_rhs;
_ = .{ &var_lhs, &var_rhs };
const var_result = @mulWithOverflow(var_lhs, var_rhs);
try std.testing.expect(var_result[0] == const_result[0]);
try std.testing.expect(var_result[1] == const_result[1]);
}
{
const const_lhs: u256 = 100477140835310762407466294984162740292250605075409128262608;
const const_rhs: u256 = 406310585934439581231;
const const_result = @mulWithOverflow(const_lhs, const_rhs);
comptime assert(const_result[0] == 66110554277021146912650321519727251744526528332039438002889524600764482652976);
comptime assert(const_result[1] == 1);
var var_lhs = const_lhs;
var var_rhs = const_rhs;
_ = .{ &var_lhs, &var_rhs };
const var_result = @mulWithOverflow(var_lhs, var_rhs);
try std.testing.expect(var_result[0] == const_result[0]);
try std.testing.expect(var_result[1] == const_result[1]);
}
}
stage2-wasm: enhance add/subWithOverflow Added behavior tests to verify implementation
2024-07-18 17:54:44 +02:00
fn testSubWithOverflow(comptime T: type, a: T, b: T, sub: T, bit: u1) !void {
const ov = @subWithOverflow(a, b);
try expect(ov[0] == sub);
try expect(ov[1] == bit);
}
stage2: @subWithOverflow
2021-12-20 21:53:40 +01:00
test "@subWithOverflow" {
update uses of overflow arithmetic builtins
2022-12-21 16:40:30 +02:00
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
stage2-wasm: enhance add/subWithOverflow Added behavior tests to verify implementation
2024-07-18 17:54:44 +02:00
try testSubWithOverflow(u8, 1, 2, 255, 1);
try testSubWithOverflow(u8, 1, 1, 0, 0);
stage2: @subWithOverflow
2021-12-20 21:53:40 +01:00
stage2-wasm: enhance add/subWithOverflow Added behavior tests to verify implementation
2024-07-18 17:54:44 +02:00
try testSubWithOverflow(u16, 10000, 10002, 65534, 1);
try testSubWithOverflow(u16, 10000, 9999, 1, 0);
aarch64: sub_with_overflow should always track V flag
2022-05-14 21:24:48 +02:00
stage2-wasm: enhance add/subWithOverflow Added behavior tests to verify implementation
2024-07-18 17:54:44 +02:00
try testSubWithOverflow(usize, 6, 6, 0, 0);
try testSubWithOverflow(usize, 6, 7, maxInt(usize), 1);
try testSubWithOverflow(isize, -6, -6, 0, 0);
try testSubWithOverflow(isize, minInt(isize), 6, maxInt(isize) - 5, 1);
}
aarch64: sub_with_overflow should always track V flag
2022-05-14 21:24:48 +02:00
stage2-wasm: enhance add/subWithOverflow Added behavior tests to verify implementation
2024-07-18 17:54:44 +02:00
test "@subWithOverflow > 64 bits" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
spirv: skip range switch tests This is not yet implemented
2024-10-13 01:58:11 +02:00
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
stage2-wasm: enhance add/subWithOverflow Added behavior tests to verify implementation
2024-07-18 17:54:44 +02:00
try testSubWithOverflow(u65, 4, 105, maxInt(u65) - 100, 1);
try testSubWithOverflow(u65, 1000, 100, 900, 0);
try testSubWithOverflow(u65, maxInt(u65), maxInt(u65), 0, 0);
try testSubWithOverflow(u65, maxInt(u65) - 1, maxInt(u65), maxInt(u65), 1);
try testSubWithOverflow(u65, maxInt(u65), maxInt(u65) - 1, 1, 0);
try testSubWithOverflow(u128, 4, 105, maxInt(u128) - 100, 1);
try testSubWithOverflow(u128, 1000, 100, 900, 0);
try testSubWithOverflow(u128, maxInt(u128), maxInt(u128), 0, 0);
try testSubWithOverflow(u128, maxInt(u128) - 1, maxInt(u128), maxInt(u128), 1);
try testSubWithOverflow(u128, maxInt(u128), maxInt(u128) - 1, 1, 0);
try testSubWithOverflow(i65, 4, 105, -101, 0);
try testSubWithOverflow(i65, 1000, 100, 900, 0);
try testSubWithOverflow(i65, maxInt(i65), maxInt(i65), 0, 0);
try testSubWithOverflow(i65, minInt(i65), minInt(i65), 0, 0);
try testSubWithOverflow(i65, maxInt(i65) - 1, maxInt(i65), -1, 0);
try testSubWithOverflow(i65, maxInt(i65), maxInt(i65) - 1, 1, 0);
try testSubWithOverflow(i65, minInt(i65), 1, maxInt(i65), 1);
try testSubWithOverflow(i65, maxInt(i65), minInt(i65), -1, 1);
try testSubWithOverflow(i65, minInt(i65), maxInt(i65), 1, 1);
try testSubWithOverflow(i65, maxInt(i65), -2, minInt(i65) + 1, 1);
try testSubWithOverflow(i128, 4, 105, -101, 0);
try testSubWithOverflow(i128, 1000, 100, 900, 0);
try testSubWithOverflow(i128, maxInt(i128), maxInt(i128), 0, 0);
try testSubWithOverflow(i128, minInt(i128), minInt(i128), 0, 0);
try testSubWithOverflow(i128, maxInt(i128) - 1, maxInt(i128), -1, 0);
try testSubWithOverflow(i128, maxInt(i128), maxInt(i128) - 1, 1, 0);
try testSubWithOverflow(i128, minInt(i128), 1, maxInt(i128), 1);
try testSubWithOverflow(i128, maxInt(i128), minInt(i128), -1, 1);
try testSubWithOverflow(i128, minInt(i128), maxInt(i128), 1, 1);
try testSubWithOverflow(i128, maxInt(i128), -2, minInt(i128) + 1, 1);
stage2: @subWithOverflow
2021-12-20 21:53:40 +01:00
}
stage2: @shlWithOverflow
2021-12-21 01:38:46 +01:00
stage2-wasm: improve @shlWithOverflow for <= 128 bits Additionally fixed a bug for shr on signed big ints
2024-07-18 18:01:06 +02:00
fn testShlWithOverflow(comptime T: type, a: T, b: math.Log2Int(T), shl: T, bit: u1) !void {
const ov = @shlWithOverflow(a, b);
try expect(ov[0] == shl);
try expect(ov[1] == bit);
}
stage2: @shlWithOverflow
2021-12-21 01:38:46 +01:00
test "@shlWithOverflow" {
update uses of overflow arithmetic builtins
2022-12-21 16:40:30 +02:00
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
setup spirv backend in behavior tests
2023-05-11 09:23:34 +03:30
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
setup spirv backend in behavior tests
2023-05-11 09:23:34 +03:30
stage2-wasm: improve @shlWithOverflow for <= 128 bits Additionally fixed a bug for shr on signed big ints
2024-07-18 18:01:06 +02:00
try testShlWithOverflow(u4, 2, 1, 4, 0);
try testShlWithOverflow(u4, 2, 3, 0, 1);
x64: implement shl with overflow for non-pow-2
2022-05-10 21:19:05 +02:00
stage2-wasm: improve @shlWithOverflow for <= 128 bits Additionally fixed a bug for shr on signed big ints
2024-07-18 18:01:06 +02:00
try testShlWithOverflow(i9, 127, 1, 254, 0);
try testShlWithOverflow(i9, 127, 2, -4, 1);
behavior tests cleanup: promote math.zig
2022-03-03 01:23:50 -07:00
stage2-wasm: improve @shlWithOverflow for <= 128 bits Additionally fixed a bug for shr on signed big ints
2024-07-18 18:01:06 +02:00
try testShlWithOverflow(u16, 0b0010111111111111, 3, 0b0111111111111000, 1);
try testShlWithOverflow(u16, 0b0010111111111111, 2, 0b1011111111111100, 0);
x64: implement shl with overflow for non-pow-2
2022-05-10 21:19:05 +02:00
stage2-wasm: improve @shlWithOverflow for <= 128 bits Additionally fixed a bug for shr on signed big ints
2024-07-18 18:01:06 +02:00
try testShlWithOverflow(u16, 0b0000_0000_0000_0011, 15, 0b1000_0000_0000_0000, 1);
try testShlWithOverflow(u16, 0b0000_0000_0000_0011, 14, 0b1100_0000_0000_0000, 0);
}
stage2: @shlWithOverflow
2021-12-21 01:38:46 +01:00
stage2-wasm: improve @shlWithOverflow for <= 128 bits Additionally fixed a bug for shr on signed big ints
2024-07-18 18:01:06 +02:00
test "@shlWithOverflow > 64 bits" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
try testShlWithOverflow(u65, 0x0_0100_0000_0000_0000, 7, 0x0_8000_0000_0000_0000, 0);
try testShlWithOverflow(u65, 0x0_0100_0000_0000_0000, 8, 0x1_0000_0000_0000_0000, 0);
try testShlWithOverflow(u65, 0x0_0100_0000_0000_0000, 9, 0, 1);
try testShlWithOverflow(u65, 0x0_0100_0000_0000_0000, 10, 0, 1);
try testShlWithOverflow(u128, 0x0100_0000_0000_0000_0000000000000000, 6, 0x4000_0000_0000_0000_0000000000000000, 0);
try testShlWithOverflow(u128, 0x0100_0000_0000_0000_0000000000000000, 7, 0x8000_0000_0000_0000_0000000000000000, 0);
try testShlWithOverflow(u128, 0x0100_0000_0000_0000_0000000000000000, 8, 0, 1);
try testShlWithOverflow(u128, 0x0100_0000_0000_0000_0000000000000000, 9, 0, 1);
try testShlWithOverflow(i65, 0x0_0100_0000_0000_0000, 7, 0x0_8000_0000_0000_0000, 0);
try testShlWithOverflow(i65, 0x0_0100_0000_0000_0000, 8, minInt(i65), 1);
try testShlWithOverflow(i65, 0x0_0100_0000_0000_0000, 9, 0, 1);
try testShlWithOverflow(i65, 0x0_0100_0000_0000_0000, 10, 0, 1);
try testShlWithOverflow(i128, 0x0100_0000_0000_0000_0000000000000000, 6, 0x4000_0000_0000_0000_0000000000000000, 0);
try testShlWithOverflow(i128, 0x0100_0000_0000_0000_0000000000000000, 7, minInt(i128), 1);
try testShlWithOverflow(i128, 0x0100_0000_0000_0000_0000000000000000, 8, 0, 1);
try testShlWithOverflow(i128, 0x0100_0000_0000_0000_0000000000000000, 9, 0, 1);
stage2: @shlWithOverflow
2021-12-21 01:38:46 +01:00
}
test "overflow arithmetic with u0 values" {
spirv: update failing / passing tests Some tests are now failing due to debug info changes, some tests now pass due to improved compiler functionality.
2023-09-23 01:30:16 +02:00
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
update uses of overflow arithmetic builtins
2022-12-21 16:40:30 +02:00
{
var a: u0 = 0;
test: update behavior to silence 'var is never mutated' errors
2023-11-16 13:21:18 +00:00
_ = &a;
update uses of overflow arithmetic builtins
2022-12-21 16:40:30 +02:00
const ov = @addWithOverflow(a, 0);
try expect(ov[1] == 0);
try expect(ov[1] == 0);
}
{
var a: u0 = 0;
test: update behavior to silence 'var is never mutated' errors
2023-11-16 13:21:18 +00:00
_ = &a;
update uses of overflow arithmetic builtins
2022-12-21 16:40:30 +02:00
const ov = @subWithOverflow(a, 0);
try expect(ov[1] == 0);
try expect(ov[1] == 0);
}
{
var a: u0 = 0;
test: update behavior to silence 'var is never mutated' errors
2023-11-16 13:21:18 +00:00
_ = &a;
update uses of overflow arithmetic builtins
2022-12-21 16:40:30 +02:00
const ov = @mulWithOverflow(a, 0);
try expect(ov[1] == 0);
try expect(ov[1] == 0);
}
{
var a: u0 = 0;
test: update behavior to silence 'var is never mutated' errors
2023-11-16 13:21:18 +00:00
_ = &a;
update uses of overflow arithmetic builtins
2022-12-21 16:40:30 +02:00
const ov = @shlWithOverflow(a, 0);
try expect(ov[1] == 0);
try expect(ov[1] == 0);
}
stage2: @shlWithOverflow
2021-12-21 01:38:46 +01:00
}
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
fix(text): hyphenate "comptime" adjectives
2022-10-05 20:58:23 +02:00
test "allow signed integer division/remainder when values are comptime-known and positive or exact" {
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
try expect(5 / 3 == 1);
try expect(-5 / -3 == 1);
try expect(-6 / 3 == -2);
try expect(5 % 3 == 2);
try expect(-6 % 3 == 0);
behavior tests cleanup: promote math.zig
2022-03-03 01:23:50 -07:00
var undef: i32 = undefined;
test: update behavior to silence 'var is never mutated' errors
2023-11-16 13:21:18 +00:00
_ = &undef;
behavior tests cleanup: promote math.zig
2022-03-03 01:23:50 -07:00
if (0 % undef != 0) {
@compileError("0 as numerator should return comptime zero independent of denominator");
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
}
}
test "quad hex float literal parsing accurate" {
behavior tests cleanup: promote math.zig
2022-03-03 01:23:50 -07:00
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
setup spirv backend in behavior tests
2023-05-11 09:23:34 +03:30
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
behavior tests cleanup: promote math.zig
2022-03-03 01:23:50 -07:00
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
const a: f128 = 0x1.1111222233334444555566667777p+0;
// implied 1 is dropped, with an exponent of 0 (0x3fff) after biasing.
const expected: u128 = 0x3fff1111222233334444555566667777;
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
try expect(@as(u128, @bitCast(a)) == expected);
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
// non-normalized
const b: f128 = 0x11.111222233334444555566667777p-4;
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
try expect(@as(u128, @bitCast(b)) == expected);
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
const S = struct {
fn doTheTest() !void {
{
var f: f128 = 0x1.2eab345678439abcdefea56782346p+5;
test: update behavior to silence 'var is never mutated' errors
2023-11-16 13:21:18 +00:00
_ = &f;
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
try expect(@as(u128, @bitCast(f)) == 0x40042eab345678439abcdefea5678234);
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
}
{
remove references to stage1 in behavior tests Good riddance.
2022-12-06 19:06:48 -07:00
var f: f128 = 0x1.edcb34a235253948765432134674fp-1;
test: update behavior to silence 'var is never mutated' errors
2023-11-16 13:21:18 +00:00
_ = &f;
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
try expect(@as(u128, @bitCast(f)) == 0x3ffeedcb34a235253948765432134675); // round-to-even
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
}
{
var f: f128 = 0x1.353e45674d89abacc3a2ebf3ff4ffp-50;
test: update behavior to silence 'var is never mutated' errors
2023-11-16 13:21:18 +00:00
_ = &f;
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
try expect(@as(u128, @bitCast(f)) == 0x3fcd353e45674d89abacc3a2ebf3ff50);
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
}
{
var f: f128 = 0x1.ed8764648369535adf4be3214567fp-9;
test: update behavior to silence 'var is never mutated' errors
2023-11-16 13:21:18 +00:00
_ = &f;
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
try expect(@as(u128, @bitCast(f)) == 0x3ff6ed8764648369535adf4be3214568);
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
}
const exp2ft = [_]f64{
0x1.6a09e667f3bcdp-1,
0x1.7a11473eb0187p-1,
0x1.8ace5422aa0dbp-1,
0x1.9c49182a3f090p-1,
0x1.ae89f995ad3adp-1,
0x1.c199bdd85529cp-1,
0x1.d5818dcfba487p-1,
0x1.ea4afa2a490dap-1,
0x1.0000000000000p+0,
0x1.0b5586cf9890fp+0,
0x1.172b83c7d517bp+0,
0x1.2387a6e756238p+0,
0x1.306fe0a31b715p+0,
0x1.3dea64c123422p+0,
0x1.4bfdad5362a27p+0,
0x1.5ab07dd485429p+0,
0x1.8p23,
0x1.62e430p-1,
0x1.ebfbe0p-3,
0x1.c6b348p-5,
0x1.3b2c9cp-7,
0x1.0p127,
-0x1.0p-149,
};
const answers = [_]u64{
0x3fe6a09e667f3bcd,
0x3fe7a11473eb0187,
0x3fe8ace5422aa0db,
0x3fe9c49182a3f090,
0x3feae89f995ad3ad,
0x3fec199bdd85529c,
0x3fed5818dcfba487,
0x3feea4afa2a490da,
0x3ff0000000000000,
0x3ff0b5586cf9890f,
0x3ff172b83c7d517b,
0x3ff2387a6e756238,
0x3ff306fe0a31b715,
0x3ff3dea64c123422,
0x3ff4bfdad5362a27,
0x3ff5ab07dd485429,
0x4168000000000000,
0x3fe62e4300000000,
0x3fcebfbe00000000,
0x3fac6b3480000000,
0x3f83b2c9c0000000,
0x47e0000000000000,
0xb6a0000000000000,
};
update existing behavior tests and std lib to new for loop semantics
2023-02-17 20:23:33 -07:00
for (exp2ft, 0..) |x, i| {
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
try expect(@as(u64, @bitCast(x)) == answers[i]);
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
}
}
};
try S.doTheTest();
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime S.doTheTest();
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
}
test "truncating shift left" {
try testShlTrunc(maxInt(u16));
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime testShlTrunc(maxInt(u16));
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
}
fn testShlTrunc(x: u16) !void {
const shifted = x << 1;
try expect(shifted == 65534);
}
test "exact shift left" {
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
try testShlExact(0b00110101);
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime testShlExact(0b00110101);
`@shlExact` fixups * Add clarification in langref * move test case to behavior tests
2024-01-04 00:44:44 -07:00
if (@shlExact(1, 1) != 2) @compileError("should be 2");
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
}
fn testShlExact(x: u8) !void {
const shifted = @shlExact(x, 2);
try expect(shifted == 0b11010100);
}
test "exact shift right" {
try testShrExact(0b10110100);
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime testShrExact(0b10110100);
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
}
fn testShrExact(x: u8) !void {
const shifted = @shrExact(x, 2);
try expect(shifted == 0b00101101);
}
test "shift left/right on u0 operand" {
const S = struct {
fn doTheTest() !void {
var x: u0 = 0;
var y: u0 = 0;
test: update behavior to silence 'var is never mutated' errors
2023-11-16 13:21:18 +00:00
_ = .{ &x, &y };
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
try expectEqual(@as(u0, 0), x << 0);
try expectEqual(@as(u0, 0), x >> 0);
try expectEqual(@as(u0, 0), x << y);
try expectEqual(@as(u0, 0), x >> y);
try expectEqual(@as(u0, 0), @shlExact(x, 0));
try expectEqual(@as(u0, 0), @shrExact(x, 0));
try expectEqual(@as(u0, 0), @shlExact(x, y));
try expectEqual(@as(u0, 0), @shrExact(x, y));
}
};
try S.doTheTest();
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime S.doTheTest();
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
}
test "comptime float rem int" {
comptime {
test: update behavior to silence 'var is never mutated' errors
2023-11-16 13:21:18 +00:00
const x = @as(f32, 1) % 2;
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
try expect(x == 1.0);
}
}
test "remainder division" {
enable newly passing behavior tests closes #11030
2022-04-27 17:24:36 -07:00
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
stage2: sparc64: Skip compile-failing tests for now
2022-07-10 16:42:51 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
setup spirv backend in behavior tests
2023-05-11 09:23:34 +03:30
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
x86_64+macho: pass more behavior tests
2024-01-29 15:33:45 +01:00
if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
std.Target: Replace isARM() with isArmOrThumb() and rename it to isArm(). The old isARM() function was a portability trap. With the name it had, it seemed like the obviously correct function to use, but it didn't include Thumb. In the vast majority of cases where someone wants to ask "is the target Arm?", Thumb *should* be included. There are exactly 3 cases in the codebase where we do actually need to exclude Thumb, although one of those is in Aro and mirrors a check in Clang that is itself likely a bug. These rare cases can just add an extra isThumb() check.
2024-10-03 08:34:19 +02:00
if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArm()) return error.SkipZigTest;
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
disable failing CBE behavior tests failing on aarch64-windows Also start to move redundant tests next to each other to make them slightly more obvious that they need to be cleaned up. See tracking issue #13876
2022-12-10 13:44:12 -07:00
if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) {
// https://github.com/ziglang/zig/issues/12602
return error.SkipZigTest;
}
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime remdiv(f16);
try comptime remdiv(f32);
try comptime remdiv(f64);
try comptime remdiv(f80);
try comptime remdiv(f128);
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
try remdiv(f16);
x86_64: implement `@rem` for floats
2023-10-08 03:27:12 -04:00
try remdiv(f32);
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
try remdiv(f64);
enable newly passing behavior tests closes #11030
2022-04-27 17:24:36 -07:00
try remdiv(f80);
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
try remdiv(f128);
}
fn remdiv(comptime T: type) !void {
try expect(@as(T, 1) == @as(T, 1) % @as(T, 2));
enable newly passing behavior tests closes #11030
2022-04-27 17:24:36 -07:00
try remdivOne(T, 1, 1, 2);
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
try expect(@as(T, 1) == @as(T, 7) % @as(T, 3));
enable newly passing behavior tests closes #11030
2022-04-27 17:24:36 -07:00
try remdivOne(T, 1, 7, 3);
}
fn remdivOne(comptime T: type, a: T, b: T, c: T) !void {
try expect(a == @rem(b, c));
try expect(a == @mod(b, c));
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
}
Implement f128 `@rem`
2022-02-13 14:37:38 +01:00
test "float remainder division using @rem" {
enable newly passing behavior tests closes #11030
2022-04-27 17:24:36 -07:00
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
stage2: sparc64: Skip compile-failing tests for now
2022-07-10 16:42:51 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
setup spirv backend in behavior tests
2023-05-11 09:23:34 +03:30
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
x86_64+macho: pass more behavior tests
2024-01-29 15:33:45 +01:00
if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
behavior tests cleanup: promote math.zig
2022-03-03 01:23:50 -07:00
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime frem(f16);
try comptime frem(f32);
try comptime frem(f64);
try comptime frem(f80);
try comptime frem(f128);
Implement f128 `@rem`
2022-02-13 14:37:38 +01:00
try frem(f16);
try frem(f32);
try frem(f64);
enable newly passing behavior tests closes #11030
2022-04-27 17:24:36 -07:00
try frem(f80);
Implement f128 `@rem`
2022-02-13 14:37:38 +01:00
try frem(f128);
}
fn frem(comptime T: type) !void {
const epsilon = switch (T) {
f16 => 1.0,
f32 => 0.001,
f64 => 0.00001,
enable newly passing behavior tests closes #11030
2022-04-27 17:24:36 -07:00
f80 => 0.000001,
Implement f128 `@rem`
2022-02-13 14:37:38 +01:00
f128 => 0.0000001,
else => unreachable,
};
enable newly passing behavior tests closes #11030
2022-04-27 17:24:36 -07:00
try fremOne(T, 6.9, 4.0, 2.9, epsilon);
try fremOne(T, -6.9, 4.0, -2.9, epsilon);
try fremOne(T, -5.0, 3.0, -2.0, epsilon);
try fremOne(T, 3.0, 2.0, 1.0, epsilon);
try fremOne(T, 1.0, 2.0, 1.0, epsilon);
try fremOne(T, 0.0, 1.0, 0.0, epsilon);
try fremOne(T, -0.0, 1.0, -0.0, epsilon);
}
fn fremOne(comptime T: type, a: T, b: T, c: T, epsilon: T) !void {
Replace `@fabs` with `@abs` in behavior tests
2023-07-18 01:51:37 +02:00
try expect(@abs(@rem(a, b) - c) < epsilon);
Implement f128 `@rem`
2022-02-13 14:37:38 +01:00
}
test "float modulo division using @mod" {
enable newly passing behavior tests closes #11030
2022-04-27 17:24:36 -07:00
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
setup spirv backend in behavior tests
2023-05-11 09:23:34 +03:30
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
x86_64+macho: pass more behavior tests
2024-01-29 15:33:45 +01:00
if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
behavior tests cleanup: promote math.zig
2022-03-03 01:23:50 -07:00
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime fmod(f16);
try comptime fmod(f32);
try comptime fmod(f64);
try comptime fmod(f80);
try comptime fmod(f128);
Implement f128 `@rem`
2022-02-13 14:37:38 +01:00
try fmod(f16);
try fmod(f32);
try fmod(f64);
enable newly passing behavior tests closes #11030
2022-04-27 17:24:36 -07:00
try fmod(f80);
Implement f128 `@rem`
2022-02-13 14:37:38 +01:00
try fmod(f128);
}
fn fmod(comptime T: type) !void {
const epsilon = switch (T) {
f16 => 1.0,
f32 => 0.001,
f64 => 0.00001,
enable newly passing behavior tests closes #11030
2022-04-27 17:24:36 -07:00
f80 => 0.000001,
Implement f128 `@rem`
2022-02-13 14:37:38 +01:00
f128 => 0.0000001,
else => unreachable,
};
enable newly passing behavior tests closes #11030
2022-04-27 17:24:36 -07:00
try fmodOne(T, 6.9, 4.0, 2.9, epsilon);
try fmodOne(T, -6.9, 4.0, 1.1, epsilon);
try fmodOne(T, -5.0, 3.0, 1.0, epsilon);
try fmodOne(T, 3.0, 2.0, 1.0, epsilon);
try fmodOne(T, 1.0, 2.0, 1.0, epsilon);
try fmodOne(T, 0.0, 1.0, 0.0, epsilon);
try fmodOne(T, -0.0, 1.0, -0.0, epsilon);
}
fn fmodOne(comptime T: type, a: T, b: T, c: T, epsilon: T) !void {
Replace `@fabs` with `@abs` in behavior tests
2023-07-18 01:51:37 +02:00
try expect(@abs(@mod(@as(T, a), @as(T, b)) - @as(T, c)) < epsilon);
Implement f128 `@rem`
2022-02-13 14:37:38 +01:00
}
x86_64: implement and test unary float builtins
2023-09-23 06:21:03 -04:00
test "@round f16" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
x86_64+macho: pass more behavior tests
2024-01-29 15:33:45 +01:00
if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
x86_64: implement and test unary float builtins
2023-09-23 06:21:03 -04:00
try testRound(f16, 12.0);
try comptime testRound(f16, 12.0);
}
test "@round f32/f64" {
enable newly passing behavior tests closes #11030
2022-04-27 17:24:36 -07:00
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
x86_64+macho: pass more behavior tests
2024-01-29 15:33:45 +01:00
if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
try testRound(f64, 12.0);
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime testRound(f64, 12.0);
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
try testRound(f32, 12.0);
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime testRound(f32, 12.0);
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
const x = 14.0;
const y = x + 0.4;
const z = @round(y);
test/behavior: replace all 'comptime expect' with 'comptime assert'
2024-01-15 16:01:13 +11:00
comptime assert(x == z);
Sema: improve lowering of stores to bitcasted vector pointers Detect if we are storing an array operand to a bitcasted vector pointer. If so, we instead reach through the bitcasted pointer to the vector pointer, bitcast the array operand to a vector, and then lower this as a store of a vector value to a vector pointer. This generally results in better code, as well as working around an LLVM bug. See #11154
2022-03-14 00:10:35 -07:00
}
test "@round f80" {
enable newly passing behavior tests closes #11030
2022-04-27 17:24:36 -07:00
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
setup spirv backend in behavior tests
2023-05-11 09:23:34 +03:30
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
std.Target: Replace isARM() with isArmOrThumb() and rename it to isArm(). The old isARM() function was a portability trap. With the name it had, it seemed like the obviously correct function to use, but it didn't include Thumb. In the vast majority of cases where someone wants to ask "is the target Arm?", Thumb *should* be included. There are exactly 3 cases in the codebase where we do actually need to exclude Thumb, although one of those is in Aro and mirrors a check in Clang that is itself likely a bug. These rare cases can just add an extra isThumb() check.
2024-10-03 08:34:19 +02:00
if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArm()) return error.SkipZigTest;
x86_64+macho: pass more behavior tests
2024-01-29 15:33:45 +01:00
if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
Sema: improve lowering of stores to bitcasted vector pointers Detect if we are storing an array operand to a bitcasted vector pointer. If so, we instead reach through the bitcasted pointer to the vector pointer, bitcast the array operand to a vector, and then lower this as a store of a vector value to a vector pointer. This generally results in better code, as well as working around an LLVM bug. See #11154
2022-03-14 00:10:35 -07:00
try testRound(f80, 12.0);
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime testRound(f80, 12.0);
Sema: improve lowering of stores to bitcasted vector pointers Detect if we are storing an array operand to a bitcasted vector pointer. If so, we instead reach through the bitcasted pointer to the vector pointer, bitcast the array operand to a vector, and then lower this as a store of a vector value to a vector pointer. This generally results in better code, as well as working around an LLVM bug. See #11154
2022-03-14 00:10:35 -07:00
}
test "@round f128" {
enable newly passing behavior tests closes #11030
2022-04-27 17:24:36 -07:00
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
setup spirv backend in behavior tests
2023-05-11 09:23:34 +03:30
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
std.Target: Replace isARM() with isArmOrThumb() and rename it to isArm(). The old isARM() function was a portability trap. With the name it had, it seemed like the obviously correct function to use, but it didn't include Thumb. In the vast majority of cases where someone wants to ask "is the target Arm?", Thumb *should* be included. There are exactly 3 cases in the codebase where we do actually need to exclude Thumb, although one of those is in Aro and mirrors a check in Clang that is itself likely a bug. These rare cases can just add an extra isThumb() check.
2024-10-03 08:34:19 +02:00
if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArm()) return error.SkipZigTest;
x86_64+macho: pass more behavior tests
2024-01-29 15:33:45 +01:00
if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
Sema: improve lowering of stores to bitcasted vector pointers Detect if we are storing an array operand to a bitcasted vector pointer. If so, we instead reach through the bitcasted pointer to the vector pointer, bitcast the array operand to a vector, and then lower this as a store of a vector value to a vector pointer. This generally results in better code, as well as working around an LLVM bug. See #11154
2022-03-14 00:10:35 -07:00
enable newly passing behavior tests closes #11030
2022-04-27 17:24:36 -07:00
try testRound(f128, 12.0);
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime testRound(f128, 12.0);
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
}
fn testRound(comptime T: type, x: T) !void {
const y = x - 0.5;
const z = @round(y);
Sema: improve lowering of stores to bitcasted vector pointers Detect if we are storing an array operand to a bitcasted vector pointer. If so, we instead reach through the bitcasted pointer to the vector pointer, bitcast the array operand to a vector, and then lower this as a store of a vector value to a vector pointer. This generally results in better code, as well as working around an LLVM bug. See #11154
2022-03-14 00:10:35 -07:00
try expect(x == z);
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
}
test "vector integer addition" {
stage2: enable some passing array & vector tests
2022-03-23 08:49:16 -07:00
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
const S = struct {
fn doTheTest() !void {
replace other uses of `std.meta.Vector` with `@Vector` (#11346)
2022-03-30 11:12:14 -07:00
var a: @Vector(4, i32) = [_]i32{ 1, 2, 3, 4 };
var b: @Vector(4, i32) = [_]i32{ 5, 6, 7, 8 };
test: update behavior to silence 'var is never mutated' errors
2023-11-16 13:21:18 +00:00
_ = .{ &a, &b };
const result = a + b;
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
var result_array: [4]i32 = result;
const expected = [_]i32{ 6, 8, 10, 12 };
try expectEqualSlices(i32, &expected, &result_array);
}
};
try S.doTheTest();
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime S.doTheTest();
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
}
test "NaN comparison" {
behavior tests cleanup: promote math.zig
2022-03-03 01:23:50 -07:00
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
setup spirv backend in behavior tests
2023-05-11 09:23:34 +03:30
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
x86_64+macho: pass more behavior tests
2024-01-29 15:33:45 +01:00
if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
std.Target: Replace isARM() with isArmOrThumb() and rename it to isArm(). The old isARM() function was a portability trap. With the name it had, it seemed like the obviously correct function to use, but it didn't include Thumb. In the vast majority of cases where someone wants to ask "is the target Arm?", Thumb *should* be included. There are exactly 3 cases in the codebase where we do actually need to exclude Thumb, although one of those is in Aro and mirrors a check in Clang that is itself likely a bug. These rare cases can just add an extra isThumb() check.
2024-10-03 08:34:19 +02:00
if (builtin.cpu.arch.isArm() and builtin.target.floatAbi() == .soft) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21234
behavior tests cleanup: promote math.zig
2022-03-03 01:23:50 -07:00
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
try testNanEqNan(f16);
try testNanEqNan(f32);
try testNanEqNan(f64);
try testNanEqNan(f128);
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime testNanEqNan(f16);
try comptime testNanEqNan(f32);
try comptime testNanEqNan(f64);
try comptime testNanEqNan(f128);
Sema: improve lowering of stores to bitcasted vector pointers Detect if we are storing an array operand to a bitcasted vector pointer. If so, we instead reach through the bitcasted pointer to the vector pointer, bitcast the array operand to a vector, and then lower this as a store of a vector value to a vector pointer. This generally results in better code, as well as working around an LLVM bug. See #11154
2022-03-14 00:10:35 -07:00
}
disable NaN f80 behavior tests Let's get all these other bug fixes in and figure out f80 NaN later. Looks like it's not working at comptime in master branch anyway.
2022-02-11 01:27:00 -07:00
Sema: improve lowering of stores to bitcasted vector pointers Detect if we are storing an array operand to a bitcasted vector pointer. If so, we instead reach through the bitcasted pointer to the vector pointer, bitcast the array operand to a vector, and then lower this as a store of a vector value to a vector pointer. This generally results in better code, as well as working around an LLVM bug. See #11154
2022-03-14 00:10:35 -07:00
test "NaN comparison f80" {
enable newly passing behavior tests closes #11030
2022-04-27 17:24:36 -07:00
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
setup spirv backend in behavior tests
2023-05-11 09:23:34 +03:30
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
x86_64+macho: pass more behavior tests
2024-01-29 15:33:45 +01:00
if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
enable newly passing behavior tests closes #11030
2022-04-27 17:24:36 -07:00
Sema: improve lowering of stores to bitcasted vector pointers Detect if we are storing an array operand to a bitcasted vector pointer. If so, we instead reach through the bitcasted pointer to the vector pointer, bitcast the array operand to a vector, and then lower this as a store of a vector value to a vector pointer. This generally results in better code, as well as working around an LLVM bug. See #11154
2022-03-14 00:10:35 -07:00
try testNanEqNan(f80);
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime testNanEqNan(f80);
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
}
fn testNanEqNan(comptime F: type) !void {
compiler-rt: math functions reorg * unify the logic for exporting math functions from compiler-rt, with the appropriate suffixes and prefixes. - add all missing f128 and f80 exports. Functions with missing implementations call other functions and have TODO comments. - also add f16 functions * move math functions from freestanding libc to compiler-rt (#7265) * enable all the f128 and f80 code in the stage2 compiler and behavior tests (#11161). * update std lib to use builtins rather than `std.math`.
2022-04-26 10:13:55 -07:00
var nan1 = math.nan(F);
var nan2 = math.nan(F);
test: update behavior to silence 'var is never mutated' errors
2023-11-16 13:21:18 +00:00
_ = .{ &nan1, &nan2 };
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
try expect(nan1 != nan2);
try expect(!(nan1 == nan2));
try expect(!(nan1 > nan2));
try expect(!(nan1 >= nan2));
try expect(!(nan1 < nan2));
try expect(!(nan1 <= nan2));
}
test "vector comparison" {
stage2: enable some passing array & vector tests
2022-03-23 08:49:16 -07:00
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
x86_64: fix vector comparisions
2023-12-04 13:07:33 -05:00
if (builtin.zig_backend == .stage2_x86_64 and
!comptime std.Target.x86.featureSetHas(builtin.cpu.features, .avx2)) return error.SkipZigTest;
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
const S = struct {
fn doTheTest() !void {
replace other uses of `std.meta.Vector` with `@Vector` (#11346)
2022-03-30 11:12:14 -07:00
var a: @Vector(6, i32) = [_]i32{ 1, 3, -1, 5, 7, 9 };
var b: @Vector(6, i32) = [_]i32{ -1, 3, 0, 6, 10, -10 };
test: update behavior to silence 'var is never mutated' errors
2023-11-16 13:21:18 +00:00
_ = .{ &a, &b };
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
try expect(mem.eql(bool, &@as([6]bool, a < b), &[_]bool{ false, false, true, true, true, false }));
try expect(mem.eql(bool, &@as([6]bool, a <= b), &[_]bool{ false, true, true, true, true, false }));
try expect(mem.eql(bool, &@as([6]bool, a == b), &[_]bool{ false, true, false, false, false, false }));
try expect(mem.eql(bool, &@as([6]bool, a != b), &[_]bool{ true, false, true, true, true, true }));
try expect(mem.eql(bool, &@as([6]bool, a > b), &[_]bool{ true, false, false, false, false, true }));
try expect(mem.eql(bool, &@as([6]bool, a >= b), &[_]bool{ true, true, false, false, false, true }));
}
};
try S.doTheTest();
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime S.doTheTest();
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
}
test "compare undefined literal with comptime_int" {
var x = undefined == 1;
// x is now undefined with type bool
x = true;
try expect(x);
}
test "signed zeros are represented properly" {
Sema: comptime float negation supports negative zero When handling the `negate` ZIR instruction, Zig now checks for a comptime operand and handles it as a special case rather than lowering it as `0 - x` so that the expression `-x` where `x` is a floating point value known at compile-time, will get the negative zero bitwise representation.
2022-05-10 21:46:24 -07:00
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
setup spirv backend in behavior tests
2023-05-11 09:23:34 +03:30
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
const S = struct {
fn doTheTest() !void {
Sema: comptime float negation supports negative zero When handling the `negate` ZIR instruction, Zig now checks for a comptime operand and handles it as a special case rather than lowering it as `0 - x` so that the expression `-x` where `x` is a floating point value known at compile-time, will get the negative zero bitwise representation.
2022-05-10 21:46:24 -07:00
try testOne(f16);
try testOne(f32);
try testOne(f64);
re-enable "signed zeros are represented properly" beahvior tests for f80 and c_longdouble
2022-12-12 03:01:11 -08:00
try testOne(f80);
Sema: comptime float negation supports negative zero When handling the `negate` ZIR instruction, Zig now checks for a comptime operand and handles it as a special case rather than lowering it as `0 - x` so that the expression `-x` where `x` is a floating point value known at compile-time, will get the negative zero bitwise representation.
2022-05-10 21:46:24 -07:00
try testOne(f128);
re-enable "signed zeros are represented properly" beahvior tests for f80 and c_longdouble
2022-12-12 03:01:11 -08:00
try testOne(c_longdouble);
Sema: comptime float negation supports negative zero When handling the `negate` ZIR instruction, Zig now checks for a comptime operand and handles it as a special case rather than lowering it as `0 - x` so that the expression `-x` where `x` is a floating point value known at compile-time, will get the negative zero bitwise representation.
2022-05-10 21:46:24 -07:00
}
fn testOne(comptime T: type) !void {
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
const ST = std.meta.Int(.unsigned, @typeInfo(T).float.bits);
Sema: comptime float negation supports negative zero When handling the `negate` ZIR instruction, Zig now checks for a comptime operand and handles it as a special case rather than lowering it as `0 - x` so that the expression `-x` where `x` is a floating point value known at compile-time, will get the negative zero bitwise representation.
2022-05-10 21:46:24 -07:00
var as_fp_val = -@as(T, 0.0);
test: update behavior to silence 'var is never mutated' errors
2023-11-16 13:21:18 +00:00
_ = &as_fp_val;
const as_uint_val: ST = @bitCast(as_fp_val);
Sema: comptime float negation supports negative zero When handling the `negate` ZIR instruction, Zig now checks for a comptime operand and handles it as a special case rather than lowering it as `0 - x` so that the expression `-x` where `x` is a floating point value known at compile-time, will get the negative zero bitwise representation.
2022-05-10 21:46:24 -07:00
// Ensure the sign bit is set.
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
try expect(as_uint_val >> (@typeInfo(T).float.bits - 1) == 1);
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
}
};
try S.doTheTest();
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime S.doTheTest();
Sema: improved comptime `%` syntax * comptime known 0 as a numerator returns comptime 0 independent of denominator. * negative numerator and denominator are allowed when the remainder is zero because that means the modulus would be also zero. * organize math behavior tests
2022-01-29 14:25:43 -07:00
}
compiler-rt: math functions reorg * unify the logic for exporting math functions from compiler-rt, with the appropriate suffixes and prefixes. - add all missing f128 and f80 exports. Functions with missing implementations call other functions and have TODO comments. - also add f16 functions * move math functions from freestanding libc to compiler-rt (#7265) * enable all the f128 and f80 code in the stage2 compiler and behavior tests (#11161). * update std lib to use builtins rather than `std.math`.
2022-04-26 10:13:55 -07:00
test "absFloat" {
disable failing behavior tests
2022-04-27 14:29:59 -07:00
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
disable failing behavior tests
2022-04-27 14:29:59 -07:00
compiler-rt: math functions reorg * unify the logic for exporting math functions from compiler-rt, with the appropriate suffixes and prefixes. - add all missing f128 and f80 exports. Functions with missing implementations call other functions and have TODO comments. - also add f16 functions * move math functions from freestanding libc to compiler-rt (#7265) * enable all the f128 and f80 code in the stage2 compiler and behavior tests (#11161). * update std lib to use builtins rather than `std.math`.
2022-04-26 10:13:55 -07:00
try testAbsFloat();
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime testAbsFloat();
compiler-rt: math functions reorg * unify the logic for exporting math functions from compiler-rt, with the appropriate suffixes and prefixes. - add all missing f128 and f80 exports. Functions with missing implementations call other functions and have TODO comments. - also add f16 functions * move math functions from freestanding libc to compiler-rt (#7265) * enable all the f128 and f80 code in the stage2 compiler and behavior tests (#11161). * update std lib to use builtins rather than `std.math`.
2022-04-26 10:13:55 -07:00
}
fn testAbsFloat() !void {
disable failing behavior tests
2022-04-27 14:29:59 -07:00
try testAbsFloatOne(-10.05, 10.05);
try testAbsFloatOne(10.05, 10.05);
}
fn testAbsFloatOne(in: f32, out: f32) !void {
Replace `@fabs` with `@abs` in behavior tests
2023-07-18 01:51:37 +02:00
try expect(@abs(@as(f32, in)) == @as(f32, out));
compiler-rt: math functions reorg * unify the logic for exporting math functions from compiler-rt, with the appropriate suffixes and prefixes. - add all missing f128 and f80 exports. Functions with missing implementations call other functions and have TODO comments. - also add f16 functions * move math functions from freestanding libc to compiler-rt (#7265) * enable all the f128 and f80 code in the stage2 compiler and behavior tests (#11161). * update std lib to use builtins rather than `std.math`.
2022-04-26 10:13:55 -07:00
}
stage2: Handle lazy values for the % operator
2022-08-10 13:21:47 +02:00
test "mod lazy values" {
{
const X = struct { x: u32 };
const x = @sizeOf(X);
const y = 1 % x;
_ = y;
}
{
const X = struct { x: u32 };
const x = @sizeOf(X);
const y = x % 1;
_ = y;
}
}
categorize `behavior/bugs/<issueno>.zig` tests
2024-01-02 17:33:41 +02:00
test "@clz works on both vector and scalar inputs" {
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
categorize `behavior/bugs/<issueno>.zig` tests
2024-01-02 17:33:41 +02:00
var x: u32 = 0x1;
_ = &x;
var y: @Vector(4, u32) = [_]u32{ 0x1, 0x1, 0x1, 0x1 };
_ = &y;
const a = @clz(x);
const b = @clz(y);
try std.testing.expectEqual(@as(u6, 31), a);
try std.testing.expectEqual([_]u6{ 31, 31, 31, 31 }, b);
}
Sema: clean up cmpNumeric There is one minor language change here, which is that comparisons of the form `comptime_inf < runtime_f32` have their results comptime-known. This is consistent with comparisons against comptime NaN for instance, which are always comptime known. A corresponding behavior test is added. This fixes a bug with int comparison elision which my previous commit somehow triggered. `Sema.compareIntsOnlyPossibleResult` is much cleaner now!
2024-09-17 11:00:38 +01:00
test "runtime comparison to NaN is comptime-known" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
std.Target: Replace isARM() with isArmOrThumb() and rename it to isArm(). The old isARM() function was a portability trap. With the name it had, it seemed like the obviously correct function to use, but it didn't include Thumb. In the vast majority of cases where someone wants to ask "is the target Arm?", Thumb *should* be included. There are exactly 3 cases in the codebase where we do actually need to exclude Thumb, although one of those is in Aro and mirrors a check in Clang that is itself likely a bug. These rare cases can just add an extra isThumb() check.
2024-10-03 08:34:19 +02:00
if (builtin.cpu.arch.isArm() and builtin.target.floatAbi() == .soft) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21234
Sema: clean up cmpNumeric There is one minor language change here, which is that comparisons of the form `comptime_inf < runtime_f32` have their results comptime-known. This is consistent with comparisons against comptime NaN for instance, which are always comptime known. A corresponding behavior test is added. This fixes a bug with int comparison elision which my previous commit somehow triggered. `Sema.compareIntsOnlyPossibleResult` is much cleaner now!
2024-09-17 11:00:38 +01:00
const S = struct {
fn doTheTest(comptime F: type, x: F) void {
const nan = math.nan(F);
if (!(nan != x)) comptime unreachable;
if (nan == x) comptime unreachable;
if (nan > x) comptime unreachable;
if (nan < x) comptime unreachable;
if (nan >= x) comptime unreachable;
if (nan <= x) comptime unreachable;
}
};
S.doTheTest(f16, 123.0);
S.doTheTest(f32, 123.0);
S.doTheTest(f64, 123.0);
S.doTheTest(f128, 123.0);
comptime S.doTheTest(f16, 123.0);
comptime S.doTheTest(f32, 123.0);
comptime S.doTheTest(f64, 123.0);
comptime S.doTheTest(f128, 123.0);
}
test "runtime int comparison to inf is comptime-known" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
std.Target: Replace isARM() with isArmOrThumb() and rename it to isArm(). The old isARM() function was a portability trap. With the name it had, it seemed like the obviously correct function to use, but it didn't include Thumb. In the vast majority of cases where someone wants to ask "is the target Arm?", Thumb *should* be included. There are exactly 3 cases in the codebase where we do actually need to exclude Thumb, although one of those is in Aro and mirrors a check in Clang that is itself likely a bug. These rare cases can just add an extra isThumb() check.
2024-10-03 08:34:19 +02:00
if (builtin.cpu.arch.isArm() and builtin.target.floatAbi() == .soft) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21234
Sema: clean up cmpNumeric There is one minor language change here, which is that comparisons of the form `comptime_inf < runtime_f32` have their results comptime-known. This is consistent with comparisons against comptime NaN for instance, which are always comptime known. A corresponding behavior test is added. This fixes a bug with int comparison elision which my previous commit somehow triggered. `Sema.compareIntsOnlyPossibleResult` is much cleaner now!
2024-09-17 11:00:38 +01:00
const S = struct {
fn doTheTest(comptime F: type, x: u32) void {
const inf = math.inf(F);
if (!(inf != x)) comptime unreachable;
if (inf == x) comptime unreachable;
if (x > inf) comptime unreachable;
if (x >= inf) comptime unreachable;
if (!(x < inf)) comptime unreachable;
if (!(x <= inf)) comptime unreachable;
}
};
S.doTheTest(f16, 123);
S.doTheTest(f32, 123);
S.doTheTest(f64, 123);
S.doTheTest(f128, 123);
comptime S.doTheTest(f16, 123);
comptime S.doTheTest(f32, 123);
comptime S.doTheTest(f64, 123);
comptime S.doTheTest(f128, 123);
}
Reference in New Issue Copy Permalink