Hojun-Cho
cbcc0167ae
Seven fixes across the toolchain, plus three new lib/hash modules
(adler32, crc16, crc32) that surfaced them.
1. `~x` on u8/u16/u32 left the upper bits set: NOTQ inverts the
whole 64-bit register and nothing trimmed it back to type
width, so a returned `u16` would compare 64-bit against a
typed literal and disagree. Both stages now mask after NOTQ
for narrow unsigned: AND $0xFF/0xFFFF for u8/u16, MOVL r,r for
u32 (ANDQ $0xFFFFFFFF sign-extends imm32 and is a no-op).
Signed narrows stay sign-extended and need no fix-up. See
cmd/w6c/cgen.c N_UN TK_TILDE and selfhost cgenexpr.ww cgun
TK_TILDE with new nodeprimwidth helper.
2. w6a had no D_CONST immediate path for ANDQ / ORQ. cgen would
emit `ANDQ $65535, AX` and the rr encoder silently wrote
`21 /r` with garbage reg fields — the mask never happened.
Added `81 /4` (AND) and `81 /1` (OR) imm32 paths in both
cstage and selfhost w6a. The ~width fix above depends on this.
3. `s: []u8` cast as a direct fn argument produced a 0-length
slice. cgexpr for N_CAST left (AX=ptr, BX=len) from the str
source but never set CX (cap), and the arg-push fallback only
pushed AX. cgcast now synthesises CX=BX when target is slice
and source is str; node_isslice / arg-push recognise
cast-to-slice and emit the full (cap, len, ptr) triple. Both
stages.
4. `*[N]T` element-store used 8-byte stride + MOVQ regardless of
T's width. Indexing `buf: *[4]u16` would step 8 bytes and
write 8 bytes per element. Added idx_eff (drills *[N]T → T)
in cstage and the matching pointer-array drill in selfhost
elemsizeof. Also added MOVW / MOVZWQ / MOVSWQ to w6c, w6a,
and selfhost mirrors so 2-byte element stores/loads use the
right opcode (was falling through to MOVQ and trailing 6 bytes
into the next slot).
5. Slicing a top-level fixed array (`g[0:n]` where `g: [N]T` is
a global) computed the base from BP instead of the symbol —
localfind returned 0 and the cgen treated it as a local at
offset 0. Both N_SLICE-as-expression (cgslice) and N_SLICE-
as-call-arg paths now check let_islet / letvartnode and emit
LEAQ name(SB) when the base is a global array (or MOVQ
name(SB) for a global slice/pointer base). Both stages.
6. Top-level `let arr: [N]T = [v0, v1, ...]` link-failed on
cstage — emit_lets bailed when it saw N_ARRLIT init on an
array type, and the sz==8 scalar path then misemitted any
8-byte-sized array (e.g. [4]u16, [8]u8) as a single quad.
emit_lets now walks N_ARRLIT, evaluates each element as an
int/rune/bool/nil literal, packs per-element bytes
little-endian, and honours the trailing `...` repeat marker.
Selfhost already handled the literal-init path; fixed the
parallel sz==8 duplicate-DATAW emit on its side (the array
and the scalar paths both fired, last write winning at link
but the duplicate broke cross-stage byte-identicality on user
code with this shape).
7. w6a's per-line input buffer was a 1KB stack `char buf[1024]`.
A `DATAW` for a [256]u16 emits ~2080 bytes on one line, which
truncated mid-escape; the assembler then re-parsed the
remaining tail as garbage opcodes ("unknown opcode"). Bumped
cstage w6a to a 32K static buffer (selfhost w6a already
allocated per-line via amalloc).
lib: lib/hash/adler32, lib/hash/crc16, lib/hash/crc32 — pure
buffer-subset shape (matching lib/hash/fnv), with per-module
*_test.ww runnable via `ww test lib/hash/<name>`. Adler-32 plus
CRC-16 (CCITT/CMDA2000/DECT/ANSI) and CRC-32 (IEEE/Castagnoli/
Koopman) cover Hare's reference vectors bit-for-bit. Wired into
test/wcc/900_stdlib.c. .gitignore: lib/**/*.s,*.o so `ww test`
droppings stay untracked.
`make test` (26/26), `make bootstrap` (ww2≡ww3≡ww4), and per-module
`ww test` all pass. cgen output is byte-identical across cstage and
selfhost for every repro that previously diverged.
43 lines
1.4 KiB
Plaintext
43 lines
1.4 KiB
Plaintext
// hash/crc16 — CRC-16 checksum. Pure ww.
|
|
//
|
|
// Inline polynomial-shift per byte (no precomputed tables). Slower
|
|
// than a table-driven CRC by ~8x per byte but matches the
|
|
// table-driven answer bit-for-bit.
|
|
//
|
|
// Polynomials are given in reversed form, matching Hare.
|
|
|
|
def CCITT: u16 = 0x8408u16; // X.25, Bluetooth, XMODEM
|
|
def CMDA2000: u16 = 0xE613u16; // CDMA2000 infra
|
|
def DECT: u16 = 0x91A0u16; // DECT cordless
|
|
def ANSI: u16 = 0xA001u16; // Modbus, USB, ANSI X3.28
|
|
|
|
// sum16 — fold `buf` under `poly` and return ~cval. Initial value is
|
|
// ~0u16, matching the streaming CRC-16 contract for a single
|
|
// write-then-sum. Per byte: XOR low byte of cval with msg byte to form
|
|
// an 8-bit index, run 8 polynomial shifts on that index, XOR the
|
|
// result with the high byte of cval shifted down.
|
|
export fn sum16(buf: []u8, poly: u16) u16 = {
|
|
let c: u16 = 0xFFFFu16;
|
|
let i: i32 = 0;
|
|
for (i < buf.len) {
|
|
let t: u16 = (c & 0xFFu16) ^ (buf[i]: u16);
|
|
let z: i32 = 0;
|
|
for (z < 8) {
|
|
if ((t & 1u16) == 1u16) {
|
|
t = (t >> 1u16) ^ poly;
|
|
} else {
|
|
t = t >> 1u16;
|
|
};
|
|
z += 1;
|
|
};
|
|
c = t ^ (c >> 8u16);
|
|
i += 1;
|
|
};
|
|
return ~c;
|
|
};
|
|
|
|
export fn sum16ccitt(buf: []u8) u16 = { return sum16(buf, CCITT); };
|
|
export fn sum16cmda2000(buf: []u8) u16 = { return sum16(buf, CMDA2000); };
|
|
export fn sum16dect(buf: []u8) u16 = { return sum16(buf, DECT); };
|
|
export fn sum16ansi(buf: []u8) u16 = { return sum16(buf, ANSI); };
|