mirror/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2026-02-13 21:08:36 +00:00
Code Issues Packages Projects Releases Wiki Activity

cbe: enable CI for std tests

Browse Source
This commit is contained in:
Jacob Young 2023-04-18 20:18:23 -04:00
parent 528b66f6ec
commit bf6fd9ae3f
17 changed files with 705 additions and 489 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/std/bit_set.zig
View File

@ -1635,6 +1635,8 @@ fn testStaticBitSet(comptime Set: type) !void {
}
test "IntegerBitSet" {
if (@import("builtin").zig_backend == .stage2_c) return error.SkipZigTest;
try testStaticBitSet(IntegerBitSet(0));
try testStaticBitSet(IntegerBitSet(1));
try testStaticBitSet(IntegerBitSet(2));

3
lib/std/crypto/aes.zig
View File

@ -5,7 +5,8 @@ const testing = std.testing;
const has_aesni = std.Target.x86.featureSetHas(builtin.cpu.features, .aes);
const has_avx = std.Target.x86.featureSetHas(builtin.cpu.features, .avx);
const has_armaes = std.Target.aarch64.featureSetHas(builtin.cpu.features, .aes);
const impl = if (builtin.cpu.arch == .x86_64 and has_aesni and has_avx) impl: {
// C backend doesn't currently support passing vectors to inline asm.
const impl = if (builtin.cpu.arch == .x86_64 and builtin.zig_backend != .stage2_c and has_aesni and has_avx) impl: {
break :impl @import("aes/aesni.zig");
} else if (builtin.cpu.arch == .aarch64 and has_armaes)
impl: {

8
lib/std/crypto/aes_ocb.zig
View File

@ -257,6 +257,8 @@ inline fn xorWith(x: *Block, y: Block) void {
const hexToBytes = std.fmt.hexToBytes;
test "AesOcb test vector 1" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
var k: [Aes128Ocb.key_length]u8 = undefined;
var nonce: [Aes128Ocb.nonce_length]u8 = undefined;
var tag: [Aes128Ocb.tag_length]u8 = undefined;
@ -274,6 +276,8 @@ test "AesOcb test vector 1" {
}
test "AesOcb test vector 2" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
var k: [Aes128Ocb.key_length]u8 = undefined;
var nonce: [Aes128Ocb.nonce_length]u8 = undefined;
var tag: [Aes128Ocb.tag_length]u8 = undefined;
@ -293,6 +297,8 @@ test "AesOcb test vector 2" {
}
test "AesOcb test vector 3" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
var k: [Aes128Ocb.key_length]u8 = undefined;
var nonce: [Aes128Ocb.nonce_length]u8 = undefined;
var tag: [Aes128Ocb.tag_length]u8 = undefined;
@ -315,6 +321,8 @@ test "AesOcb test vector 3" {
}
test "AesOcb test vector 4" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
var k: [Aes128Ocb.key_length]u8 = undefined;
var nonce: [Aes128Ocb.nonce_length]u8 = undefined;
var tag: [Aes128Ocb.tag_length]u8 = undefined;

13
lib/std/crypto/ecdsa.zig
View File

@ -1,3 +1,4 @@
const builtin = @import("builtin");
const std = @import("std");
const crypto = std.crypto;
const fmt = std.fmt;
@ -373,6 +374,8 @@ pub fn Ecdsa(comptime Curve: type, comptime Hash: type) type {
}
test "ECDSA - Basic operations over EcdsaP384Sha384" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
const Scheme = EcdsaP384Sha384;
const kp = try Scheme.KeyPair.create(null);
const msg = "test";
@ -387,6 +390,8 @@ test "ECDSA - Basic operations over EcdsaP384Sha384" {
}
test "ECDSA - Basic operations over Secp256k1" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
const Scheme = EcdsaSecp256k1Sha256oSha256;
const kp = try Scheme.KeyPair.create(null);
const msg = "test";
@ -401,6 +406,8 @@ test "ECDSA - Basic operations over Secp256k1" {
}
test "ECDSA - Basic operations over EcdsaP384Sha256" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
const Scheme = Ecdsa(crypto.ecc.P384, crypto.hash.sha2.Sha256);
const kp = try Scheme.KeyPair.create(null);
const msg = "test";
@ -415,6 +422,8 @@ test "ECDSA - Basic operations over EcdsaP384Sha256" {
}
test "ECDSA - Verifying a existing signature with EcdsaP384Sha256" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
const Scheme = Ecdsa(crypto.ecc.P384, crypto.hash.sha2.Sha256);
// zig fmt: off
const sk_bytes = [_]u8{
@ -457,6 +466,8 @@ const TestVector = struct {
};
test "ECDSA - Test vectors from Project Wycheproof" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
const vectors = [_]TestVector{
.{ .key = "042927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e", .msg = "313233343030", .sig = "304402202ba3a8be6b94d5ec80a6d9d1190a436effe50d85a1eee859b8cc6af9bd5c2e1802204cd60b855d442f5b3c7b11eb6c4e0ae7525fe710fab9aa7c77a67f79e6fadd76", .result = .valid },
.{ .key = "042927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e", .msg = "313233343030", .sig = "304402202ba3a8be6b94d5ec80a6d9d1190a436effe50d85a1eee859b8cc6af9bd5c2e180220b329f479a2bbd0a5c384ee1493b1f5186a87139cac5df4087c134b49156847db", .result = .acceptable },
@ -869,6 +880,8 @@ fn tvTry(vector: TestVector) !void {
}
test "ECDSA - Sec1 encoding/decoding" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
const Scheme = EcdsaP384Sha384;
const kp = try Scheme.KeyPair.create(null);
const pk = kp.public_key;

3
lib/std/crypto/ghash_polyval.zig
View File

@ -248,7 +248,8 @@ fn Hash(comptime endian: std.builtin.Endian, comptime shift_key: bool) type {
const has_pclmul = std.Target.x86.featureSetHas(builtin.cpu.features, .pclmul);
const has_avx = std.Target.x86.featureSetHas(builtin.cpu.features, .avx);
const has_armaes = std.Target.aarch64.featureSetHas(builtin.cpu.features, .aes);
const clmul = if (builtin.cpu.arch == .x86_64 and has_pclmul and has_avx) impl: {
// C backend doesn't currently support passing vectors to inline asm.
const clmul = if (builtin.cpu.arch == .x86_64 and builtin.zig_backend != .stage2_c and has_pclmul and has_avx) impl: {
break :impl clmulPclmul;
} else if (builtin.cpu.arch == .aarch64 and has_armaes) impl: {
break :impl clmulPmull;

2
lib/std/crypto/pcurves/p384.zig
View File

@ -474,5 +474,7 @@ pub const AffineCoordinates = struct {
};
test "p384" {
if (@import("builtin").zig_backend == .stage2_c) return error.SkipZigTest;
_ = @import("tests/p384.zig");
}

2
lib/std/crypto/pcurves/secp256k1.zig
View File

@ -552,5 +552,7 @@ pub const AffineCoordinates = struct {
};
test "secp256k1" {
if (@import("builtin").zig_backend == .stage2_c) return error.SkipZigTest;
_ = @import("tests/secp256k1.zig");
}

3
lib/std/crypto/sha2.zig
View File

@ -242,7 +242,8 @@ fn Sha2x32(comptime params: Sha2Params32) type {
d.s[4..8].* = y +% @as(v4u32, d.s[4..8].*);
return;
},
.x86_64 => if (comptime std.Target.x86.featureSetHas(builtin.cpu.features, .sha)) {
// C backend doesn't currently support passing vectors to inline asm.
.x86_64 => if (builtin.zig_backend != .stage2_c and comptime std.Target.x86.featureSetHas(builtin.cpu.features, .sha)) {
var x: v4u32 = [_]u32{ d.s[5], d.s[4], d.s[1], d.s[0] };
var y: v4u32 = [_]u32{ d.s[7], d.s[6], d.s[3], d.s[2] };
const s_v = @ptrCast(*[16]v4u32, &s);

2
lib/std/debug.zig
View File

@ -2189,6 +2189,8 @@ pub fn dumpStackPointerAddr(prefix: []const u8) void {
}
test "manage resources correctly" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // error.UnsupportedBackend
if (builtin.os.tag == .wasi) return error.SkipZigTest;
if (builtin.os.tag == .windows and builtin.cpu.arch == .x86_64) {

26
lib/std/math/big/int_test.zig
View File

@ -915,6 +915,8 @@ test "big.int mul multi-single" {
}
test "big.int mul multi-multi" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
var op1: u256 = 0x998888efefefefefefefef;
var op2: u256 = 0x333000abababababababab;
var a = try Managed.initSet(testing.allocator, op1);
@ -1034,6 +1036,8 @@ test "big.int mulWrap single-single signed" {
}
test "big.int mulWrap multi-multi unsigned" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
var op1: u256 = 0x998888efefefefefefefef;
var op2: u256 = 0x333000abababababababab;
var a = try Managed.initSet(testing.allocator, op1);
@ -1049,6 +1053,8 @@ test "big.int mulWrap multi-multi unsigned" {
}
test "big.int mulWrap multi-multi signed" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
var a = try Managed.initSet(testing.allocator, maxInt(SignedDoubleLimb) - 1);
defer a.deinit();
var b = try Managed.initSet(testing.allocator, maxInt(SignedDoubleLimb));
@ -1252,6 +1258,8 @@ test "big.int div q=0 alias" {
}
test "big.int div multi-multi q < r" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
const op1 = 0x1ffffffff0078f432;
const op2 = 0x1ffffffff01000000;
var a = try Managed.initSet(testing.allocator, op1);
@ -1608,6 +1616,8 @@ test "big.int div floor positive close to zero" {
}
test "big.int div multi-multi with rem" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
var a = try Managed.initSet(testing.allocator, 0x8888999911110000ffffeeeeddddccccbbbbaaaa9999);
defer a.deinit();
var b = try Managed.initSet(testing.allocator, 0x99990000111122223333);
@ -1624,6 +1634,8 @@ test "big.int div multi-multi with rem" {
}
test "big.int div multi-multi no rem" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
var a = try Managed.initSet(testing.allocator, 0x8888999911110000ffffeeeedb4fec200ee3a4286361);
defer a.deinit();
var b = try Managed.initSet(testing.allocator, 0x99990000111122223333);
@ -1640,6 +1652,8 @@ test "big.int div multi-multi no rem" {
}
test "big.int div multi-multi (2 branch)" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
var a = try Managed.initSet(testing.allocator, 0x866666665555555588888887777777761111111111111111);
defer a.deinit();
var b = try Managed.initSet(testing.allocator, 0x86666666555555554444444433333333);
@ -1656,6 +1670,8 @@ test "big.int div multi-multi (2 branch)" {
}
test "big.int div multi-multi (3.1/3.3 branch)" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
var a = try Managed.initSet(testing.allocator, 0x11111111111111111111111111111111111111111111111111111111111111);
defer a.deinit();
var b = try Managed.initSet(testing.allocator, 0x1111111111111111111111111111111111111111171);
@ -1672,6 +1688,8 @@ test "big.int div multi-multi (3.1/3.3 branch)" {
}
test "big.int div multi-single zero-limb trailing" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
var a = try Managed.initSet(testing.allocator, 0x60000000000000000000000000000000000000000000000000000000000000000);
defer a.deinit();
var b = try Managed.initSet(testing.allocator, 0x10000000000000000);
@ -1690,6 +1708,8 @@ test "big.int div multi-single zero-limb trailing" {
}
test "big.int div multi-multi zero-limb trailing (with rem)" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
var a = try Managed.initSet(testing.allocator, 0x86666666555555558888888777777776111111111111111100000000000000000000000000000000);
defer a.deinit();
var b = try Managed.initSet(testing.allocator, 0x8666666655555555444444443333333300000000000000000000000000000000);
@ -1709,6 +1729,8 @@ test "big.int div multi-multi zero-limb trailing (with rem)" {
}
test "big.int div multi-multi zero-limb trailing (with rem) and dividend zero-limb count > divisor zero-limb count" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
var a = try Managed.initSet(testing.allocator, 0x8666666655555555888888877777777611111111111111110000000000000000);
defer a.deinit();
var b = try Managed.initSet(testing.allocator, 0x8666666655555555444444443333333300000000000000000000000000000000);
@ -1728,6 +1750,8 @@ test "big.int div multi-multi zero-limb trailing (with rem) and dividend zero-li
}
test "big.int div multi-multi zero-limb trailing (with rem) and dividend zero-limb count < divisor zero-limb count" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
var a = try Managed.initSet(testing.allocator, 0x86666666555555558888888777777776111111111111111100000000000000000000000000000000);
defer a.deinit();
var b = try Managed.initSet(testing.allocator, 0x866666665555555544444444333333330000000000000000);
@ -2486,6 +2510,8 @@ test "big.int gcd non-one large" {
}
test "big.int gcd large multi-limb result" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
var a = try Managed.initSet(testing.allocator, 0x12345678123456781234567812345678123456781234567812345678);
defer a.deinit();
var b = try Managed.initSet(testing.allocator, 0x12345671234567123456712345671234567123456712345671234567);

6
lib/std/mem.zig
View File

@ -1504,6 +1504,8 @@ test "comptime read/write int" {
}
test "readIntBig and readIntLittle" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
try testing.expect(readIntSliceBig(u0, &[_]u8{}) == 0x0);
try testing.expect(readIntSliceLittle(u0, &[_]u8{}) == 0x0);
@ -1795,6 +1797,8 @@ pub fn writeVarPackedInt(bytes: []u8, bit_offset: usize, bit_count: usize, value
}
test "writeIntBig and writeIntLittle" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
var buf0: [0]u8 = undefined;
var buf1: [1]u8 = undefined;
var buf2: [2]u8 = undefined;
@ -4011,6 +4015,8 @@ pub fn alignInSlice(slice: anytype, comptime new_alignment: usize) ?AlignedSlice
}
test "read/write(Var)PackedInt" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
switch (builtin.cpu.arch) {
// This test generates too much code to execute on WASI.
// LLVM backend fails with "too many locals: locals exceed maximum"

3
lib/std/os/test.zig
View File

@ -502,8 +502,7 @@ fn iter_fn(info: *dl_phdr_info, size: usize, counter: *usize) IterFnError!void {
}
test "dl_iterate_phdr" {
if (native_os == .windows or native_os == .wasi or native_os == .macos)
return error.SkipZigTest;
if (builtin.object_format != .elf) return error.SkipZigTest;
var counter: usize = 0;
try os.dl_iterate_phdr(&counter, IterFnError, iter_fn);

2
lib/std/rand/Xoshiro256.zig
View File

@ -90,6 +90,8 @@ pub fn fill(self: *Xoshiro256, buf: []u8) void {
}
test "xoroshiro sequence" {
if (@import("builtin").zig_backend == .stage2_c) return error.SkipZigTest;
var r = Xoshiro256.init(0);
const seq1 = [_]u64{

237
lib/zig.h
View File

@ -1972,6 +1972,243 @@ static inline int32_t zig_cmp_big(const void *lhs, const void *rhs, bool is_sign
return 0;
}
static inline void zig_and_big(void *res, const void *lhs, const void *rhs, bool is_signed, uint16_t bits) {
uint8_t *res_bytes = res;
const uint8_t *lhs_bytes = lhs;
const uint8_t *rhs_bytes = rhs;
uint16_t byte_offset = 0;
uint16_t remaining_bytes = zig_int_bytes(bits);
(void)is_signed;
while (remaining_bytes >= 128 / CHAR_BIT) {
zig_u128 res_limb;
zig_u128 lhs_limb;
zig_u128 rhs_limb;
memcpy(&lhs_limb, &lhs_bytes[byte_offset], sizeof(lhs_limb));
memcpy(&rhs_limb, &rhs_bytes[byte_offset], sizeof(rhs_limb));
res_limb = zig_and_u128(lhs_limb, rhs_limb);
memcpy(&res_bytes[byte_offset], &res_limb, sizeof(res_limb));
remaining_bytes -= 128 / CHAR_BIT;
byte_offset += 128 / CHAR_BIT;
}
while (remaining_bytes >= 64 / CHAR_BIT) {
uint64_t res_limb;
uint64_t lhs_limb;
uint64_t rhs_limb;
memcpy(&lhs_limb, &lhs_bytes[byte_offset], sizeof(lhs_limb));
memcpy(&rhs_limb, &rhs_bytes[byte_offset], sizeof(rhs_limb));
res_limb = zig_and_u64(lhs_limb, rhs_limb);
memcpy(&res_bytes[byte_offset], &res_limb, sizeof(res_limb));
remaining_bytes -= 64 / CHAR_BIT;
byte_offset += 64 / CHAR_BIT;
}
while (remaining_bytes >= 32 / CHAR_BIT) {
uint32_t res_limb;
uint32_t lhs_limb;
uint32_t rhs_limb;
memcpy(&lhs_limb, &lhs_bytes[byte_offset], sizeof(lhs_limb));
memcpy(&rhs_limb, &rhs_bytes[byte_offset], sizeof(rhs_limb));
res_limb = zig_and_u32(lhs_limb, rhs_limb);
memcpy(&res_bytes[byte_offset], &res_limb, sizeof(res_limb));
remaining_bytes -= 32 / CHAR_BIT;
byte_offset += 32 / CHAR_BIT;
}
while (remaining_bytes >= 16 / CHAR_BIT) {
uint16_t res_limb;
uint16_t lhs_limb;
uint16_t rhs_limb;
memcpy(&lhs_limb, &lhs_bytes[byte_offset], sizeof(lhs_limb));
memcpy(&rhs_limb, &rhs_bytes[byte_offset], sizeof(rhs_limb));
res_limb = zig_and_u16(lhs_limb, rhs_limb);
memcpy(&res_bytes[byte_offset], &res_limb, sizeof(res_limb));
remaining_bytes -= 16 / CHAR_BIT;
byte_offset += 16 / CHAR_BIT;
}
while (remaining_bytes >= 8 / CHAR_BIT) {
uint8_t res_limb;
uint8_t lhs_limb;
uint8_t rhs_limb;
memcpy(&lhs_limb, &lhs_bytes[byte_offset], sizeof(lhs_limb));
memcpy(&rhs_limb, &rhs_bytes[byte_offset], sizeof(rhs_limb));
res_limb = zig_and_u8(lhs_limb, rhs_limb);
memcpy(&res_bytes[byte_offset], &res_limb, sizeof(res_limb));
remaining_bytes -= 8 / CHAR_BIT;
byte_offset += 8 / CHAR_BIT;
}
}
static inline void zig_or_big(void *res, const void *lhs, const void *rhs, bool is_signed, uint16_t bits) {
uint8_t *res_bytes = res;
const uint8_t *lhs_bytes = lhs;
const uint8_t *rhs_bytes = rhs;
uint16_t byte_offset = 0;
uint16_t remaining_bytes = zig_int_bytes(bits);
(void)is_signed;
while (remaining_bytes >= 128 / CHAR_BIT) {
zig_u128 res_limb;
zig_u128 lhs_limb;
zig_u128 rhs_limb;
memcpy(&lhs_limb, &lhs_bytes[byte_offset], sizeof(lhs_limb));
memcpy(&rhs_limb, &rhs_bytes[byte_offset], sizeof(rhs_limb));
res_limb = zig_or_u128(lhs_limb, rhs_limb);
memcpy(&res_bytes[byte_offset], &res_limb, sizeof(res_limb));
remaining_bytes -= 128 / CHAR_BIT;
byte_offset += 128 / CHAR_BIT;
}
while (remaining_bytes >= 64 / CHAR_BIT) {
uint64_t res_limb;
uint64_t lhs_limb;
uint64_t rhs_limb;
memcpy(&lhs_limb, &lhs_bytes[byte_offset], sizeof(lhs_limb));
memcpy(&rhs_limb, &rhs_bytes[byte_offset], sizeof(rhs_limb));
res_limb = zig_or_u64(lhs_limb, rhs_limb);
memcpy(&res_bytes[byte_offset], &res_limb, sizeof(res_limb));
remaining_bytes -= 64 / CHAR_BIT;
byte_offset += 64 / CHAR_BIT;
}
while (remaining_bytes >= 32 / CHAR_BIT) {
uint32_t res_limb;
uint32_t lhs_limb;
uint32_t rhs_limb;
memcpy(&lhs_limb, &lhs_bytes[byte_offset], sizeof(lhs_limb));
memcpy(&rhs_limb, &rhs_bytes[byte_offset], sizeof(rhs_limb));
res_limb = zig_or_u32(lhs_limb, rhs_limb);
memcpy(&res_bytes[byte_offset], &res_limb, sizeof(res_limb));
remaining_bytes -= 32 / CHAR_BIT;
byte_offset += 32 / CHAR_BIT;
}
while (remaining_bytes >= 16 / CHAR_BIT) {
uint16_t res_limb;
uint16_t lhs_limb;
uint16_t rhs_limb;
memcpy(&lhs_limb, &lhs_bytes[byte_offset], sizeof(lhs_limb));
memcpy(&rhs_limb, &rhs_bytes[byte_offset], sizeof(rhs_limb));
res_limb = zig_or_u16(lhs_limb, rhs_limb);
memcpy(&res_bytes[byte_offset], &res_limb, sizeof(res_limb));
remaining_bytes -= 16 / CHAR_BIT;
byte_offset += 16 / CHAR_BIT;
}
while (remaining_bytes >= 8 / CHAR_BIT) {
uint8_t res_limb;
uint8_t lhs_limb;
uint8_t rhs_limb;
memcpy(&lhs_limb, &lhs_bytes[byte_offset], sizeof(lhs_limb));
memcpy(&rhs_limb, &rhs_bytes[byte_offset], sizeof(rhs_limb));
res_limb = zig_or_u8(lhs_limb, rhs_limb);
memcpy(&res_bytes[byte_offset], &res_limb, sizeof(res_limb));
remaining_bytes -= 8 / CHAR_BIT;
byte_offset += 8 / CHAR_BIT;
}
}
static inline void zig_xor_big(void *res, const void *lhs, const void *rhs, bool is_signed, uint16_t bits) {
uint8_t *res_bytes = res;
const uint8_t *lhs_bytes = lhs;
const uint8_t *rhs_bytes = rhs;
uint16_t byte_offset = 0;
uint16_t remaining_bytes = zig_int_bytes(bits);
(void)is_signed;
while (remaining_bytes >= 128 / CHAR_BIT) {
zig_u128 res_limb;
zig_u128 lhs_limb;
zig_u128 rhs_limb;
memcpy(&lhs_limb, &lhs_bytes[byte_offset], sizeof(lhs_limb));
memcpy(&rhs_limb, &rhs_bytes[byte_offset], sizeof(rhs_limb));
res_limb = zig_xor_u128(lhs_limb, rhs_limb);
memcpy(&res_bytes[byte_offset], &res_limb, sizeof(res_limb));
remaining_bytes -= 128 / CHAR_BIT;
byte_offset += 128 / CHAR_BIT;
}
while (remaining_bytes >= 64 / CHAR_BIT) {
uint64_t res_limb;
uint64_t lhs_limb;
uint64_t rhs_limb;
memcpy(&lhs_limb, &lhs_bytes[byte_offset], sizeof(lhs_limb));
memcpy(&rhs_limb, &rhs_bytes[byte_offset], sizeof(rhs_limb));
res_limb = zig_xor_u64(lhs_limb, rhs_limb);
memcpy(&res_bytes[byte_offset], &res_limb, sizeof(res_limb));
remaining_bytes -= 64 / CHAR_BIT;
byte_offset += 64 / CHAR_BIT;
}
while (remaining_bytes >= 32 / CHAR_BIT) {
uint32_t res_limb;
uint32_t lhs_limb;
uint32_t rhs_limb;
memcpy(&lhs_limb, &lhs_bytes[byte_offset], sizeof(lhs_limb));
memcpy(&rhs_limb, &rhs_bytes[byte_offset], sizeof(rhs_limb));
res_limb = zig_xor_u32(lhs_limb, rhs_limb);
memcpy(&res_bytes[byte_offset], &res_limb, sizeof(res_limb));
remaining_bytes -= 32 / CHAR_BIT;
byte_offset += 32 / CHAR_BIT;
}
while (remaining_bytes >= 16 / CHAR_BIT) {
uint16_t res_limb;
uint16_t lhs_limb;
uint16_t rhs_limb;
memcpy(&lhs_limb, &lhs_bytes[byte_offset], sizeof(lhs_limb));
memcpy(&rhs_limb, &rhs_bytes[byte_offset], sizeof(rhs_limb));
res_limb = zig_xor_u16(lhs_limb, rhs_limb);
memcpy(&res_bytes[byte_offset], &res_limb, sizeof(res_limb));
remaining_bytes -= 16 / CHAR_BIT;
byte_offset += 16 / CHAR_BIT;
}
while (remaining_bytes >= 8 / CHAR_BIT) {
uint8_t res_limb;
uint8_t lhs_limb;
uint8_t rhs_limb;
memcpy(&lhs_limb, &lhs_bytes[byte_offset], sizeof(lhs_limb));
memcpy(&rhs_limb, &rhs_bytes[byte_offset], sizeof(rhs_limb));
res_limb = zig_xor_u8(lhs_limb, rhs_limb);
memcpy(&res_bytes[byte_offset], &res_limb, sizeof(res_limb));
remaining_bytes -= 8 / CHAR_BIT;
byte_offset += 8 / CHAR_BIT;
}
}
static inline bool zig_addo_big(void *res, const void *lhs, const void *rhs, bool is_signed, uint16_t bits) {
uint8_t *res_bytes = res;
const uint8_t *lhs_bytes = lhs;

863
src/codegen/c.zig
View File

File diff suppressed because it is too large Load Diff

12
test/behavior/packed-struct.zig
View File

@ -615,3 +615,15 @@ test "pointer to container level packed struct field" {
@ptrCast(*S, &S.arr[0]).other_bits.enable_3 = true;
try expect(S.arr[0] == 0x10000000);
}
test "store undefined to packed result location" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
var x: u4 = 0;
var s = packed struct { x: u4, y: u4 }{ .x = x, .y = if (x > 0) x else undefined };
try expectEqual(x, s.x);
}

7
test/tests.zig
View File

@ -962,13 +962,6 @@ pub fn addModuleTests(b: *std.Build, options: ModuleTestOptions) *Step {
if (test_target.use_llvm == false and mem.eql(u8, options.name, "std"))
continue;
// TODO get std lib tests passing for the C backend
if (test_target.target.ofmt == std.Target.ObjectFormat.c and
mem.eql(u8, options.name, "std"))
{
continue;
}
const want_this_mode = for (options.optimize_modes) |m| {
if (m == test_target.optimize_mode) break true;
} else false;