shishantbiswas/c3c
1
1
Fork 0
mirror of https://github.com/c3lang/c3c.git synced 2026-02-27 03:51:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

Migrate from @unaligned_load to mem::load

Browse Source
This commit is contained in:
Christoffer Lerno
2026-01-17 19:12:32 +01:00
parent a326e31e57
commit d3ebd4a130
9 changed files with 41 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
lib/std/core/bitorder.c3
View File

@@ -101,7 +101,7 @@ macro read(bytes, $Type)
$default:
ptr = bytes[..].ptr;
$endswitch
return bitcast(@unaligned_load(*(char[$Type.sizeof]*)ptr, 1), $Type).val;
return bitcast(mem::load((char[$Type.sizeof]*)ptr, $align: 1), $Type).val;
}
<*
@@ -118,7 +118,7 @@ macro write(x, bytes, $Type)
$default:
ptr = bytes[..].ptr;
$endswitch
@unaligned_store(*($typeof(x)*)ptr, bitcast(x, $Type).val, 1);
mem::store(($typeof(x)*)ptr, bitcast(x, $Type).val, 1);
}
macro bool is_bitorder($Type)

2
lib/std/crypto/chacha20.c3
View File

@@ -142,7 +142,7 @@ fn void ChaCha20.transform(&self, char[] data)
char[] aligned_data = data[offset..];
for (; x <= (BLOCK_SIZE - usz.sizeof); x += usz.sizeof)
{
((usz*)aligned_data.ptr)[x / usz.sizeof] ^= @unaligned_load(*(usz*)(&key_stream[x]), 1);
((usz*)aligned_data.ptr)[x / usz.sizeof] ^= mem::load((usz*)(&key_stream[x]), $align: 1);
}
for (; x < BLOCK_SIZE; x++) data[x] ^= key_stream[x];
}

16
lib/std/hash/a5hash.c3
View File

@@ -62,8 +62,8 @@ fn ulong hash(char[] data, ulong seed = 0)
for (; data.len > 16; data = data[16..])
{
@a5mul(
@unaligned_load(((ulong*)data.ptr)[0], 1) ^ seed1,
@unaligned_load(((ulong*)data.ptr)[1], 1) ^ seed2,
mem::load((ulong*)data.ptr, 1) ^ seed1,
mem::load((ulong*)data.ptr + 1, 1) ^ seed2,
seed1, seed2
);
@@ -71,16 +71,16 @@ fn ulong hash(char[] data, ulong seed = 0)
seed2 += val10;
}
a = @unaligned_load(*(ulong*)(data.ptr + (uptr)data.len - 16), 1);
b = @unaligned_load(*(ulong*)(data.ptr + (uptr)data.len - 8), 1);
a = mem::load((ulong*)(data.ptr + (uptr)data.len - 16), 1);
b = mem::load((ulong*)(data.ptr + (uptr)data.len - 8), 1);
}
else
{
a = ((ulong)@unaligned_load(*(uint*)&data[0], 1) << 32)
| @unaligned_load(*(uint*)&data[^4], 1);
a = ((ulong)mem::load((uint*)&data[0], 1) << 32)
| mem::load((uint*)&data[^4], 1);
b = ((ulong)@unaligned_load(*(uint*)&data[(data.len >> 3) * 4], 1) << 32)
| @unaligned_load(*(uint*)(data.ptr + data.len - 4 - (data.len >> 3) * 4), 1);
b = ((ulong)mem::load((uint*)&data[(data.len >> 3) * 4], 1) << 32)
| mem::load((uint*)(data.ptr + data.len - 4 - (data.len >> 3) * 4), 1);
}
}
else

10
lib/std/hash/blake3.c3
View File

