244 lignes
7.9 KiB
C++
244 lignes
7.9 KiB
C++
#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<u8>((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<u8>(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<i64>(begin));
|
|
err_write("..");
|
|
err_write_i64(static_cast<i64>(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<u8>(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<u8>(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<u8>(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<i64>(c.seed));
|
|
err_write(" in_len=");
|
|
err_write_i64(static_cast<i64>(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<i64>(ref_len));
|
|
err_write(" optimisee=");
|
|
err_write_i64(static_cast<i64>(opt_len));
|
|
err_write("\n");
|
|
if (diff_at < ref_len) {
|
|
err_write(" premier octet divergent a l offset ");
|
|
err_write_i64(static_cast<i64>(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
|