#include "oracle.hpp" #include "proj3/base/fmt.hpp" #include "proj3/base/mem.hpp" #include "proj3/sys/panic.hpp" namespace proj3::oracle { mem::System* g_system = nullptr; namespace { // Octet de garde ecrit apres chaque tampon de sortie. Toute routine qui ecrit // un octet de trop l ecrase, et le harnais le voit. C est ce qui transforme // le cas "debordement d un octet" en detection, au lieu d une corruption // silencieuse d une zone voisine. constexpr u8 kGuardByte = 0xA5; constexpr usize kGuardBytes = 32; // Motif deterministe, pour les cas de graine 0. Volontairement non trivial // (ni tout a zero ni croissant) pour qu une routine qui ignore son entree ne // passe pas par chance. void fill_deterministic(u8* p, usize n) { for (usize i = 0; i < n; ++i) { p[i] = static_cast((i * 31u + (i >> 3) * 17u + 0x5Bu) & 0xFFu); } } void fill_random(u8* p, usize n, u64 seed) { Rng rng(seed); usize i = 0; while (i < n) { u64 v = rng.next(); for (int b = 0; b < 8 && i < n; ++b, ++i) { p[i] = static_cast(v & 0xFFu); v >>= 8; } } } void dump_hex(const u8* p, usize n) { char buf[3]; for (usize i = 0; i < n; ++i) { const usize k = fmt_hex_u8(buf, sizeof(buf), p[i]); err_write_bytes(buf, k); buf[0] = ' '; err_write_bytes(buf, 1); } } // Contexte autour de l offset divergent : 16 octets avant, 16 apres, bornes au // tampon. Sans contexte, un offset seul ne dit pas si l erreur est un decalage // ou une valeur fausse. void dump_context(const char* tag, const u8* p, usize len, usize center) { const usize begin = center >= 16 ? center - 16 : 0; usize end = center + 17; if (end > len) end = len; err_write(" "); err_write(tag); err_write(" ["); err_write_i64(static_cast(begin)); err_write(".."); err_write_i64(static_cast(end)); err_write(") : "); dump_hex(p + begin, end - begin); err_write("\n"); } bool guards_intact(const u8* guard) { for (usize i = 0; i < kGuardBytes; ++i) { if (guard[i] != kGuardByte) return false; } return true; } // --- Enregistrement -------------------------------------------------------- #if PROJ3_EMBEDDED // Symboles synthetises par l editeur de liens pour la section proj3_pairs. extern "C" const Pair* const __start_proj3_pairs[]; extern "C" const Pair* const __stop_proj3_pairs[]; #else // Stockage statique a initialisation constante : il est pret AVANT que le // moindre constructeur statique ne tourne, donc l ordre d initialisation ne // peut pas nous mordre. constexpr usize kMaxPairs = 64; const Pair* g_pairs[kMaxPairs]; usize g_pair_count; #endif } // namespace void register_pair(const Pair* p) { #if PROJ3_EMBEDDED (void)p; // l enregistrement se fait par la section, pas par appel #else if (g_pair_count >= kMaxPairs) panic("oracle : trop de paires enregistrees"); g_pairs[g_pair_count++] = p; #endif } bool run_pair(const Pair& p, mem::Arena& work, Report& out, bool expect_failure) { bool pair_ok = true; if (p.opt == nullptr) { ++out.pairs_ref_only; } else { ++out.pairs_run; } for (usize ci = 0; ci < p.case_count; ++ci) { const CaseSpec& c = p.cases[ci]; const usize mark = work.mark(); // Tampons : chacun precede de son decalage d alignement et suivi d une // zone de garde. La base de l arene est alignee sur 2 Mo, donc un // decalage de k octets donne une adresse ≡ k modulo 16 : c est // exactement le levier dont les chemins NEON auront besoin. u8* in_raw = work.alloc_array(c.in_len + 64); u8* in = in_raw + c.in_align_offset; const usize out_cap = c.in_len; u8* ref_raw = work.alloc_array(out_cap + 64 + kGuardBytes); u8* ref_out = ref_raw + c.out_align_offset; u8* ref_guard = ref_out + out_cap; u8* opt_raw = work.alloc_array(out_cap + 64 + kGuardBytes); u8* opt_out = opt_raw + c.out_align_offset; u8* opt_guard = opt_out + out_cap; if (c.seed == 0) { fill_deterministic(in, c.in_len); } else { fill_random(in, c.in_len, c.seed); } mem_fill(ref_out, 0, out_cap); mem_fill(opt_out, 0, out_cap); mem_fill(ref_guard, kGuardByte, kGuardBytes); mem_fill(opt_guard, kGuardByte, kGuardBytes); const usize ref_len = p.ref(in, c.in_len, ref_out, out_cap); ++out.cases_run; bool case_ok = true; const char* reason = nullptr; usize diff_at = 0; if (!guards_intact(ref_guard)) { case_ok = false; reason = "la REFERENCE a deborde son tampon de sortie"; } if (case_ok && p.opt != nullptr) { const usize opt_len = p.opt(in, c.in_len, opt_out, out_cap); if (!guards_intact(opt_guard)) { case_ok = false; reason = "l implementation optimisee a deborde son tampon"; } else if (opt_len != ref_len) { case_ok = false; reason = "longueur de sortie differente"; } else { diff_at = mem_first_diff(ref_out, opt_out, ref_len); if (diff_at != ref_len) { case_ok = false; reason = "octet divergent"; } } if (!case_ok) { err_write("ECHEC "); err_write(p.name); err_write(" / "); err_write(c.label); err_write("\n "); err_write(reason); err_write("\n"); err_write(" rejouer ce cas : graine="); err_write_i64(static_cast(c.seed)); err_write(" in_len="); err_write_i64(static_cast(c.in_len)); err_write(" align_in=+"); err_write_i64(c.in_align_offset); err_write(" align_out=+"); err_write_i64(c.out_align_offset); err_write("\n"); err_write(" longueurs : reference="); err_write_i64(static_cast(ref_len)); err_write(" optimisee="); err_write_i64(static_cast(opt_len)); err_write("\n"); if (diff_at < ref_len) { err_write(" premier octet divergent a l offset "); err_write_i64(static_cast(diff_at)); err_write(" : attendu="); err_write_hex(ref_out[diff_at]); err_write(" obtenu="); err_write_hex(opt_out[diff_at]); err_write("\n"); dump_context("attendu", ref_out, ref_len, diff_at); dump_context("obtenu ", opt_out, opt_len, diff_at); } } } if (!case_ok) { ++out.cases_failed; pair_ok = false; } work.rewind_to(mark); } if (pair_ok) { err_write(p.opt == nullptr ? "REF " : "OK "); err_write(p.name); if (p.opt == nullptr) { err_write(" (reference figee, version assembleur absente)"); } err_write("\n"); } // Un self-test attend un echec : dans ce cas, "reussi" veut dire "a bien // echoue". Sans cette inversion, on ne saurait pas prouver que le harnais // sait detecter une erreur connue. return expect_failure ? !pair_ok : pair_ok; } bool run_all(mem::Arena& work, Report& out) { bool ok = true; #if PROJ3_EMBEDDED for (const Pair* const* it = __start_proj3_pairs; it != __stop_proj3_pairs; ++it) { if (!run_pair(**it, work, out, false)) ok = false; } #else for (usize i = 0; i < g_pair_count; ++i) { if (!run_pair(*g_pairs[i], work, out, false)) ok = false; } #endif return ok; } } // namespace proj3::oracle