@@ -229,7 +229,7 @@ fn void Blake3.init(&self, char[] key = {}, char explicit_flags = 0)
if (key.len)
{
foreach (i, &w : self.key) *w = @unaligned_load(*(uint*)&key[i * $sizeof(self.key[0])], 1);
foreach (i, &w : self.key) *w = mem::load((uint*)&key[i * $sizeof(self.key[0])], 1);
if (!explicit_flags) explicit_flags = Blake3Flags.KEYED_HASH;
}
else
@@ -599,7 +599,7 @@ macro @round(uint[] state, uint* msg, usz round) @local
fn void compress_pre(uint[] state, uint[] cv, char[BLOCK_SIZE] block, usz block_len, ulong counter, char flags) @local @noinline
{
uint[16] block_words @noinit;
foreach (i, &b : block_words) *b = @unaligned_load(*(uint*)&block[i * 4], 1);
foreach (i, &b : block_words) *b = mem::load((uint*)&block[i * 4], 1);
state[0:8] = cv[0:8];
state[8:4] = IV[0:4];
state[12] = (uint)counter;
@@ -626,8 +626,8 @@ macro compress_xof(uint[] cv, char[BLOCK_SIZE] block, usz block_len, ulong count
{
uint[16] state @noinit;
compress_pre(state[..], cv, block, block_len, counter, flags);
$for usz $i = 0; $i < 8; $i++: @unaligned_store(*(uint*)&out[4 * $i], state[$i] ^ state[$i + 8], 1); $endfor
$for usz $i = 0; $i < 8; $i++: @unaligned_store(*(uint*)&out[4 * (8 + $i)], state[$i + 8] ^ cv[$i], 1); $endfor
$for usz $i = 0; $i < 8; $i++: mem::store((uint*)&out[4 * $i], state[$i] ^ state[$i + 8], 1); $endfor
$for usz $i = 0; $i < 8; $i++: mem::store((uint*)&out[4 * (8 + $i)], state[$i + 8] ^ cv[$i], 1); $endfor
}
macro @xof_many(uint[] cv, char[BLOCK_SIZE] block, usz block_len, ulong counter, char flags, char[] out, usz out_blocks) @local
@@ -645,7 +645,7 @@ macro hash_one(char* input, usz blocks, uint[] key, ulong counter, char flags, c
if (blocks == 1) block_flags |= flags_end;
compress_in_place(cv[..], input[:BLOCK_SIZE], BLOCK_SIZE, counter, block_flags);
}
foreach (i, c : cv) @unaligned_store(*(uint*)&out[i * 4], c, 1);
foreach (i, c : cv) mem::store((uint*)&out[i * 4], c, 1);
}
macro hash_many(char*[] inputs, usz num_inputs, usz blocks, uint[] key, ulong counter, bool $increment_counter, char flags, char flags_start, char flags_end, char* out) @local

30
lib/std/hash/komi.c3
View File

@@ -58,38 +58,38 @@ fn ulong hash(char[] data, ulong seed = 0)
if (@likely(data.len >= 8))
{
r1h ^= @unaligned_load(*(ulong*)data.ptr, 1);
r1h ^= mem::load((ulong*)data.ptr, 1);
r2h ^= (data.len < 12)
? ((data[data.len - 3] | ((ulong)data[data.len - 2] << 8) | ((ulong)data[data.len - 1] << 16) | ((ulong)1 << 24)) >> ((data.len * 8) ^ 88))
: (((@unaligned_load(*(uint*)&data[^4], 1) | ((ulong)1 << 32)) >> (128 - data.len * 8)) << 32 | @unaligned_load(*(uint*)&data[8], 1));
: (((mem::load((uint*)&data[^4], 1) | ((ulong)1 << 32)) >> (128 - data.len * 8)) << 32 | mem::load((uint*)&data[8], 1));
}
else if (data.len != 0)
{
r1h ^= (data.len < 4)
? (((ulong)1 << (data.len * 8)) ^ data[0] ^ (data.len > 1 ? (ulong)data[1] << 8 : 0) ^ (data.len > 2 ? (ulong)data[2] << 16 : 0))
: (((@unaligned_load(*(uint*)&data[^4], 1) | ((ulong)1 << 32)) >> (64 - data.len * 8)) << 32 | @unaligned_load(*(uint*)&data[0], 1));
: (((mem::load((uint*)&data[^4], 1) | ((ulong)1 << 32)) >> (64 - data.len * 8)) << 32 | mem::load((uint*)&data[0], 1));
}
}
else if (data.len < 32)
{
// HASH16
@komimul(
@unaligned_load(*(ulong*)&data[0], 1) ^ seed1,
@unaligned_load(*(ulong*)&data[8], 1) ^ seed5,
mem::load((ulong*)&data[0], 1) ^ seed1,
mem::load((ulong*)&data[8], 1) ^ seed5,
seed1, seed5
);
seed1 ^= seed5;
if (data.len < 24)
{
r1h = (((@unaligned_load(*(ulong*)&data[^8], 1) >> 8) | ((ulong)1 << 56)) >> (((int)(data.len * 8) ^ 184))) ^ seed1;
r1h = (((mem::load((ulong*)&data[^8], 1) >> 8) | ((ulong)1 << 56)) >> (((int)(data.len * 8) ^ 184))) ^ seed1;
r2h = seed5;
}
else
{
r1h = @unaligned_load(*(ulong*)&data[16], 1) ^ seed1;
r2h = (((@unaligned_load(*(ulong*)&data[^8], 1) >> 8) | ((ulong)1 << 56)) >> (((int)(data.len * 8) ^ 248))) ^ seed5;
r1h = mem::load((ulong*)&data[16], 1) ^ seed1;
r2h = (((mem::load((ulong*)&data[^8], 1) >> 8) | ((ulong)1 << 56)) >> (((int)(data.len * 8) ^ 248))) ^ seed5;
}
}
else
@@ -106,8 +106,8 @@ fn ulong hash(char[] data, ulong seed = 0)
{
$for var $x = 0; $x < 4; ++$x :
@komimul(
@unaligned_load(*(ulong*)&data[0 + ($x * 8)], 1) ^ seeds[$x],
@unaligned_load(*(ulong*)&data[32 + ($x * 8)], 1) ^ seeds[4 + $x],
mem::load((ulong*)&data[0 + ($x * 8)], 1) ^ seeds[$x],
mem::load((ulong*)&data[32 + ($x * 8)], 1) ^ seeds[4 + $x],
seeds[$x], seeds[4 + $x]
);
$endfor
@@ -125,8 +125,8 @@ fn ulong hash(char[] data, ulong seed = 0)
for (; data.len >= 16; data = data[16:^16])
{
@komimul(
@unaligned_load(*(ulong*)&data[0], 1) ^ seed1,
@unaligned_load(*(ulong*)&data[8], 1) ^ seed5,
mem::load((ulong*)&data[0], 1) ^ seed1,
mem::load((ulong*)&data[8], 1) ^ seed5,
seed1, seed5
);
seed1 ^= seed5;
@@ -137,13 +137,13 @@ fn ulong hash(char[] data, ulong seed = 0)
// NOTE: This is translated from the original code. It grabs the last ulong off the buffer even though the
// data slice is less than 8 bytes. This is possible because this branch only occurs in a loop where
// the original data slice length is >= 32.
r1h = (((@unaligned_load(*(ulong*)(data.ptr + data.len - 8), 1) >> 8) | ((ulong)1 << 56)) >> ((data.len * 8) ^ 0x38)) ^ seed1;
r1h = (((mem::load((ulong*)(data.ptr + data.len - 8), 1) >> 8) | ((ulong)1 << 56)) >> ((data.len * 8) ^ 0x38)) ^ seed1;
r2h = seed5;
}
else
{
r1h = @unaligned_load(*(ulong*)data.ptr, 1) ^ seed1;
r2h = (((@unaligned_load(*(ulong*)&data[^8], 1) >> 8) | ((ulong)1 << 56)) >> ((data.len * 8) ^ 0x78)) ^ seed5;
r1h = mem::load((ulong*)data.ptr, 1) ^ seed1;
r2h = (((mem::load((ulong*)&data[^8], 1) >> 8) | ((ulong)1 << 56)) >> ((data.len * 8) ^ 0x78)) ^ seed5;
}
}

