From abd77dfcf3f4eddcde7c0c176cfce35bd84ce41d Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Wed, 14 Oct 2026 19:57:00 -0500 Subject: [PATCH] Match Node's per-architecture parseInt rounding and record both answers in the string oracle For radixes other than 2, 4, 8, 10, 16 and 32, V8 folds each 32-bit digit chunk with `value * multiplier + part`. Node's arm64 builds fuse that multiply-add into one rounding and its x64 builds round twice, so long inputs such as parseInt("9007199254740993", 36) answer 1.9896986116031812e+24 on arm64 and 1.9896986116031807e+24 on x64. The runtime followed the same split only through the C compiler's default contraction, and the committed string oracle held one architecture's answers: regenerating it on x64 replaced the two arm64 values, failing the string oracle tests on macOS arm64. scr_radix_fold now writes out each form: fma() on aarch64, and an unfused multiply and add with contraction disabled elsewhere, so the result matches the same architecture's Node under any contraction setting. The generator records the architecture-dependent cases once per architecture ("parseInt.arm64" / "parseInt.x64") from a listed table and checks the current machine's answer against Node, so the committed file is the same whichever machine generates it. The C harness runs the cases for the architecture it was built for. --- packages/runtime/src/scr_string.c | 25 +++++++-- packages/runtime/test/gen-string-cases.mjs | 38 ++++++++++++- packages/runtime/test/string-cases.txt | 6 ++- packages/runtime/test/string.test.ts | 62 +++------------------- packages/runtime/test/test_string.c | 15 +++++- 5 files changed, 84 insertions(+), 62 deletions(-) diff --git a/packages/runtime/src/scr_string.c b/packages/runtime/src/scr_string.c index 71016cfdc..c01b15960 100644 --- a/packages/runtime/src/scr_string.c +++ b/packages/runtime/src/scr_string.c @@ -2603,6 +2603,25 @@ static int scr_digit_value(char c) { return 99; } +/* One fold of V8's generic-radix loop: v * multiplier + part. Node's V8 is + * compiled with the C++ compiler's default floating-point contraction, + * which fuses this multiply-add into one rounding on arm64 and keeps two + * roundings on x86-64, so Node answers long inputs differently on the two + * architectures (parseInt("9007199254740993", 36) is 1.9896986116031812e+24 + * on arm64 and 1.9896986116031807e+24 on x64). Each form is written out so + * the result matches the same architecture's Node under any contraction + * setting this file is compiled with. */ +static inline double scr_radix_fold(double v, uint32_t multiplier, uint32_t part) { +#if defined(__aarch64__) + return fma(v, (double)multiplier, (double)part); +#else +#ifdef __clang__ +#pragma clang fp contract(off) +#endif + return v * (double)multiplier + (double)part; +#endif +} + /* Digit string → double (digits already validated against the radix, * leading zeros stripped, count >= 1). Node (V8) is the oracle, and V8 is * only EXACT where the spec requires it (radix 2, 4, 8, 10, 16, 32); for @@ -2615,8 +2634,8 @@ static double scr_digits_to_double(const char *p, size_t n, int radix) { if (radix != 10 && (radix & (radix - 1)) != 0) { /* V8's generic-radix loop (numbers/conversions.cc): consume the * longest digit run whose multiplier stays below 0xFFFFFFFF/36, then - * fold with one double multiply-add per chunk — the rounding of each - * fold IS the observable Node behavior. */ + * fold with one double multiply-add per chunk (scr_radix_fold) — the + * rounding of each fold IS the observable Node behavior. */ const uint32_t kMaximumMultiplier = 0xFFFFFFFFu / 36u; double v = 0.0; size_t i = 0; @@ -2635,7 +2654,7 @@ static double scr_digits_to_double(const char *p, size_t n, int radix) { multiplier = m; i++; } - v = v * (double)multiplier + (double)part; + v = scr_radix_fold(v, multiplier, part); } while (!done); return v; } diff --git a/packages/runtime/test/gen-string-cases.mjs b/packages/runtime/test/gen-string-cases.mjs index 866f44291..ee3cc0296 100644 --- a/packages/runtime/test/gen-string-cases.mjs +++ b/packages/runtime/test/gen-string-cases.mjs @@ -309,8 +309,42 @@ const radices = [ -4294967280, 35, ]; +// parseInt cases whose Node answer depends on the architecture, keyed by +// input and radix argument. For radixes other than 2, 4, 8, 10, 16 and 32, V8 +// folds each 32-bit digit chunk with `value * multiplier + part`; Node's +// arm64 builds fuse that multiply-add into one rounding and its x64 builds +// round twice. Each case is written once per architecture with the listed +// answers, so the file is the same whichever machine generates it, and the +// answer for this machine's architecture is checked against Node here. +const ARCH_PARSEINT = new Map([ + ["9007199254740993\t36", { arm64: "1.9896986116031812e+24", x64: "1.9896986116031807e+24" }], + [ + "123456789012345678901234567890\t36", + { arm64: "1.436287679432363e+45", x64: "1.4362876794323633e+45" }, + ], +]); +const ownArch = process.arch === "arm64" ? "arm64" : "x64"; +const archCases = new Set(); for (const s of parseIntInputs) - for (const r of radices) - emit("parseInt", s, r === undefined ? "0" : num(r), hex(String(parseInt(s, r)))); + for (const r of radices) { + const args = r === undefined ? "0" : num(r); + const answer = String(parseInt(s, r)); + const arch = ARCH_PARSEINT.get(`${s}\t${args}`); + if (arch === undefined) { + emit("parseInt", s, args, hex(answer)); + continue; + } + if (answer !== arch[ownArch]) { + throw new Error( + `parseInt(${JSON.stringify(s)}, ${args}) is ${answer} on ${process.arch}; ARCH_PARSEINT lists ${arch[ownArch]}`, + ); + } + archCases.add(`${s}\t${args}`); + emit("parseInt.arm64", s, args, hex(arch.arm64)); + emit("parseInt.x64", s, args, hex(arch.x64)); + } +if (archCases.size !== ARCH_PARSEINT.size) { + throw new Error("ARCH_PARSEINT lists a case that parseIntInputs and radices do not generate"); +} stdout.write([...lines].join("\n") + "\n"); diff --git a/packages/runtime/test/string-cases.txt b/packages/runtime/test/string-cases.txt index 4334b0470..17dc8ef6f 100644 --- a/packages/runtime/test/string-cases.txt +++ b/packages/runtime/test/string-cases.txt @@ -34282,7 +34282,8 @@ parseInt 39303037313939323534373430393933 2 4e614e parseInt 39303037313939323534373430393933 8 4e614e parseInt 39303037313939323534373430393933 10 39303037313939323534373430393932 parseInt 39303037313939323534373430393933 16 3130333738323931393832353731343037303030 -parseInt 39303037313939323534373430393933 36 312e39383936393836313136303331383037652b3234 +parseInt.arm64 39303037313939323534373430393933 36 312e39383936393836313136303331383132652b3234 +parseInt.x64 39303037313939323534373430393933 36 312e39383936393836313136303331383037652b3234 parseInt 39303037313939323534373430393933 1 4e614e parseInt 39303037313939323534373430393933 37 4e614e parseInt 39303037313939323534373430393933 -1 4e614e @@ -34316,7 +34317,8 @@ parseInt 313233343536373839303132333435363738393031323334353637383930 2 31 parseInt 313233343536373839303132333435363738393031323334353637383930 8 333432333931 parseInt 313233343536373839303132333435363738393031323334353637383930 10 312e32333435363738393031323334353638652b3239 parseInt 313233343536373839303132333435363738393031323334353637383930 16 392e343532323837393638373336353437652b3334 -parseInt 313233343536373839303132333435363738393031323334353637383930 36 312e34333632383736373934333233363333652b3435 +parseInt.arm64 313233343536373839303132333435363738393031323334353637383930 36 312e343336323837363739343332333633652b3435 +parseInt.x64 313233343536373839303132333435363738393031323334353637383930 36 312e34333632383736373934333233363333652b3435 parseInt 313233343536373839303132333435363738393031323334353637383930 1 4e614e parseInt 313233343536373839303132333435363738393031323334353637383930 37 4e614e parseInt 313233343536373839303132333435363738393031323334353637383930 -1 4e614e diff --git a/packages/runtime/test/string.test.ts b/packages/runtime/test/string.test.ts index 14dfe090a..3995a8de1 100644 --- a/packages/runtime/test/string.test.ts +++ b/packages/runtime/test/string.test.ts @@ -53,37 +53,17 @@ beforeAll(async () => { }); // Runs against the committed case file generated from Node via -// gen-string-cases.mjs. The test below also verifies the checked-in oracle -// against the generator, so an accidental stale result cannot be masked by -// the platform-specific native-runtime allowlist. Covers UTF-16 +// gen-string-cases.mjs. The first test below also verifies the checked-in +// oracle against the generator, so a stale result cannot pass. Covers UTF-16 // length/charCodeAt/indexOf/includes/startsWith/endsWith/slice/repeat/ // trim/trimStart/trimEnd/split/padStart/padEnd/charAt plus parseInt over // ASCII, Latin-1, CJK, astral, and combining-mark strings, including the // documented lone-surrogate → U+FFFD divergence. // -// On macOS every committed case matches exactly. On Linux (glibc, -// measured on the sandbox-suite lane's AL2023 clang 15) exactly two -// parseInt cases — giant base-36 inputs whose magnitude assembly rides -// libm — land one ulp away from V8's correctly-rounded conversion. -// scr_number.c is pinned and shared across every consumer, so the -// divergence is documented HERE as an allowlist keyed by exact input and -// exact divergent output: a third value, a new failing case, or a future -// conversion fix all make the test fail. -const LINUX_PARSEINT_ULP: ReadonlyMap = new Map([ - [ - // parseInt("9007199254740993", 36): Node 1.9896986116031812e+24, - // glibc lane 1.9896986116031807e+24. - "parseInt(39303037313939323534373430393933 ; 36)", - "312e39383936393836313136303331383037652b3234", - ], - [ - // parseInt("123456789012345678901234567890", 36): - // Node 1.436287679432363e+45, glibc lane 1.4362876794323633e+45. - "parseInt(313233343536373839303132333435363738393031323334353637383930 ; 36)", - "312e34333632383736373934333233363333652b3435", - ], -]); - +// parseInt cases whose Node answer differs between arm64 and x64 are +// recorded once per architecture ("parseInt.arm64" / "parseInt.x64", see +// ARCH_PARSEINT in gen-string-cases.mjs), so the generated file is the same +// on either machine and the C harness checks this architecture's answer. test("committed string oracle matches Node", async () => { const caseFile = join(testDir, "string-cases.txt"); const [{ stdout }, committed] = await Promise.all([ @@ -92,18 +72,10 @@ test("committed string oracle matches Node", async () => { }), readFile(caseFile, "utf8"), ]); - // The committed cases come from Node on arm64. Node on x64 answers the two - // allowlisted base-36 parseInt cases with exactly the values listed above; - // every other line, and any other value for those two, must still match. const generated = stdout.split("\n"); const expected = committed.split("\n"); expect(generated).toHaveLength(expected.length); - const differing = generated.filter((line, index) => line !== expected[index]); - if (process.arch === "arm64") expect(differing).toEqual([]); - for (const line of differing) { - const [operation, input, radix, output] = line.split("\t"); - expect(LINUX_PARSEINT_ULP.get(`${operation}(${input} ; ${radix})`), line).toBe(output); - } + expect(generated.filter((line, index) => line !== expected[index])).toEqual([]); }); test("string methods match Node on committed oracle cases", async () => { @@ -111,25 +83,7 @@ test("string methods match Node on committed oracle cases", async () => { (v) => ({ stderr: v.stderr }), (e: Error & { stderr?: string }) => ({ stderr: e.stderr ?? "" }), ); - const stderr = r.stderr.trim(); - if (process.platform !== "linux") { - expect(stderr).toMatch(/^(\d+)\/\1 cases passed$/); - return; - } - const lines = stderr.split("\n"); - const mismatches = lines.filter((l) => l.startsWith("MISMATCH ")); - for (const line of mismatches) { - const m = /^MISMATCH (.+) expected=[0-9a-f]* got=([0-9a-f]*)$/.exec(line); - expect(m, `unparseable mismatch line: ${line}`).not.toBeNull(); - expect(LINUX_PARSEINT_ULP.get(m![1]!), line).toBe(m![2]); - } - // The harness prints at most 20 mismatch lines; the pass-count tail is - // the ground truth that NOTHING beyond the printed (allowlisted) set - // failed. - const t = /^(\d+)\/(\d+) cases passed$/.exec(lines.at(-1) ?? ""); - expect(t, `missing pass-count line: ${lines.at(-1)}`).not.toBeNull(); - expect(Number(t![2]) - Number(t![1]), "failed-case count").toBe(mismatches.length); - expect(mismatches.length).toBeLessThanOrEqual(LINUX_PARSEINT_ULP.size); + expect(r.stderr.trim()).toMatch(/^(\d+)\/\1 cases passed$/); }); // repeat(count) with count < 0 or Infinity is Node's catchable RangeError diff --git a/packages/runtime/test/test_string.c b/packages/runtime/test/test_string.c index e7ce99100..55c49af7e 100644 --- a/packages/runtime/test/test_string.c +++ b/packages/runtime/test/test_string.c @@ -27,6 +27,16 @@ long scr_str_live_count(void); /* provided by scr_string.c */ #endif +/* parseInt cases whose Node answer depends on the architecture carry it in + * the op name ("parseInt.arm64" / "parseInt.x64"); only this build's runs. + * scr_radix_fold uses the fused multiply-add on aarch64 and two roundings + * elsewhere, matching Node on arm64 and x64. */ +#if defined(__aarch64__) +#define SCR_TEST_PARSEINT_ARCH "parseInt.arm64" +#else +#define SCR_TEST_PARSEINT_ARCH "parseInt.x64" +#endif + #ifdef SCR_SIDX_TEST /* Test-only sparse-index observability, deliberately absent from the normal * runtime ABI. The walker count is code-point steps after a cache prime. */ @@ -977,9 +987,12 @@ int main(int argc, char **argv) { } else if (strcmp(op, "trimEnd") == 0) { check_str(op, args, input, scr_str_trim_end(input), expected_bytes, exp_len); - } else if (strcmp(op, "parseInt") == 0) { + } else if (strcmp(op, "parseInt") == 0 || + strcmp(op, SCR_TEST_PARSEINT_ARCH) == 0) { check_f64(op, args, input, scr_parse_int(input, strtod(args, NULL)), expected_bytes, exp_len); + } else if (strncmp(op, "parseInt.", 9) == 0) { + /* another architecture's answer (see SCR_TEST_PARSEINT_ARCH) */ } else if (strcmp(op, "split") == 0 || strcmp(op, "splitLimit") == 0) { /* args = separator hex; expected = ":" */ double limit = 4294967295.0;