2
lib/std/hash/md5.c3
View File

@@ -108,7 +108,7 @@ macro @i(x, y, z) => y ^ (x | ~z);
macro void @step(#f, a, b, c, d, ptr, n, t, s)
{
*a += #f(b, c, d) + @unaligned_load(*(uint *)&ptr[n * 4], 2) + t;
*a += #f(b, c, d) + mem::load((uint *)&ptr[n * 4], 2) + t;
*a = (*a << s) | ((*a & 0xffffffff) >> (32 - s));
*a += b;
}

8
lib/std/hash/poly1305.c3
View File

@@ -62,8 +62,8 @@ alias tag = hash;
fn void Poly1305.init(&self, char[KEY_SIZE] key)
{
*self = { // implicitly clears state as well
.r = @unaligned_load(*(uint128*)&key[ 0], 1) & 0x0ffffffc_0ffffffc_0ffffffc_0fffffff, // clamped per spec
.nonce = @unaligned_load(*(uint128*)&key[16], 1)
.r = mem::load((uint128*)&key[ 0], 1) & 0x0ffffffc_0ffffffc_0ffffffc_0fffffff, // clamped per spec
.nonce = mem::load((uint128*)&key[16], 1)
};
self.r0 = @unaligned_load(((ulong*)&self.r)[0], 1);
@@ -139,8 +139,8 @@ fn void Poly1305.blocks(&self, char[] input, ulong pad_bit = 1) @local
{
for (; input.len >= BLOCK_SIZE; input = input[BLOCK_SIZE..])
{
ulong i0 = @unaligned_load(*(ulong*)&input[0], 1);
ulong i1 = @unaligned_load(*(ulong*)&input[8], 1);
ulong i0 = mem::load((ulong*)&input[0], 1);
ulong i1 = mem::load((ulong*)&input[8], 1);
uint128 d0 = (uint128)self.h[0] + i0;
self.h[0] = (ulong)d0;

2
lib/std/hash/whirlpool/whirlpool.c3
View File

@@ -161,7 +161,7 @@ fn void Whirlpool.process_block(&self, char* block) @local
// NOTE: These loops are unrolled with C3's Chad-tier compile-time evaluation.
$for var $round = 0; $round < 8; $round++:
k[$round] = self.hash[$round];
state[$round] = $$bswap(@unaligned_load(((ulong*)block)[$round], 1)) ^ self.hash[$round];
state[$round] = $$bswap(mem::load((ulong*)block + $round, 1)) ^ self.hash[$round];
self.hash[$round] = state[$round];
$endfor

8
lib/std/hash/wyhash2.c3
View File

@@ -34,8 +34,8 @@ fn ulong hash(char[] input, ulong seed = 0)
{
if (@likely(input.len >= 4))
{
a = (ulong)@unaligned_load(*(uint*)input.ptr, 1); // first 4 bytes widened to a u64
b = (ulong)@unaligned_load(*(uint*)&input[^4], 1); // a walking 4-byte window based on input.len
a = (ulong)mem::load((uint*)input.ptr, 1); // first 4 bytes widened to a u64
b = (ulong)mem::load((uint*)&input[^4], 1); // a walking 4-byte window based on input.len
}
else if (input.len > 0)
{
@@ -44,8 +44,8 @@ fn ulong hash(char[] input, ulong seed = 0)
}
else
{
a = @unaligned_load(*(ulong*)input.ptr, 1); // first 8 bytes
b = @unaligned_load(*(ulong*)&input[^8], 1); // a walking 8-byte window based on input.len
a = mem::load((ulong*)input.ptr, 1); // first 8 bytes
b = mem::load((ulong*)&input[^8], 1); // a walking 8-byte window based on input.len
}
uint128 r = ((uint128)a ^ 0xe703_7ed1_a0b4_28db) * ((uint128)b ^ seed);